Class vs Object in Java

A class is a description: the fields an object will have, the methods it can run, and the rules for constructing one. It exists as a type and as the bytecode that the class loader loads. An object is an instance: a particular piece of state living on the heap, created from that description. The class is shared; each object has its own copy of the fields.

Three practical ways to name the difference. The class is what you write in the source file. The object is what you create with new. And the class is what getClass() returns, so two objects are instances of the same class when their getClass() references are equal.

public class Main {
    public static void main(String[] args) {
        // The class is the blueprint; the object is the thing built from it.
        Car car = new Car("Hatch", 2020);
        System.out.println("car            : " + car);
        System.out.println("class of car   : " + car.getClass().getName());
        System.out.println("simple name    : " + car.getClass().getSimpleName());
        System.out.println("instanceof Car : " + (car instanceof Car));

        // Two objects from the same class are distinct instances.
        Car other = new Car("Saloon", 2021);
        System.out.println("same instance  : " + (car == other));
        System.out.println("same class     : " + (car.getClass() == other.getClass()));
    }
}

class Car {
    private final String body;
    private final int year;

    Car(String body, int year) {
        this.body = body;
        this.year = year;
    }

    @Override
    public String toString() {
        return body + " (" + year + ")";
    }
}

The output separates the two ideas neatly. The two cars are not the same object, so == on the references is false, but they come from the same class, so comparing their class objects is true. The identity check and the class check answer different questions, and confusing them is a common source of bugs.

One more distinction worth keeping straight: the class of an object is fixed for its lifetime. You cannot change an object's class at run time — getClass() is final — which is why the cast questions later in this topic all revolve around the static type of your reference, not the type of the object itself.

Usually more than one, and this is worth being precise about because it surprises people. List<String> names = new ArrayList<>(); creates one ArrayList object, and that ArrayList creates a backing Object array as well. Adding a String creates another object. So a single statement can quietly produce three objects, and the ones you did not name are the ones that show up in a memory profile.

For inspection, the standard tools are getClass() for the exact runtime type, getName() and getSimpleName() for its name, instanceof for a type test, and System.identityHashCode for a rough identity number. Anonymous classes are the interesting case: getClass().getName() reveals the outer class and the synthetic index, which is invaluable when you are reading a stack trace and wondering which lambda or which anonymous implementation just threw.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // One statement, several objects.
        List<String> names = new ArrayList<>();     // the list plus its backing array
        names.add("Ada");                           // a String

        System.out.println("list class   : " + names.getClass().getName());
        System.out.println("list size    : " + names.size());
        System.out.println("element class: " + names.get(0).getClass().getName());

        // Anonymous classes are objects of an unnamed type.
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("anonymous class: " + getClass().getName());
            }
        };
        r.run();

        // Two objects of the same class are still two objects.
        Object a = new Object();
        Object b = new Object();
        System.out.println("distinct identities: " + (a != b));
        System.out.println("same class         : " + (a.getClass() == b.getClass()));
    }
}

The anonymous class output is the practical takeaway: the name includes the enclosing class and a counter, which is how you tell two anonymous implementations apart in a log line. Everything else in the output is the class-versus-object distinction again — two instances, one class, distinct identities.