COE318 Lecture Notes Week 6 (Oct 10, 2011)

Transcription

1 COE318 Software Systems Lecture Notes: Week 6 1 of 8 COE318 Lecture Notes Week 6 (Oct 10, 2011) Topics Announcements final qualifiers Example: An alternative to arrays == vs..equals(...): A first look Stack and Heap details Announcements Midterm: Monday, October 17, 2011 The final qualifier When an instance or class variable is declared final it's value can only be set once; any subsequent attempt to change its value results in a run-time error (exception). Immutable instance variables should normally be declared final. Hence, immutable objects should have all their instance variables declared as final. Class variables (declared as static) used as constants should also be declared final. Here's an example taken from the source code for the Math class: public static final double PI = ; (Note: it is rare for constants not to be static.) Note also that PI is uppercase. It is a common convention to make public static final constants all uppercase. Later in the course (once inheritance and overriding have been covered), we shall see other uses for final : A final class cannot be subclassed. (The String class is final). A final method cannot be overridden in a subclass.

2 COE318 Software Systems Lecture Notes: Week 6 2 of 8 Below is an example of using the static and final qualifiers in a simple class. Note that getnumrs() is a static method and helongs to the class, not an individual object. Hence, it can be invoked even if no Resistor objects exist. public class Resistor { public static int getnumrs() { return numrs; private final double resistance; private static int numrs; private int id; public double getresistance() { return resistance; public Resistor(double resistance) { this.resistance = resistance; numrs++; id = numrs; public String getname() { return "R" + id; public static void main(string[] args) { System.out.println("Before creating Rs; # Rs = " + Resistor.getNumRs()); Resistor w = new Resistor(10); System.out.println(w.getName() + " " + w.resistance); Resistor x = new Resistor(20); System.out.println(x.getName() + " " + x.resistance); Resistor y = new Resistor(50); System.out.println(y.getName() + " " + y.resistance);

3 COE318 Software Systems Lecture Notes: Week 6 3 of 8 Example: making a flexible array Suppose we want to put a bunch of resistors into a collection and we don't know at the outset how many resistors will be in the collection. Arrays are not a good solution for a case like this because the size is determined at creation time and cannot be made bigger later on. One solution is the following ResistorCollection class: public class ResistorCollection { private int n = 0; private Resistor[] resistors = new Resistor[2]; public void add(resistor r) { if (n >= resistors.length) { Resistor[] tmp = new Resistor[2 * resistors.length]; for (int i = 0; i < n; i++) { tmp[i] = resistors[i]; resistors = tmp; resistors[n] = r; n++; public Resistor get(int i) { return resistors[i]; public int size() { return n; We initially have an array of Resistors only big enough to hold 2 resistors. What happens when we try to add a third Resistor. Our array is too small, so we create a brand new array twice as big as the one that was too small. We now have two arrays; one twice as big as the other. We now copy all of hte smaller array (which is full) into the first half of the new array.

4 COE318 Software Systems Lecture Notes: Week 6 4 of 8 Finally, we set re3sistors to reference the new, bigger array. Now we can add the third resistor! This trick makes it seem that we can make arrays bigger at run time...but that is just an illusion, we simply made a new bigger array. Using ArrayList This is such a good idea that it is incorporated into the Java standard libary with ArrayList. ArrayList does what ResistorCollection does (and a lot more) and it can be used for any kind of object. Below is the same program using ArrayList: import java.util.arraylist; public class ArrayListCollection { public static void main(string[] args) { ArrayList<Resistor> hipower = new ArrayList<Resistor>(); ArrayList<Resistor> lopower = new ArrayList<Resistor>(); Resistor[] lows = {new Resistor(10), new Resistor(20), new Resistor(30); for (int i = 0; i < lows.length; i++) { lopower.add(lows[i]); Resistor[] highs = {new Resistor(100), new Resistor(200), new Resistor(1300); for (int i = 0; i < highs.length; i++) { hipower.add(highs[i]); for (int i = 0; i < lopower.size(); i++) { System.out.println("" + lopower.get(i).getname() + " " + lopower.get(i).getresistance());

5 COE318 Software Systems Lecture Notes: Week 6 5 of 8 //OR, better, use a "for-each" loop for (Resistor r : hipower) { System.out.println("" + r.getname() + " " + r.getresistance()); Another kind of for loop: for-each Look at: for (Resistor r : hipower) { System.out.println("" + r.getname() + " " + r.getresistance()); Read for (Resistor r : hipower) as if it said : for each Resistor r in hipower and each time through the loop the variable r will be the next Resistor in the collection. No need for index variables! The for-each loop can be used for ArrayLists and many other collections; it can also be used with simple arrays. For example,if arr is an array of Resistors, instead of: for(int i = 0; i < arr.length; i++) { System.out.println(arr[i].getResistance()); you can write: for(resistor r : arr) { System.out.println(r.getResistance()); More details: Stack and Heap Recall:

6 COE318 Software Systems Lecture Notes: Week 6 6 of 8 local variables and parameters are allocated on the stack and exist only during the the time the method they are declared in is running; instance variables exist in the memory allocated on the heap for the object they belong to; they continue to exist until the object is garbage collected. Initial values: Initial value means the value assigned after a variable is declared but before it is explicitly set to a definite value. Local variables have random initial values. (This is why the compiler will complain if you try to use a local variable before you have set its value.) Instance variables have initial values of zero when an object is created. Why? Because the area in the heap allocated for the object they belong to has all of the bytes for the instance variables set to 0x00. This means that the initial values of all reference variables are null and the values for primitive data types are zero for numbers (byte, short, int, long, float and double), '\0' for chars and false for booleans. Consider now the following class: public class G { private int id; public G(int id) { this.id = id; public void incr(int i) { id += i; public static void main(string[] args) { G g, h; int i = 3; g = new G(4); h = new G(8); g.incr(i - 2); i++; h.incr(i); System.out.println("g.id = " + g.id); System.out.println("h.id = " + h.id);

7 COE318 Software Systems Lecture Notes: Week 6 7 of 8 Convince yourself that the output will be: g.id = 5 h.id = 12 The diagram below illustrates what the stack and heap look like when we are in the incr method called with g.incr(i 2). Note that there is a stack frame associated with the main method below the stack frame of the incr method. A method can only access local variables and parameters in its own frame. So incr cannot access the local variables of the main method. == vs. equals(...) For primitive data types (int, double, boolean, char, etc.) the only way to test if two values are equal is with ==; thus if i and j are ints then (i == j) is true if and only if they both have the same value. For reference data types, however, you can test for different types of equality : It is legal (but usually wrong) to use == just as with primitive types. Two reference objects

8 COE318 Software Systems Lecture Notes: Week 6 8 of 8 are equal in this sense only if they refer to the identical object. The equals(...) method is almost always the correct way to check for equality of two reference variables. Consider the example below (where we assume a ComplexNukber class similar to what you did in the lab except that it has an equals() method that returns true if both complex numbers have exactly the same real and imaginary parts.) ComplexNumber w, y, z; w = new ComplexNumber(1, 2); z = new ComplexNumber(1, 2); y = z; //Now w == z is false; they are different objects! //But w.equals(z) is true since they represent the same //complex number. //Both y == z and y.equals(z) are true since they are //the same object. Questions 1.