Issues
Enhancing Administrative Classes
Lecture 13 Ongoing
Program 3 due June 13th
Today
Homework 3 assigned
Due June 11th
Object References Object References
Variables have been one of two varieties
Primitive Data Types Object References
Object Reference Variable and the Object are two different things Recall the two steps:
Declare an object reference variable Then create a new object
Allocation & Instantiation
1. Declaration allocates space for an object reference Use of the new operator constructs a new instance of an object The assignment operator stores a reference to the newly created object
DeskLamp myLamp; myLamp = new DeskLamp(100);
The null Reference
An object reference variable that doesnt point to an object is a null reference Reserved word null represents a null reference
String name; // Uninitialized, so a null reference if (name == null) System.out.println(Name is a null reference.);
2.
3.
myLamp null
NullPointerException
Dont call a method from a null reference
NullPointerException thrown Halts the program Exceptions in Section 8.0
Coming soon
String name; // Uninitialized, so a null reference System.out.println(name.length()); // NullPointerException thrown here
NullPointerException
Avoid exceptions by checking for null references Use an if statement and the reserved word null
String name; // Uninitialized, so a null reference // Use if statement to detect a null reference if (name == null) System.out.println(Null reference, Length undefined); else System.out.println(name.length());
Back to Object References
Object references store the memory address of an object When declaring a variable, a null reference is allocated
HondaCivic myCar; Without instantiation, myCar is null
Object References
When new is called, a new instance is created someplace in memory After assignment, the variable points to that memory address myCar = new HondaCivic(); Pointer Relationship depicted below
null myCar
myCar
How it Works
HondaCivic myCar; Everything stored as bytes in memory myCar reference has a spot in memory
Example: myCar at 1502
myCar 1502
How it Works
myCar = new HondaCivic(); null The new operator creates a new instance of the Car class
Reserves enough memory to hold the HondaCivic object Constructor is called to initialize the values of any instance variables myCar 1502 null (0)
1503 1504 9101 9102 9103 9104
1503 1504 9101 9102 9103 9104
Example
A new HondaCivic at starting at location 9102 and spanning many bytes
How it Works
HondaCivic myCar; myCar = new HondaCivic();
myCar 1502
Object References
9102
The assignment stores the starting address of the object in the reference variable The object reference REFERS to the location of the object
It points to the object
1503 1504 9101 9102 9103 9104
A second variable with a second call to new will produce a second object myCar = new HondaCivic(); yourCar = new HondaCivic();
myCar
yourCar
Object Reference Equality
What does (myCar == yourCar) mean? True if the references point to the same object As depicted, false To compare if the two objects are alike, you must define a method such as equals() with Strings
Reference Assignment
What happens during an assignment statement? myCar = yourCar;
myCar
yourCar
myCar
yourCar
Aliases
yourCar and myCar are now aliases for the same object (yourCar == myCar) is true! Any changes to myCar also change yourCar!
Aliasing Example
// Instantiate a lamp DeskLamp myLamp = new DeskLamp(100); // Create an alias to myLamp DeskLamp yourLamp = myLamp; // Turn on myLamp and print out the status myLamp.turnOn(); System.out.println(myLamp.isOn()); // Turn off yourLamp and print out myLamps status yourLamp.turnOff(); System.out.println(myLamp.isOn());
myCar
yourCar
Output: true false
Garbage
What happens to the green car? With no pointers, its garbage
Garbage is unreferenced memory
Garbage Collection
Java provides automatic garbage collection Memory designated as garbage is cleaned up and released An objects memory is collected when no variables reference it
Can never get new pointer to garbage: ITS LOST!
myCar
yourCar
myCar
yourCar
Swapping References
To swap two references, same algorithm as used when swapping primitive data
tempCar
2 Minute Exercise
What happens when this code fragment is executed?
HondaCivic car1 = new HondaCivic(Green); HondaCivic car2 = new HondaCivic(Blue); car2 = car1; car1 = car2; System.out.println(Color 1 is + car1.getColor()); System.out.println(Color 2 is + car2.getColor()); car1 = null; car1 = car2; System.out.println(Color 1 is + car1.getColor()); System.out.println(Color 2 is + car2.getColor()); car2 = null; System.out.println(Color 1 is + car1.getColor()); System.out.println(Color 2 is + car2.getColor());
myCar
yourCar
The this Reference The this Reference
The this reference refers to the currently executing object Example
In a class BankAccount, a method might compare the account numbers of two accounts The method could contain the following:
if (this.acctNum == otherAcct.acctNum) return true;
The this Reference
In this example, this simply clarifies that you meant the account number of the currently executing object, not the otherAcct object In this example, the this keyword is optional
if (this.acctNum == otherAcct.acctNum) return true;
Distinguishing Parameters
Examine the following class definition The reserved word this resolves the variable scope
In this example, this is required!
public class Athlete { String name; int jerseyNum; // with Constructor name conflicts public Athlete(String name, int jerseryNum) { this.name = name; // name is of local scope this.jerseyNum = jerseyNum; } }
finalize() Method The finalize() Method
Just before being collected, the finalize() method is called Used for cleaning up
Perhaps closing an open file Printing out some messages to screen Any task that must be done at the very end
Takes no parameters Returns type void You can define a finalize() method for any class your create
finalize() Example
public class DeskLamp { ... public void finalize() { this.unplug(); } }
Java and Parameters
Java and Parameters
Java passes all parameters by value Value of actual parameter is copied into the formal parameter of the method Parameter passing is like an assignment statement
Object Parameters
If a parameter is an object, the reference is copied
Creates an alias for the object!
Statements in the method alter the same object as the actual parameter For objects:
Changes inside a method are seen outside the method
Example
// Declare HondaCivic HondaCivic CarPainter myCar and yourCar as aliases myCar = new HondaCivic(red); yourCar = myCar; painter = new CarPainter();
Example Continued
// This method paints myCar green painter.paintGreen(myCar); // Method inside Painter class public void paintGreen(HondaCivic car) { car.setColor(Green); } myCar and car are aliases of each other. Thats the only way that the change of color takes place!
// This method paints myCar green painter.paintGreen(myCar); // What color is yourCar? System.out.println(yourCar is + yourCar.color());
Comparison to Primitive Parameters
// This method doubles a number myObject.doubleNum(anyIntVariable); // Method inside my class definition public void doubleNum(int val) { val *= 2; } The int value is copied to val. The doubled value isnt seen in anyIntVariable. To see the new value, a return statement would be needed
The Static Modifier
The Static Modifier
Static Methods
No instantiation needed Example: Math.sqrt(); These are class methods
Static Variable
Static Variables
Only one copy of a static variable Shared across all instances
Example declaration
private static int count = 0;
A static variable is shared by all instances of a class
These are class variables
Memory is allocated when the class is first referenced in the program
Uses for Static Variable
Constants are often static variables
Values never change No need for multiple copies
private static final int MAX_SPEED = 125;
Wrapper Classes
Keep count of how many instances are currently instantiated
No need for multiple copies
private static int count = 0;
Increment count in the constructor Decrement count in the finalize() method
Wrapper Classes
Java has many primitive data types
int, short, byte, char, etc.
Javas Wrapper Classes
Primitive Type
byte short int long float double char boolean void
Wrapper Class
Byte Short Integer Long Float Double Character Boolean Void
However, sometimes objects would be useful instead Java provides Wrapper Classes for primitive data types
Using Wrapper Classes
Integer milesObj = new Integer(13455); Character gradeObj = new Character(A);
Wrapper Methods
Wrapper classes provide many methods For class Integer:
byte byteValue() double doubleValue() float floatValue() int intValue() long longValue()
Static methods for class Integer
static int ParseInt (String str) static String toBinaryString(int num)
Using Integers Methods
// Read a number System.out.print(Enter a number:); String decimalStr = Keyboard.readString(); // Convert to an int int value = Integer.ParseInt(decimalStr); // Convert to a binary string and print String binaryStr = Integer.toBinaryString(value); System.out.println(binaryStr);
Static Wrapper Variables
Useful constant values stored as static variables Example:
In Integer class
MIN_VALUE MAX_VALUE
Other wrapper classes have similar constants
Another Wrapper: The Character Class
boolean equals(Object arg); char charValue(); static boolean isDigit(char c); static boolean isLetter(char c); public final static char MAX_VALUE; public final static char MIN_VALUE;
Other Wrappers
For full descriptions, see Appendix M
Java Interfaces Java Interfaces
An Interface in Java
A collection of constants and abstract methods
Abstract methods have no code associated with them Only have method prototype
A class definition can implement an interface
Requires a class to implement the abstract methods
Java Interfaces
Some Java Interfaces
Comparable
Provides a common mechanism for comparing objects Contains one abstract method: int compareTo(Object obj)
Example: Interfaces
public class ABit implements Comparable { private byte bitValue = 0; // Ignore formatting here. I ran public ABit() {} // out of space and squeezed it. public byte value() { return this.bitValue; } public int compareTo(ABit otherBit) { if (this.bitValue == otherBit.value()) return 0; else if (this.bitValue < otherBit.value()) return -1; else return 1; compareTo() } }
Iterator
Used for collections and navigating through them Major abstract methods: boolean hasNext() Object next()
is required for any class that implements the Comparable interface.
2 Minute Exercise
Implement the compareTo() method for the PlayingCard class Assume aces are low Cards with the same value but different suit should be considered equal
JBuilder Example
Using a static variable
Keeping track of number of instances
For Next Class
Read Sections 6.2-6.4
Advanced Array Topics