1.12 Objects: Instances of Classes

TLDR

A class is the blueprint, and an object is a specific instance built from that blueprint with its own attribute values. In AP Computer Science A, a variable of a reference type does not hold the object itself; it holds a reference to where the object lives in memory. Topic 1.12 is where you start thinking in terms of objects, references, and how every Java class connects back to the built-in Object class.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Why This Matters for the AP Computer Science A Exam

This topic builds the mental model you use for the rest of the course. Once you understand that an object is an instance of a class and that reference variables store references rather than raw values, everything from String methods to ArrayLists to 2D arrays makes more sense.

On the exam, this shows up most in multiple-choice questions where you describe the behavior of a code segment. You will be expected to tell the difference between a class and an object, recognize that two objects of the same class can hold different data, and understand what a reference variable actually stores. Later free-response code writing also depends on this foundation, since you cannot work with objects you do not understand.

A few scope notes so you do not overstudy. You should know that subclasses extend a superclass and inherit its attributes and behaviors, and that every class in Java is ultimately a subclass of Object. You do not need to design or write inheritance relationships yourself in this course. Keep your focus on explaining the class-object relationship and declaring reference variables correctly.

Key Takeaways

• A class is the blueprint that defines attributes and behaviors; an object is a specific instance of that class with its own attribute values.
• Two objects of the same class share the same methods but can store completely different data.
• A reference variable holds an object reference, which you can think of as the memory address of the object, not the object itself.
• A reference variable can hold null, meaning it is not pointing to any object yet.
• Subclasses extend a superclass and inherit its attributes and behaviors, and every class in Java is a subclass of Object.
• You are responsible for explaining class-object relationships and declaring reference types, not for designing inheritance.

Class vs Object

A class is the formal blueprint of the attributes and behaviors an object will have. An object is a specific instance of that class with defined attributes. If Car is the class, then one actual car you build from it is an object.

Each object keeps its own state through its attributes while sharing the same methods defined by the class. That is why two objects of the same type can behave the same way but hold different data.

</>Java
// Car is the class (blueprint)
public class Car {
    private String make;
    private String model;
    private int year;

    public Car(String carMake, String carModel, int carYear) {
        make = carMake;
        model = carModel;
        year = carYear;
    }

    public String getCarInfo() {
        return year + " " + make + " " + model;
    }
}

</>Java
// Each variable below refers to a separate Car object
Car myCar = new Car("Toyota", "Camry", 2020);
Car friendsCar = new Car("Honda", "Civic", 2019);

System.out.println(myCar.getCarInfo());      // 2020 Toyota Camry
System.out.println(friendsCar.getCarInfo()); // 2019 Honda Civic

myCar and friendsCar are both Car objects, but they store different attribute values and are completely independent.

Reference Variables and References

This is the part that trips people up. A variable of a reference type does not store the object. It stores a reference to the object, which you can think of as the memory address where the object actually lives.

</>Java
Car myCar = new Car("Toyota", "Camry", 2020);

Here, myCar does not contain the car's data directly. It holds a reference that points to the Car object created by new. When you call myCar.getCarInfo(), Java follows that reference to find the object and run the method.

A reference variable can also hold null, which means it is not pointing to any object. Declaring a variable and creating an object are two separate steps.

</>Java
Car myCar;        // declared, currently holds null (no object yet)
myCar = new Car("Toyota", "Camry", 2020); // now refers to a real object

Classes Are Reference Types

Classes define reference types, the same way int, double, and boolean are primitive types. When you write int x = 5;, x holds the value 5 directly. When you write Car myCar = new Car("Toyota", "Camry", 2020);, myCar holds a reference to a Car object, not the object itself.

Every object created from a class has the same structure defined by that class, but each can store different data.

Where Object Fits In

Java organizes related classes using a hierarchy. Common attributes and behaviors can be placed in a single class called a superclass. Classes that extend a superclass, called subclasses, can use the superclass's existing attributes and behaviors without rewriting them. This is an inheritance relationship.

The big fact to remember: every class in Java is ultimately a subclass of the built-in Object class. You do not need to design or implement inheritance in this course, but knowing that all classes trace back to Object helps later when you see behaviors that every object is guaranteed to have.

How to Use This on the AP Computer Science A Exam

MCQ

• When a question asks you to describe behavior, separate the class from its objects. The class defines what attributes and methods exist; each object holds its own values.
• Expect questions where two objects of the same class store different data. Track each object's state separately.
• Know that a reference variable stores a reference, not the object. Questions may test whether you understand that two variables could refer to the same object or to different objects.
• If a variable was declared but never assigned an object, it holds null.

Code Tracing

• When you see new ClassName(...), recognize that a new object is being created and a reference to it is stored in the variable.
• Follow each reference variable to the object it points to before predicting output.
• Keep separate notes for each object so you do not mix up their attribute values.

Common Trap

• Declaring a variable does not create an object. Car myCar; gives you a variable that holds null until you assign it an object with new.

Common Misconceptions

• "A class and an object are the same thing." A class is the blueprint. An object is a specific instance built from that blueprint. One class can produce many independent objects.
• "A reference variable stores the object." It stores a reference to the object, which you can think of as a memory address. The object itself lives elsewhere in memory.
• "Declaring a variable creates the object." Declaration and creation are separate. Until you assign an object with new, the reference variable holds null.
• "Changing one object changes all objects of that class." Each object keeps its own attribute values. Changing one object's data does not affect another object of the same class.
• "I need to write inheritance code for this topic." You only need to explain the class-object relationship and declare reference variables. Designing and implementing inheritance is not part of this topic.
• "Every class extending Object is something I set up." Every Java class is automatically a subclass of Object. You do not write that relationship yourself.

Related AP Computer Science A Guides

• 1.4 Assignment Statements and Input
• 1.14 Calling a Void Method
• 1.6 Compound Assignment Operators
• 1.15 String Methods
• 1.1 Why Programming? Why Java?
• 1.11 Using the Math Class