Using final We use the notion of constant

Using final We use the notion of constant data to represent data that cannot be changed. public class Test { static final int some. Int = 10; //… some. Int = 9; // ERROR //… }

Using final What happens when we want a constant object? public class Circle { private double radius; public Circle(double r) { radius = r; } public void set. Radius(double r) { radius = r; } public double get. Radius() { return radius; } }

Using Final public class Final. Test { private static final Circle wheel = new Circle(5. 0); public static void main(String[] args) { System. out. println(“radius is “ + wheel. get. Radius()); wheel. set. Radius(7. 4); System. out. println(“now the radius is “ + wheel. get. Radius()); } }

Using Final The output of the code is: radius is 5. 0 now the radius is 7. 4 How can the wheel object change values when we specifically declared it final? ? ? We did not change the value of the variable wheel. We changed the content of the object that wheel references.

Using final What if we try the following code: public class Final. Test { private static final Circle wheel = new Circle(5. 0); public static void main(String[] args) { System. out. println(“radius is “ + wheel. get. Radius()); wheel = new Circle(7. 4) ; System. out. println(“now the radius is “ + wheel. get. Radius()); } }

Using Final Compiling this code results in what we expect: Final. Test. java: 9: Can’t assign a value to a final variable: wheel = new Circle(7. 4); ^ 1 error There is an error because we are attempting to modify the reference which was defined as final. • The reference is final and thus immutable. • The object itself is not affect and thus is mutable.

Arrays vs. Vectors • Java provides two constructs, an array and a Vector, which appear to be similar. • In fact, the array and Vector are altogether different. • It is important to understand the differences between the two, in order to write efficient code.

Arrays summary • • • Arrays have fixed size - after creating an array, you cannot add more elements than its maximum size. If you do, you will get an Array. Index. Out. Of. Bounds. Exception In Java, arrays are objects, so any methods contained in java. lang. Object can be invoked on them. In order to find the length of the array, use the public variable length. int[] ia = new int[N]; System. out. println(“ia length is “ + ia. length);

Arrays summary • Arrays can hold both primitive types and object references. Default values are used for each entry, based on its type. Type Default value boolean false char ‘u 0000’ short 0 int 0 long 0 float 0. 0 double 0. 0 object reference null

Vectors summary • An Vector grow its size dynamically when more elements are added than its current size can accommodate. • As elements get deleted, each element with an index greater than the index being removed is shifted downward. • Unlike arrays, you call a method on a Vector to determine its size. Vector v = new Vector(); System. out. println(“v length is “ + v. size());

Vectors summary • The Vector’s size measures the number of elements it holds. Thus, the Vector’s size may vary, unlike the array’s size which is fixed. • A vector is implemented in terms of an array of java. lang. Object. That is, when it grows, or shrinks, the entire array must be reallocated and copied. This may cause performance problems if Vectors are not used properly.

Vectors summary • Finally, a Vector may contain only object references an not primitive types. Vector v = new Vector(); v. add(new Turtle()); // OK v. add(5); // ERROR Integer i = new Integer(5); v. add(i); // OK

Arrays vs. Vectors If you are working with a primitive type, consider using an array instead of Vector. Support for primitive types Support for objects Auto size fast Array Yes No Yes Vector No Yes No

Memory 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 = null; two = null; Oops, killing turtles two is one against the law

Memory 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. get. Runtime(); long mem = rt. free. Memory(); System. out. println(“Free memory is: “ + mem); //… System. gc(); //… mem = rt. free. Memory(); System. out. println(“Free memory is now: “ + mem); 15

Memory 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[] cus. Id. Array; public Customers(String filename) { int num = // read amount from file cus. Id. Array = new int[num]; for (int i=0; i<num; i++) cus. Id. Array[i] = // value from the file } } 16

Memory 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 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 Management What if you need to keep the cust object, but have limited use for the cus. Id. Array, after it is displayed ? • public class Customers { // … same code as above public void reset. Cust() { cus. Id. Array = null; } } public static void main(String[] args) { Customers cust = new Customers(); // display the ids to the screen // Customers object is no longer needed. //… cust. reset. Cust(); // the rest of the application } 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.

Objects and Equality • Java provides two different types: reference types and primitives. In addition wrapper classes are provided for each primitive type. Primitive Type Wrapper class boolean Boolean char Character byte Byte short Short int Integer long Long float Float double Double

Objects 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. stack 5 // i’s value j heap Integer 10

Objects 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 Equality // performing assignment and set. Location a = b; a++; x = y; x. set. Location(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 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 has also changed!

Objects and Equality x Point (0, 0) y Point (1, 1) y Point (5, 5) Point x = new Point(0, 0); Point y = new Point(1, 1); x = y; x. set. Location(5, 5);

Differentiate between == and equals 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 equals 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 equals 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.