Transcript java memory - MHS Comp Sci

JAVA & MEMORY
What did I just say this topic was about ?
1
Purpose:
In this lecture series we will learn the
following:
How Java works with the memory of the
computer system
How Java primitives and class objects are
treated when used as arguments
Returning objects from functions and
methods
2
Resources: Java & Memory
Lambert Comprehensive Lecture
p. 9 – 14
C++ Chapter 1 Class Notes
Big Java Chapter 7 p.290-291
3
Handouts:
1. PassingAnObjrectExample.java
2. dateClass.java
4
Intro:
In this lecture Java & Memory,
understanding how java handles
computer memory is important when
allocating and modifying instances of
classes.
Also, the concept of passing by value
when dealing with primitives versus
references is a critical concept to
grasp.
5
Java and Memory:
John Von Neumann --- Princeton
Mathematician developed the idea that a
computer program can reside in memory
in the form of CPU instructions.
Most computers are based on the Von
Neuman Architecture.
Reasoned that all arithmetic operations
can be reduced to 3 simple Logical
operations: and(&&) , or (||) , not (!)
6
CPU --- central processing unit
Reads in “bits” of data from memory
Reads in and processes one
instruction at a time --- fetches the next
instruction from Memory, interprets its
code, performs the operation.
Consists of an instruction set and internal
registers
Registers are memory cells that are used
to hold memory addresses and
intermediate results
7
CPU --- central processing unit
Instruction sets include instructions for
loading CPU registers from memory,
logical and arithmetic operations, altering
the sequence of operations Internal
CLOCK and the CPU speed depends on
the frequency of the clock (MHZ --megahertz or million pulses per second).
8
CPU --- central processing unit
Bus --- parallel lines connecting the CPU
to memory. Computer performance is
dependant on Bus speed and width.
9
RAM --- Random Access Memory
Gas in the tank to engine analogy
Linear array of bits for storing information
Byte = a group of 8 bits
640K was thought of as enough.
Segment registers were added to get
memory to 1MEG.
32-bit memory that allows up to 4 gig of
memory
10
Computer memory
Each memory location holds one byte or a
single character of information.
1 Byte(8 bits)
Kilobyte (1024 or 2 to the 10th power)
Megabyte (1,024,000 or 2 to the 20th
power)
Gig (1,073,741,824 bytes of 2 to the 30th
power), Terabyte
11
Computer memory
Each computer memory location holds 8
bits or 1 byte because it takes a
combination Of 8 0’s and 1’s to represent
a character (ASCII)
Because each byte of memory Can hold
exactly 1 character: 8 bits = 1 byte
12
Computer memory
256 characters is 2 to the 8th power
ex/ A = 01000001 or ACSII value 65
bit = 0 or 1 state of electricity
8 bits = 1 byte
1 byte = 1 character
2 bytes = a computer word of memory
13
Computer memory
a BYTE counts bits from right to left
7 6 5 4 3 2 1 0 ---- 0 is least significant
bit/ low order bit [2 to 0 power]
7 is most significant/ high order bit
[2 to 7 power]
14
Computer memory
Binary (base 2 ) numbering system
000010001 in base 2 or binary = 17 in base
10
11111111 in base 2 or binary = 255 in dec
15
Computer memory
Refer to The Handout and discuss:
 Binary Math
Hexidecimal
16
Dynamic Storage Management --Global and STATIC variables are stored in
Static Storage
SPVM’s variables are stored in the
RUNTIME STACK along with any Static
functions’ variables

17
Dynamic Storage Management --Dynamically allocated memory, requested
by the NEW function, resides in The
memory HEAP
NEW – also invokes the class/objects
constructor
New provides us with a REFERENCE to
the actual HEAP location of an Object
18
SPVM // last function to exit
{
int Lint;
doit();
}
public static void doit()
{
int Lint;
String myString = new String;
}
19
Memory Allocation:
Stack
Growth
Doit’s stack

Main()’s
stack 
Static stack

