1. 1 Enhancing Classes  Now we can explore various aspects of classes and objects in more detail  Chapter 5 focuses on: object references and aliases passing objects references as parameters the static modifier wrapper classes nested classes and inner classes

2. 2 References  Recall from Chapter 2 that an object reference variable holds the memory address of an object  Rather than dealing with arbitrary addresses, we often depict a reference graphically as a “pointer” to an object ChessPiece bishop1 = new ChessPiece(); bishop1

3. The null Reference  An object reference variable that does not currently point to an object is called a null reference  The reserved word null can be used to explicitly set a null reference: name = null; or to check to see if a reference is currently null: if (name == null) System.out.println ("Invalid");

4. The null Reference  An object reference variable declared at the class level (an instance variable) is automatically initialized to null  The programmer must carefully ensure that an object reference variable refers to a valid object before it is used  Attempting to follow a null reference causes a NullPointerException to be thrown  Usually a compiler will check to see if a local variable is being used without being initialized

5. The this Reference  The this reference allows an object to refer to itself  That is, the this reference, used inside a method, refers to the object through which the method is being executed  Suppose the this reference is used in a method called tryMe  If tryMe is invoked as follows, the this reference refers to obj1 : obj1.tryMe();  But in this case, the this reference refers to obj2 : obj2.tryMe();

6. The this reference  The this reference can also be used to distinguish the parameters of a constructor from the corresponding instance variables with the same names public Account (Sring name, long acctNumber, double balance) { this.name = name; this.acctNumber = acctNumber; this.balance = balance; }

7. 7 Assignment Revisited  The act of assignment takes a copy of a value and stores it in a variable  For primitive types: num2 = num1; Before num1 5 num2 12 After num1 5 num2 5

8. 8 Reference Assignment  For object references, assignment copies the memory location: bishop2 = bishop1; Before bishop1bishop2 After bishop1bishop2

9. 9 Aliases  Two or more references that refer to the same object are called aliases of each other  One object (and its data) can be accessed using different reference variables  Aliases can be useful, but should be managed carefully  Changing the object’s state (its variables) through one reference changes it for all of its aliases

10. Testing Objects for Equality  The == operator compares object references for equality, returning true if the references are aliases of each other bishop1 == bishop2  A method called equals is defined for all objects, but unless we redefine it when we write a class, it has the same semantics as the == operator bishop1.equals(bishop2)  We can redefine the equals method to return true under whatever conditions we think are appropriate

11. 11 Garbage Collection  When an object no longer has any valid references to it, it can no longer be accessed by the program  The object is useless, and therefore is called garbage  Java performs automatic garbage collection periodically, returning an object's memory to the system for future use  In other languages, the programmer is responsible for performing garbage collection

12. Objects as Parameters  Parameters in a Java method are passed by value  This means that a copy of the actual parameter (the value passed in) is stored into the formal parameter (in the method header)  Passing parameters is therefore similar to an assignment statement  When an object is passed to a method, the actual parameter and the formal parameter become aliases of each other

13. Passing Objects to Methods  What you do with a parameter inside a method may or may not have a permanent effect (outside the method)  See ParameterPassing.java (page 277)ParameterPassing.java  See ParameterTester.java (page 279)ParameterTester.java  See Num.java (page 280)Num.java  Note the difference between changing the reference and changing the object that the reference points to

14. ParameterPassing.java ParameterPassing.java public class ParameterPassing { public static void main (String[] args) { ParameterTester tester = new ParameterTester(); int a1 = 111; Num a2 = new Num (222); Num a3 = new Num (333); System.out.println ("Before calling changeValues:"); System.out.println ("a1\ta2\ta3"); System.out.println (a1 + "\t" + a2 + "\t" + a3 + "\n"); tester.changeValues (a1, a2, a3); System.out.println ("After calling changeValues:"); System.out.println ("a1\ta2\ta3"); System.out.println (a1 + "\t" + a2 + "\t" + a3 + "\n"); }}

15. ParameterTester.java public class ParameterTester { public void changeValues (int f1, Num f2, Num f3) { System.out.println ("Before changing the values:"); System.out.println ("f1\tf2\tf3"); System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n"); f1 = 999; f2.setValue(888); f3 = new Num (777); System.out.println ("After changing the values:"); System.out.println ("f1\tf2\tf3"); System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n"); }}

