1.12 Objects: Instances of Classes

1. Classes and objects

A class is the formal implementation, or blueprint, of the attributes and behaviors of an object. An object is a specific instance of a class, with defined attributes 1.12.A.1.

One Plant class can produce many Plant objects. Each object has its own values for the attributes name and height:

Plant fern = new Plant("Fern", 30);
Plant mint = new Plant("Mint", 12);
fern.grow(4);
System.out.println(fern.getName() + " " + fern.getHeight());
System.out.println(mint.getName() + " " + mint.getHeight());

Output:

Fern 34
Mint 12

Growing fern does not change mint. They are two different objects built from the same blueprint.

2. Class hierarchies: superclasses and subclasses

When related classes share attributes and behaviors, the shared parts can be written once, in one class called the superclass. This builds a class hierarchy. The classes that extend the superclass are its subclasses, and they can use the superclass’s attributes and behaviors without writing them again. The link from each subclass up to its superclass is an inheritance relationship 1.12.A.2.

Example: in a hierarchy with superclass Vehicle and subclasses Bus and Bicycle, both subclasses can use Vehicle’s attributes (such as speed) without rewriting them.

Class	Role	What it has
Vehicle	superclass	attributes and behaviors all vehicles share, such as speed
Bus	subclass of Vehicle	everything from Vehicle, plus its own, such as a number of seats
Bicycle	subclass of Vehicle	everything from Vehicle, plus its own, such as a number of gears

Outside the course: designing and implementing inheritance relationships. You only need to understand what they are.

3. Every class is a subclass of Object

All classes in Java are subclasses of the Object class 1.12.A.3. So every object, from any class, has the behaviors defined in Object, such as toString and equals, even if its own class never wrote them.

public class Coin
{
    // no methods written here at all
}

// in main
Coin c = new Coin();
System.out.println(c.equals(c));

Output:

true

Coin declares nothing, yet c.equals(c) compiles and runs, because Coin is a subclass of Object and draws on its equals behavior. Topic 1.15 uses the inherited toString behavior.

4. Reference variables hold object references

A variable of a reference type holds an object reference, which can be thought of as the memory address of that object 1.12.B.1. Declare a reference variable with the class name as its type:

String s = "Hi";
String t = s;          // copies the reference, not the object
Plant a = new Plant("Basil", 10);
Plant b = a;           // b refers to the same Plant as a
b.grow(5);
System.out.println(t);
System.out.println(a.getHeight());

Output:

Hi
15

After String t = s;, t holds a reference to the same String object that s refers to. After Plant b = a;, there is still only one Plant, so growing it through b changes what a.getHeight() returns.

Watch out: a reference variable does not contain the object; it contains where to find it.