Ref to
myString
Lint
LInt
Globals
HEAP “NEW”
myString stateful
properties
20
Memory Allocation:
Last function called is the first to exit
“UNWINDING THE STACK”
JAVA performs garbage collection for
heap memory that goes out of scope (no
longer used).
You can request garbage collection with
System.gc( );
21
TPS:
Given the code Handout, draw the
appropriate Memory Stack.
Be sure to allocate In the correct scope.
Illustrate how the stack will eventually
“Unwind”
22
Passing Arguments: Value VS Reference
Arguments to class methods or static
functions are Always passed by value
Even references to objects are passed by
value
By “value” we mean a COPY of the
argument is passed
23
How this works with primitive data types:
That is, when you pass a primitive data
type as an argument to a method, a
“copy” of that variable is passed. The
method called is passed the value in the
argument and it becomes , in effect, a
local variable of that method. This is
called “Call by Value”
24
 Example:
SPVM…
int a, b = 21;
a = myClassInstance.callAMethod( b );
CLASS…
public integer callAMethod( int x)
{
int z = 0;
x++;
z += x;
return z;
}
25
NOTE: the class method increments the
variable x, however the variable x is
LOCAL to the method and therefore the
integer passed in SPVM, b, IS NOT
modified
There is NO WAY in Java to explicitly pass
a primitive data type to a function or
method BY REFERENCE as they ARE
ALWAYS passed BY VALUE
26
TPS: See how this fits into the Memory
diagram (note local primitives have a
defined scope and can not be mutated
from outside that scope)
Write a similar program and see if you can
in any way get the original primitive
mutated by Calling a function & passing it
as an argument. Use System.out to
display the primitive throughout the
process.
27
How this works with OBJECTS:
Instances of Objects passed as arguments
to class methods or functions are also
passed BY VALUE
However, there is a major difference when
dealing with Instances of Objects
Remember that objects (implicitly as with
Strings or explicitly as with your own
classes) are DYNAMICALLY ALLOCATED
via the NEW operator
28
How this works with OBJECTS:
When you dynamically allocate an
instance of an Object as a class level
attribute or as a local variable you get a
REFERENCE (their memory address) to
that instances / objects ACTUAL memory
location in the HEAP
29
For Example:
Button b = new Button();
The variable b is NOT an object, it is
simply a REFERENCE to an object of type
Button, hence the term “reference
variable”
b is defined in the runtime stack and
simply POINTS to the place in the heap
where the ACTUAL Object is stored.
30
So when you pass an object instance as
an argument you are actually passing A
COPY OF THAT REFERENCE (memory
address)
Because the called method or function
now has the address of the actual
OBJECT INSTANCE the ORIGINAL object
instance can have its stateful properties
modified in the called routine
31
Example:
SPVM…
// imported is the dateclass as used in last
// years midterm dateClass.java
date myDate = new date();
System.out.println(myDate.toString());
System.out.println("and now the same
instancce AFTER the function call...");
changeDate(myDate);
System.out.println(myDate.toString());
32
Example:
static public void changeDate(date d)
{
d.setYear(2003);
return;
}
33
See that in SPVM we created an instance
of the class dateClass
The variable myDate became a reference
to the actual object (stateful properties )
and this object resides in the heap
Because we are passing a reference to an
object this argument is passing a copy of
the ACTUAL reference location of the
actual object
34
Therefore, when we call a set method for
this reference we ARE ACTUALLY
MODIFYING the original object !!!
Hence the output….
12-1900
And now the same instance AFTER the
function call...
12-2003
35
 TPS:
1. Illustrate this by using the Memory diagram
2. Write a simple date class consisting of:
m, d, y class level attributes
appropriate gets and sets
default constructor setting valies to 12 1 1900
overloaded constructor that accepts m,d,y
3. Create a wrapper class and import your date class
4. Add in a function that accepts & modifies a date
object (reference)
5. In SPVM create an instance of the date class and call
the function
6. Print out the states of the states of the object
Why does or why CAN the function mutate SPVM’s
local object ?
36
However, if you CHANGE the reference of
the passed argument to point to a new
object’s reference, the ORIGINAL object
will remain UNCHANGED
Example…
37
static public void changeDate(date d)
{
d.setYear(2003);
// now assign to a new date object and make a change
// since d will now refer to a different object
// any changes made to d will NOT BE REFLECTED in the
// original reference (in SPVM)
date localDate = new date(12,31,2001);
d = localDate;
System.out.println("local date var d After reassigned " +
localDate.toString());
return;
}
38
In this example we assign the local
reference to a different instance of the
date class
By doing so, we have ONLY modified the
local reference and NOT THE original
reference in SPVM
Therefore, any modifications made to the
local reference d are local to the
changeDate function
39
Hence the output from WITHIN the
function…
local date var d After reassigned 12-2001
However, the following statement from
SPVM will show it’s date variable “d” is
still 12-2003
System.out.println(myDate.toString());
40
TPS:
1.Illustrate this by using the Memory
diagram
2.Add in a function that accepts a date
object (reference) and assigns a local
instance of the date class
3.Print out the states of the states of the
object
Why can’t the function mutate SPVM’s
local object anymore ?
41
Things are a little different when dealing
with Strings:
When dealing with the String class, there
are no methods that mutate the state of
the string
42
Because Strings are immutable there is no
way to modify a string parameter passed
to a function or method (as can be done
with other objects)
Think of this as using the date class but
REMOVING the set methods !!!
43
TPS:
Comment out the date class set methods
and see if you are able to mutate the
SPVM object from A function
44
String myString = new String();
// you can also say: String myString = new String(“Hello”);
myString = “Hello “;
changeString(myString);
System.out.println(myString);
static public void changeString(String s)
{
s += " World";
System.out.println(s);
s = new String("xyz");
System.out.println(s);
return;
}
45
However, because objects' references are
passed by value, if we were to change the
reference of the object variable this
change IS NOT REFLECTED in the called
instance object as the reference s is a
COPY of the original
and when we say
s += " World"
WE ARE ACTUALLY doing
s = s + “ World”
46
In so doing the RVALUE uses the initial
state of s, Hello,
and adds World to a temporary reference
when the assignment, = , is made the
reference s is overwritten to point to a
new string reference
47
Because of this, the reference to s as was
initially passed in as an argument is NO
LONGER pointing to the original.
The original remains unchanged.
This is because the String is IMMUTABLE !!!
48
The console will display “Hello World” as
the function changeString is passed the
address of / reference to instance of the
object String , myString
Therefore, this function can call any of the
instance methods and modify accessible
stateful properties
49
This illustrates the fact that, in Java, a
method can change the state of an object
reference parameter, but it can not replace
the object reference with another
Hence the output for this is…
Hello World
xyz
Hello
50
TPS: Try this with strings (add to
your current program)
51
You can also return an instance of an
object
(you are returning a REFERENCE to that
instance)
from a method or function:
Example:
52
// return an object reference
date newDate = new
date(returnReference());
System.out.println(newDate); // implicit
// call to the date classes toString()
// method
static public date returnReference()
{
date localDate = new date(04,15,2002);
return localDate;
}
53
In this example, we are calling a function
that builds and returns a reference to a
new date object
We can do this because the date class has
an overloaded constructor that accepts as
an argument an instance of the date class
Hence the output:
04-2002
54
Lets take a closer look at this example by
also examining the date class code:
public date(date d)
{
this.setMonth(d.getMonth());
// could also say: this.month =
// d.month;
this.setYear(d.getYear());
this.setDay(d.getDay());
}
55
This example uses several concepts
that need to be reviewed
56
First, note that in SPVM we say
System.out.println(newDate);
We can do this because, by default, any
classes toString( ) method is implicitly
called when NO OTHER method is
invoked
57
Second, within the date class constructor we
see that the this reference is used
this refers to the instance of the class itself, in
our case it refers to the object referred to by
the reference variable newDate
The date argument passed in , d, refers to the
localDate created within the
returnReference( ) function
58
Also, if you were careful enough to read
the comment in the overloaded date
constructor you would See that we could
have simply assigned the class level
attributes directly !!!
The question that you should have is, how
can this be possible when these attributes
are PRIVATE and as such the attributes of
the object passed in to the constructor
SHOULD NOT BE AVAILABLE Outside the
class
59
Well, they are not actually OUTSIDE
the class
Since we are dealing with two
instances of the SAME class, WITHIN
the methods of the class ANY
instance can access the private
attributes of any other instance !!!
60
TPS:
Modify your date class to contain an
overloaded constructor that takes an
instance of itself as an argument.
Try out the various ways to accomplish the
copying of the stateful properties.
Use this
61
What are the implications of passing
references to methods or functions ?
You can not protect or encapsulate an
object instance once it is passed to a
method
In C++, you have the option of passing
arguments by value, by reference or by
constant reference
62
Projects:
Identify Arguments in MBS
Design Part of Tic-Tac-Toe
Object Based Bubble Sort
63
TEST IS THE DAY
AFTER THE
PROJECT IS DUE
!!!
64