View
220
Download
0
Tags:
Embed Size (px)
Citation preview
Using finalUsing final
We use the notion of We use the notion of constant dataconstant data to represent data that to represent data that cannot be changed.cannot be changed.
public class Testpublic class Test
{{
static final int someInt = 10;static final int someInt = 10;
//…//…
someInt = 9; someInt = 9; // // ERRORERROR
//…//…
}}
Using finalUsing final
What happens when we want a constant What happens when we want a constant objectobject??
public class Circle {public class Circle {
private double radius;private double radius;
public Circle(double r) {public Circle(double r) {
radius = r;radius = r;
}}
public void setRadius(double r) {public void setRadius(double r) {
radius = r;radius = r;
}}
public double getRadius() { public double getRadius() {
return radius; return radius;
}}
}}
Using FinalUsing Final
public class FinalTestpublic class FinalTest
{{
private static final Circle wheel = new Circle(5.0);private static final Circle wheel = new Circle(5.0);
public static void main(String[] args) {public static void main(String[] args) {
System.out.println(“radius is “ + wheel.getRadius());System.out.println(“radius is “ + wheel.getRadius());
wheel.setRadius(7.4);wheel.setRadius(7.4);
System.out.println(“now the radius is “ + System.out.println(“now the radius is “ +
wheel.getRadius());wheel.getRadius());
}}
}}
Using FinalUsing Final
The output of the code is:The output of the code is:
radius is 5.0radius is 5.0
now the radius is 7.4now the radius is 7.4
How can the wheel object change values when we How can the wheel object change values when we specifically declared it final???specifically declared it final???
We did not change the We did not change the valuevalue of the variable wheel. of the variable wheel.
We changed the We changed the content of the objectcontent of the object that wheel references. that wheel references.
Using finalUsing final
What if we try the following code:What if we try the following code:
public class FinalTestpublic class FinalTest
{{
private static final Circle wheel = new Circle(5.0);private static final Circle wheel = new Circle(5.0);
public static void main(String[] args) {public static void main(String[] args) {
System.out.println(“radius is “ + wheel.getRadius());System.out.println(“radius is “ + wheel.getRadius());
wheel = new Circle(7.4) ;wheel = new Circle(7.4) ;
System.out.println(“now the radius is “ + System.out.println(“now the radius is “ +
wheel.getRadius());wheel.getRadius());
}}
}}
Using FinalUsing Final
Compiling this code results in what we expect:Compiling this code results in what we expect:
FinalTest.java:9: Can’t assign a value to a final variable: wheelFinalTest.java:9: Can’t assign a value to a final variable: wheel
wheel = new Circle(7.4);wheel = new Circle(7.4);
^̂
1 error1 error
There is an error because we are attempting to modify There is an error because we are attempting to modify the reference which was defined as final.the reference which was defined as final.• The reference is final and thus immutable.The reference is final and thus immutable.• The object itself is not affect and thus is mutable.The object itself is not affect and thus is mutable.
Arrays vs. VectorsArrays vs. Vectors
• Java provides two constructs, an array and a Vector, Java provides two constructs, an array and a Vector,
which appear to be similar.which appear to be similar.• In fact, the array and Vector are altogether different.In fact, the array and Vector are altogether different.• It is important to understand the differences between It is important to understand the differences between
the two, in order to write efficient code.the two, in order to write efficient code.
Arrays summaryArrays summary
• Arrays have fixed size - after creating an array, you Arrays have fixed size - after creating an array, you cannot add more elements than its maximum size. If cannot add more elements than its maximum size. If you do, you will get an you do, you will get an ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException
• In Java, arrays are objects, so any methods contained In Java, arrays are objects, so any methods contained in java.lang.Object can be invoked on them.in java.lang.Object can be invoked on them.
• In order to find the length of the array, use the public In order to find the length of the array, use the public variable variable lengthlength..
int[] ia = new int[N];int[] ia = new int[N];
System.out.println(“ia length is “ + ia.length);System.out.println(“ia length is “ + ia.length);
Arrays summaryArrays summary
• Arrays can hold both primitive types and object Arrays can hold both primitive types and object
references.references.
Default values are used for each entry, based on its type.Default values are used for each entry, based on its type.
TypeType Default valueDefault value
booleanboolean falsefalse
charchar ‘‘\u0000’\u0000’
shortshort 00
intint 00
longlong 00
floatfloat 0.00.0
doubledouble 0.00.0
object referenceobject reference nullnull
Vectors summaryVectors summary
• An Vector grow its size dynamically when more An Vector grow its size dynamically when more
elements are added than its current size can elements are added than its current size can
accommodate.accommodate.• As elements get deleted, each element with an index As elements get deleted, each element with an index
greater than the index being removed is shifted greater than the index being removed is shifted
downward.downward.• Unlike arrays, you call a Unlike arrays, you call a methodmethod on a Vector to on a Vector to
determine its size.determine its size.
Vector v = new Vector();Vector v = new Vector();
System.out.println(“v length is “ + v.size());System.out.println(“v length is “ + v.size());
Vectors summaryVectors summary
• The Vector’s size measures the number of elements it The Vector’s size measures the number of elements it
holds.holds.
Thus, the Vector’s size may vary, unlike the array’s Thus, the Vector’s size may vary, unlike the array’s
size which is fixed.size which is fixed.• A vector is implemented in terms of an array of A vector is implemented in terms of an array of
java.lang.Object.java.lang.Object.
That is, when it grows, or shrinks, the entire array That is, when it grows, or shrinks, the entire array
must be reallocated and copied.must be reallocated and copied.
This may cause performance problems if Vectors are This may cause performance problems if Vectors are
not used properly.not used properly.
Vectors summaryVectors summary
• Finally, a Vector may contain only Finally, a Vector may contain only object referencesobject references an an
not primitive types.not primitive types.
Vector v = new Vector();Vector v = new Vector();
v.add(new Turtle()); v.add(new Turtle()); // OK// OK
v.add(5); v.add(5); // // ERRORERROR
Integer i = new Integer(5);Integer i = new Integer(5);
v.add(i);v.add(i); // OK// OK
Arrays vs. VectorsArrays vs. Vectors
If you are working with a primitive type, consider using If you are working with a primitive type, consider using an array instead of Vector.an array instead of Vector.
Support Support for for
primitive primitive typestypes
Support Support for objectsfor objects
Auto sizeAuto size fastfast
ArrayArray YesYes YesYes NoNo YesYes
VectorVector NoNo YesYes YesYes NoNo
Memory ManagementMemory Management
• Java provides an automatic memory management with its garbage collection.
• For this reason, free and delete are unnecessary.• This may lead some programmers to ignore memory issues.• The garbage collector frees memory held by an object only if
the object is no longer being referenced.
Turtle one = new Turtle();
Turtle two = one;one two
one = null;
two = null;
Oops, killing turtles is
against the law
15
Memory ManagementMemory Management
• There are many implementation for the garbage collection algorithm as there are numerous JVMs.
• Multiple invocations might be needed to reclaim an unreferenced object.
Runtime rt = Runtime.getRuntime();
long mem = rt.freeMemory();
System.out.println(“Free memory is: “ + mem);
//…
System.gc();
//…
mem = rt.freeMemory();
System.out.println(“Free memory is now: “ + mem);
16
Memory ManagementMemory Management
• Problems can arise when objects contain instance variables that is initialized in the constructor and consumes large amounts of memory:
public class Customers {
private int[] cusIdArray;
public Customers(String filename) {
int num = // read amount from file
cusIdArray = new int[num];
for (int i=0; i<num; i++)
cusIdArray[i] = // value from the file
}
}
Memory ManagementMemory Management
• Suppose we want to display all the ids to the screen:
public class Display {
public static void main(String[] args) {
Customers cust = new Customers();
// display the ids to the screen
// Customers object is no longer needed.
//…
// the rest of the application
}
}
Assume there are 20,000 different customers !!!
Memory ManagementMemory Management
• One solution is to set the local variable cust to null, after it is used.
public class Display {
public static void main(String[] args) { Customers cust = new Customers(); // display the ids to the screen // Customers object is no longer needed. //… cust = null; // the rest of the application }}
Memory ManagementMemory Management
• What if you need to keep the cust object, but have limited use for the cusIdArray, after it is displayed ?
The solution above works, but has a potential negative implications. We may need to handle the case that the array is needed but no longer valid.
public class Customers {
// … same code as above
public void resetCust() {
cusIdArray = null;
}
}
public static void main(String[] args) { Customers cust = new Customers(); // display the ids to the screen // Customers object is no longer needed. //… cust.resetCust(); // the rest of the application}
Objects and EqualityObjects and Equality
• Java provides two different types: reference types and primitives. In addition wrapper classes are provided for each primitive type.
Primitive TypePrimitive Type Wrapper classWrapper class
booleanboolean BooleanBoolean
charchar CharacterCharacter
bytebyte ByteByte
shortshort ShortShort
intint IntegerInteger
longlong LongLong
floatfloat FloatFloat
doubledouble DoubleDouble
Objects and EqualityObjects and Equality
• References and primitives behave altogether differently and have different semantics.
int i = 5;
Integer j = new Integer(10);
• Both primitives and references are stored and manipulated on the Java operand stack.
• Objects are stored in memory heap.
jj
5 // i’s value5 // i’s value
stack heap
Integer10
Objects and EqualityObjects and Equality
• Using a primitive type eliminates the need to call new and create an object - this saves time and space.
• Mixing primitives and objects can also create unexpected results with regard to assignment.
int a = 1;
int b = 2;
Point x = new Point(0,0);
Point y = new Point(1,1);
System.out.println(“a is “ + a);
System.out.println(“b is “ + b);
System.out.println(“x is “ + x);
System.out.println(“y is “ + y);
Objects and EqualityObjects and Equality
// performing assignment and setLocation
a = b;
a++;
x = y;
x.setLocation(5,5);
System.out.println(“a is “ + a);
System.out.println(“b is “ + b);
System.out.println(“x is “ + x);
System.out.println(“y is “ + y);
Objects and EqualityObjects and Equality
The output for the code is:
a is 1
b is 2
x is java.awt.Point[x=0,y=0]
y is java.awt.Point[x=1,y=1]
a is 3
b is 2
x is java.awt.Point[x=5,y=5]
y is java.awt.Point[x=5,y=5] y has also changed!
Objects and EqualityObjects and Equality
Point(0,0)
Point(1,1)
x
y
Point x = new Point(0,0);
Point y = new Point(1,1);
Point(0,0)
Point(1,1)
x
y
x = y;
Point(0,0)
Point(5,5)
x
y
x.setLocation(5,5);
Differentiate between == and Differentiate between == and equalsequals
What is the difference between the == operator and the equals method? Isn’t == good enough?
Public class Test{ public static void main(String[] args) { int a = 10; int b = 10; System.out.println(“a==b is “ + (a==b)); Integer ia = new Integer(10); Integer ib = new Integer(10); System.out.println(“ia==ib is “ + (ia==ib)); }}
Differentiate between == and Differentiate between == and equalsequals
The output for this code is:
a==b is true
ia==ib is false
What went wrong?
• a and b are of type int, and as such, they are of primitive
type.• ia and ib are object references and reference Integer
objects.
Differentiate between == and Differentiate between == and equalsequals
• a and b have the same value of 10.• The object references, ia and ib are really references to
two different Java Integer Objects that have the value 10. • The values of ia and ib are not 10 but rather unique
values that represent the two objects.
The == operator tests for equality. Is the thing on the
left-hand side of the == the same as the thing on the
right-hand side?
How do you test to see whether the values referenced by ia and ib are equal? This is where you use the equals method.