Using final

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

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

3. Using Final public class FinalTest { private static final Circle wheel = new Circle(5.0); public static void main(String[] args) { System.out.println(“radius is “ + wheel.getRadius()); wheel.setRadius(7.4); System.out.println(“now the radius is “ + wheel.getRadius()); } }

4. 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.

5. Using final What if we try the following code: public class FinalTest { private static final Circle wheel = new Circle(5.0); public static void main(String[] args) { System.out.println(“radius is “ + wheel.getRadius()); wheel = new Circle(7.4) ; System.out.println(“now the radius is “ + wheel.getRadius()); } }

6. Using Final Compiling this code results in what we expect: FinalTest.java:9: Can’t assign a value to a final variable: wheel 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.

7. 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.

8. 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 ArrayIndexOutOfBoundsException • 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);

9. Arrays summary Arrays can hold both primitive types and object references. Default values are used for each entry, based on its type.

10. 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());

11. 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.

12. 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

13. Arrays vs. Vectors If you are working with a primitive type, consider using an array instead of Vector.

14. 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. Oops, killing turtles is against the law one two Memory Management Turtle one = new Turtle(); Turtle two = one; one = null; two = null;

15. 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); Memory Management

16. 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 Management

17. 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 } } Memory Management Assume there are 20,000 different customers !!!

18. 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

19. What if you need to keep the cust object, but have limited use for the cusIdArray, after it is displayed ? Memory Management 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 } 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.

20. Java provides two different types: reference types and primitives. In addition wrapper classes are provided for each primitive type. Objects and Equality

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

22. 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. Objects and Equality 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);

23. Objects 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);

24. 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 Equality

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

26. 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

27. The output for this code is: a==b is true ia==ib is false What went wrong? Differentiate between == and equals • 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.

28. 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.