Objects: Instances of Classes

You have been using the word String since you first stored text in a variable, and you have read the String documentation. But what is String? It is not a piece of text itself: "Ada" is a piece of text, and so is "Grace Hopper". Both are strings, yet they are different from each other. Java needs a way to describe “what every piece of text is like” separately from “this particular piece of text.” That is the difference between a class and an object.

Start with an everyday picture. A cookie cutter is not a cookie. It describes a shape, and you can press it into dough again and again to make as many cookies as you like. Every cookie has the same shape, because it came from the same cutter, but each cookie is its own separate thing: one can have sprinkles, another chocolate chips. The cutter is the plan; the cookies are the things made from the plan.

In Java, the plan is a class: the written-out definition, or blueprint, of what a certain kind of thing knows and what it can do. A thing made from that plan is an object. Each object is one specific instance of its class, so “an instance of String” just means “one particular String object.”

A class describes two kinds of things about its objects:

• Attributes are what each object knows about itself: its data. A String object knows the characters it contains, and therefore how many characters it has.
• Behaviors are what each object can do: its actions, written as methods. A String object can report its length, among other things you will meet in later topics.

Every object of a class has the same kinds of attributes, but each object has its own values for them. Every String object has characters; "Ada" has three of them and "Grace Hopper" has twelve.

The cookie-cutter picture stops working in one place. A real cutter only controls shape, so cookies can differ in ways the cutter never mentioned. A Java object can only have the attributes and behaviors its class defines. If the class does not describe it, the object does not have it.

String first = "Ada";
String second = "Grace Hopper";
String third = "Alan";
System.out.println(first.length());
System.out.println(second.length());
System.out.println(third.length());

3
12
4

The same pattern shows up in classes you have already used. Scanner (Topic 1.4) is a class; the thing in your program that actually reads what the user types is a Scanner object. And it works for things outside Java, too. Imagine a music app that describes songs:

The Song class is invented for this example, but the reasoning is the same as for String: one class, many objects, same kinds of attributes, different values, same behaviors.

Suppose a team is writing classes for a car-rental company. They need a Car class and a Truck class. Both need a license plate, a number of miles driven, and a behavior to record a trip. If they write those three things in Car and then write them all again in Truck, they have two copies of the same code. When the company decides to track fuel level too, someone has to add it in two places, and sooner or later one copy gets forgotten.

The fix is to write the shared parts once, in one class, and let the other classes use them. In everyday words: describe what all vehicles have in common in one place, then describe only what is different about cars and trucks.

That shared class is called a superclass. A class that builds on a superclass is a subclass; programmers say the subclass extends the superclass. A subclass can use all of the superclass’s attributes and behaviors without writing them again, and it can add its own. This connection, where a subclass draws on what its superclass already defines, is called inheritance. A set of classes linked this way is a class hierarchy.

Now change one thing. The company decides every vehicle must track its fuel level. The team adds a fuel-level attribute to Vehicle only. Nothing in Car or Truck is edited, yet every Car object and every Truck object now has a fuel level, because both draw on Vehicle. That is the payoff of inheritance: a change written once in the superclass reaches every subclass.

The same shape appears whenever related things share a core. A school might have a Person superclass with a name and an email address, and subclasses Student (adds grade level) and Teacher (adds room number). A student and a teacher both have a name and an email, because both are people.

A good way to check a hierarchy is the phrase “is a”: a truck is a vehicle, and a student is a person. If the sentence sounds right, the subclass/superclass pair makes sense. “A vehicle is a truck” sounds wrong, because not every vehicle is a truck, which is exactly why Vehicle must not hold truck-only features.

In this course you need to read hierarchies like these and explain what each class gets. Designing and writing your own superclasses and subclasses is not part of AP Computer Science A.

The Vehicle hierarchy had a class at the top. Does Vehicle itself have a superclass? Does String? Java answers this the same way for every class, and the answer explains a line you may have skimmed past in the String documentation in Topic 1.7.

Java comes with a class named Object, with a capital O. It sits at the very top of every class hierarchy: every class in Java is a subclass of Object. When a class names no other superclass, Java makes Object its superclass automatically. When it does name one, like Truck naming Vehicle, then Object is still above it, one or more levels up. Either way, following the chain upward from any class always ends at Object.

Why would Java do this? Because there are a few behaviors every object in a program should have, no matter what kind it is. Java writes them once, in Object, and every class draws on them through inheritance, exactly as Car draws on Vehicle.

java.lang.Object
    java.lang.String

String firstWord = "Ada";
String secondWord = "Grace";
System.out.println(firstWord.getClass());
System.out.println(secondWord.getClass());

class java.lang.String
class java.lang.String

Now vary the hierarchy. In the school example, Person names no superclass, so its superclass is Object. Student extends Person. Follow the chain up from Student:

So Student is a subclass of Person and, one more level up, of Object. A Student object has Student’s attributes, everything from Person, and the behaviors from Object.

In Topic 1.2 you learned that a variable is a storage location with a name and a type, and that types are either primitive or reference. A primitive variable is simple: int score = 95; puts the number 95 in the box named score. But an object can be large. A String might hold a three-letter name or every word of a novel. Java cannot make every variable box big enough for any object. So how does a variable “hold” an object?

It does not hold the object at all. Think of a phone contact. Your contacts list does not contain your friend; it contains your friend’s number, which lets you reach them. The object lives somewhere in the computer’s memory, and the variable holds a way to find it.