16. Num.java Num.java public class Num { private int value; // Sets up the new Num object, storing an initial value. public Num (int update) { value = update; } // Sets the stored value to the newly specified value. public void setValue (int update) { value = update; } // Returns the stored integer value as a string. public String toString () { return value + ""; }}

17. 17 The static Modifier  In Chapter 2 we discussed static methods (also called class methods) that can be invoked through the class name rather than through a particular object  For example, the methods of the Math class are static: Math.sqrt (25)  To write a static method, we apply the static modifier to the method definition  The static modifier can be applied to variables as well  It associates a variable or method with the class rather than with an object

18. 18 Static Variables  Static variables are also called class variables  Normally, each object has its own data space, but if a variable is declared as static, only one copy of the variable exists private static float price;  Memory space for a static variable is created when the class in which it is declared is loaded  All objects created from the class share static variables  Changing the value of a static variable in one object changes it for all others

19. 19 Static Methods public static int triple (int num) { int result; result = num * 3; return result; } class Helper Because it is static, the method can be invoked as: value = Helper.triple (5);

20. 20 Static Methods  The order of the modifiers can be interchanged, but by convention visibility modifiers come first  Recall that the main method is static; it is invoked by the system without creating an object  Static methods cannot reference instance variables, because instance variables don't exist until an object exists  However, a static method can reference static variables or local variables

21. The static Modifier  Static methods and static variables often work together  See CountInstances.java (page 284)CountInstances.java  See Slogan.java (page 285)Slogan.java

22. CountInstances.java CountInstances.java public class CountInstances { public static void main (String[] args) { Slogan obj; obj = new Slogan ("Remember the Alamo."); System.out.println (obj); obj = new Slogan ("Don't Worry. Be Happy."); System.out.println (obj); obj = new Slogan ("Live Free or Die."); System.out.println (obj); obj = new Slogan ("Talk is Cheap."); System.out.println (obj); obj = new Slogan ("Write Once, Run Anywhere."); System.out.println (obj); System.out.println(); System.out.println ("Slogans created: " + Slogan.getCount()); }}

23. Slogan.java public class Slogan{ private String phrase; private static int count = 0; public Slogan (String str) { phrase = str; count++; } public String toString() { return phrase; } public static int getCount () { return count; }}

24. Wrapper Classes  A wrapper class represents a particular primitive type  For example Integer ageObj = new Integer (20); uses the Integer class to create an object which effectively represents the integer 20 as an object  This is useful when a program requires an object instead of a primitive type

25. Wrapper Classes  There is a wrapper class in the java.lang package for each primitive type: Primitive TypeWrapper Class byteByte shortShort intInteger longLong floatFloat doubleDouble charCharacter booleanBoolean voidVoid

26. Wrapper Classes  Wrapper classes contain static methods that help manage the associated type  For example, the Integer class contains a method to convert an integer stored in a String to an int value: num = Integer.parseInt (str);  The wrapper classes often contain useful static constants as well  For example, the Integer class contains MIN_VALUE and MAX_VALUE which hold the smallest and largest int values

27. Keyboard Input Revisited  The Keyboard class was introduced in Chapter 2 to facilitate capturing input from the keyboard  Recall that the Keyboard class was written by the authors of the book  The Keyboard class hides various aspects of Java input processing  But it is important to understand how that processing works

28. Reading Keyboard Input  Java I/O is accomplished using objects that represent streams of data  A stream is an ordered sequence of bytes  The System.out object represents a standard output stream, which defaults to the monitor screen  Reading keyboard input is more complicated  The input stream is made up of multiple objects: BufferedReader in = new BufferedReader ( new InputStreamReader (System.in));

29. Reading Keyboard Input  The System.in object is used to create an InputStreamReader object  The InputStreamReader object is used to create a BufferedReader object  This creates an input stream that treats input as characters and buffers them so that input can be read a line at a time  The readLine method of the BufferedReader class reads an entire line of input as a String  Wrapper class methods can be used to convert numeric input

30. Reading Keyboard Input  Problems that arise in reading or converting a value manifest themselves as exceptions  The throws clause of a method header indicates what exceptions it may throw  See Wages2.java (page 289)Wages2.java  I/O and exceptions are explored further in Chapter 8

31. Wages2.java import java.io.*; import java.text.NumberFormat; public class Wages2 { public static void main (String[] args) throws IOException { BufferedReader in = new BufferedReader (new InputStreamReader (System.in)); String name; int hours; double rate, pay; System.out.print ("Enter your name: "); name = in.readLine (); System.out.print ("Enter the number of hours worked: "); hours = Integer.parseInt (in.readLine()); System.out.print ("Enter pay rate per hour: "); rate = Double.parseDouble (in.readLine()); System.out.println (); pay = hours * rate; NumberFormat fmt = NumberFormat.getCurrencyInstance(); System.out.println (name + ", your pay is: " + fmt.format(pay)); }}

32. Nested Classes  In addition to containing data and methods, a class can contain other classes  A class declared within another class is called a nested class Enclosing Class Nested Class

33. Nested Classes  A nested class has access to the variables and methods of the enclosing class, even if they are declared private  In certain situations this makes the implementation of the classes easier because they can share information easily  Furthermore, the nested class can be protected by the enclosing class from external use  This is a special relationship and should be used with care

34. Nested Classes  A nested class produces a separate bytecode file  If a nested class called Inside is declared in an outer class called Outside, two bytecode files are produced: Outside.class Outside$Inside.class  Nested classes can be declared as static, in which case they cannot refer to instance variables or methods

35. Inner Classes  A nonstatic nested class is called an inner class  An inner class is associated with each instance of the enclosing class  An instance of an inner class can exist only within an instance of an enclosing class  See TestInner.java (page 291)TestInner.java  See Outer.java (page 292)Outer.java

36. TestInner.java public class TestInner { public static void main (String[] args) { Outer out = new Outer(); System.out.println (out); System.out.println(); out.changeMessages(); System.out.println (out); }}

37. Outer.java public class Outer { private int num; private Inner in1, in2; public Outer() {num = 9876; in1 = new Inner ("Half of the problem is 90% mental."); in2 = new Inner ("Another deadline. Another miracle."); } public void changeMessages() { in1.message = "Life is uncertain. Eat dessert first."; in2.message = "One seventh of your life is spent on Mondays."; } public String toString() { return in1 + "\n" + in2; } private class Inner { public String message; public Inner (String str) { message = str; } public String toString() { num++; return message + "\nOuter num = " + num; }}}

38. Summary  Chapter 5 has focused on: object references and aliases passing objects references as parameters the static modifier wrapper classes nested classes and inner classes