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

1

Enhancing ClassesEnhancing 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

ReferencesReferences

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

The null ReferenceThe 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");

The null ReferenceThe 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

The this ReferenceThe 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();

The this referenceThe 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

Assignment RevisitedAssignment 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

Reference AssignmentReference Assignment

For object references, assignment copies the memory location:

bishop2 = bishop1;

Before

bishop1 bishop2

After

bishop1 bishop2

9

AliasesAliases

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

Testing Objects for EqualityTesting 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

Garbage CollectionGarbage 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

Objects as ParametersObjects 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

Passing Objects to MethodsPassing 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) See ParameterTester.java (page 279) See Num.java (page 280)

Note the difference between changing the reference and changing the object that the reference points to

ParameterPassing.javaParameterPassing.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"); }}

ParameterTester.javaParameterTester.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"); }}

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

The static ModifierThe 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

Static VariablesStatic 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

Static MethodsStatic 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

Static MethodsStatic 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

The static ModifierThe static Modifier

Static methods and static variables often work together

See CountInstances.java (page 284)

See Slogan.java (page 285)

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()); }}

Slogan.javaSlogan.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; }}

Wrapper ClassesWrapper 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


There is a wrapper class in the java.lang package for each primitive type:

Primitive Type

Wrapper Class

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

void Void


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

Keyboard Input RevisitedKeyboard 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

Reading Keyboard InputReading 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));


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


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)

I/O and exceptions are explored further in Chapter 8

Wages2.javaWages2.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)); }}

Nested ClassesNested 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


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


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

Inner ClassesInner 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)

See Outer.java (page 292)

TestInner.javaTestInner.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); }}

Outer.javaOuter.javapublic 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; }}}

SummarySummary

Chapter 5 has focused on:

• object references and aliases• passing objects references as parameters• the static modifier• wrapper classes• nested classes and inner classes

Documents

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