A type that names a class, such as String or Scanner, is a reference type. A variable of a reference type holds an object reference: information that tells Java where the object is. You can picture a reference as the memory address of the object, like a street address that leads to a house. The object itself is stored at that address, outside the variable.

To declare a variable that can refer to an object, use the class name as the type:

String name = "Ada";

Declaring String name; with no assignment is also allowed, as long as the variable is assigned before it is used (Topic 1.4). And as you saw in Topic 1.4, a reference variable can hold null, meaning it refers to no object at all. Creating objects in other ways is the subject of Topic 1.13.

int score = 95;
String name = "Ada";
System.out.println(score);
System.out.println(name);

95
Ada

Now change one thing: replace "Ada" with the full text of a 300-page novel. The "Ada" object was tiny and the novel is huge, but name’s box does not grow. It still holds just a reference; only the object at the other end of it is bigger. This is why every variable can have a fixed-size box: a primitive’s value fits in it, and for an object only the reference has to.

The type in a declaration must match the kind of value assigned. A reference variable of type String can refer only to a String object, and an int variable can hold only an int. Java checks this at compile time.

public class WrongType
{
    public static void main(String[] args)
    {
        string city = "Boston";
        int name = "Ada";
        System.out.println(city);
        System.out.println(name);
    }
}

WrongType.java:5: error: cannot find symbol
WrongType.java:6: error: incompatible types: String cannot be converted to int

public class RoomNumber
{
    public static void main(String[] args)
    {
        String building = "North Hall";
        String roomNumber = 214;
        System.out.println(building);
        System.out.println(roomNumber);
    }
}

RoomNumber.java:6: error: incompatible types: int cannot be converted to String

String roomNumber = "214";

String building = "North Hall";
String roomNumber = "214";
System.out.println(building);
System.out.println(roomNumber);

In Topic 1.4 you learned that assigning a new value to a variable replaces the old one, and that a = b; copies the value of b into a. Those rules do not change for reference variables. What changes is what gets replaced or copied: the reference, not the object.

In plain words: if you write a new address on a sticky note, the note now leads to a different house, but the old house is still standing. If you copy an address onto a second note, you have two notes and still only one house.

String name = "Ada";
String backup = name;
name = "Grace";
System.out.println(name);
System.out.println(backup);

Grace
Ada

Now change one thing: swap lines 2 and 3, so name is reassigned before the copy. Then backup = name copies #7340, and both variables refer to "Grace"; the output is Grace twice. The statements are identical, only the order differs (sequencing, Topic 1.1), and the result changes because the copy takes whatever reference name holds at that moment.

String day = "Monday";
System.out.println(day);
day = "Tuesday";
day = "Friday";
System.out.println(day);

Monday
Friday

This program uses every idea in the chapter. Read it, predict the four lines of output, then check the trace.

public class HopperFacts
{
    public static void main(String[] args)
    {
        String fullName = "Grace Hopper";
        String job = "computer scientist";
        String hero = fullName;
        fullName = "Admiral Hopper";
        System.out.println(hero);
        System.out.println(fullName);
        System.out.println(job.length());
        System.out.println(hero.getClass());
    }
}

Classes and objects (1.12.1). String is the class. The program makes three String objects from literals: "Grace Hopper", "computer scientist", and "Admiral Hopper". Each has its own characters.

Reference variables (1.12.4, 1.12.5). Track the boxes, using made-up addresses:

Line 7 copies the reference, so hero and fullName briefly refer to the same object. Line 8 reassigns only fullName; hero keeps its reference to "Grace Hopper".

Behaviors (1.12.1). Line 11 asks the "computer scientist" object for its length: 8 letters in “computer”, 1 space, 9 letters in “scientist”, for 18.

Hierarchy (1.12.2, 1.12.3). Line 12 uses getClass(), which String objects have because String is a subclass of Object.

Grace Hopper
Admiral Hopper
18
class java.lang.String

• A class is a blueprint that defines attributes (what objects know) and behaviors (what they can do). An object is one instance of a class with its own attribute values.
• A superclass holds what related classes share. A subclass extends it and, through inheritance, gets those attributes and behaviors without rewriting them, and can add its own. Inheritance goes from subclass up to superclass only.
• Every class in Java is a subclass of the Object class, directly or through other superclasses, so every object has the behaviors Object defines.
• A variable of a reference type, such as String, holds an object reference (picture a memory address), not the object. Its type must match the object’s class.
• Assigning to a reference variable replaces its reference; copying one copies the reference, so both variables refer to the same object until one is reassigned.

Morning Light
City Rain

String nowPlaying = "Morning Light";
nowPlaying = "City Rain";
String previous = nowPlaying;
System.out.println(previous);
System.out.println(nowPlaying);

String nowPlaying = "Morning Light";
String previous = nowPlaying;
nowPlaying = "City Rain";
System.out.println(previous);
System.out.println(nowPlaying);

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can explain the difference between a class and an object, using String as an example. Reread
• I can sort features of a class into attributes and behaviors. Reread
• I can list everything a subclass gets from its superclass, and what it does not get. Reread
• I can explain why every class, including String, is a subclass of Object. Reread
• I can declare a reference variable and explain that it holds a reference, not the object. Reread
• I can trace what each reference variable refers to after assignments and copies. Reread