Objects and Their Classes

A common first impression is that a class has only one job. Some learners think a class is simply a place to keep static variables and subroutines. Others think a class is only a description used to build objects. Java does not force a choice between these. In Java, a class can serve both purposes, and this dual role is useful. It can also be confusing, because the single word class refers both to a container and to a description of object structure.

This article follows one question through the rest of the lesson: when you see the word class in Java code, which of its two jobs is being used? To answer that, we will trace what exists when a class is written, what exists when objects are created from it, and what each object gets to keep for itself.

Before reading any definitions, start with a concrete case. Suppose a class called Student describes a name and a score, and a subroutine called report that prints them. Two Student objects are created. Each one has a name and a score of its own. Both objects can call report. Ask yourself: what do the two objects share, and what is different between them?

The class is the description. It states which variables each object will contain and which subroutines each object can use. The following class is an original example written for this article. It describes a student with a name and a score, and a subroutine that reports both values.

Notice what this class does not do. It does not create any student. It only states the structure that a student object will have. The words name, score, and report belong to the description. Values such as Ana or 90 only appear when an object is actually created and given its own values.

The first job of a Java class is to act as a container for static members. Static variables and static subroutines belong to the class itself. They can be used without creating any object at all. The second job is to describe objects. The class states what variables and subroutines each object created from it will contain. The same class can do both jobs at once: it can hold static members and also serve as the blueprint for objects.

A class name can also be used as a type. When a variable is declared with a class name as its type, that variable is meant to hold objects of that class. In the Student example, a declaration such as Student a means that a is intended to hold a Student object. The class name is doing the job of a type, in the same way that int tells Java a variable holds integers.

The diagram shows the idea without committing to any detail the source does not give. Each variable is declared with the type Student, and each one is associated with a separate object. The variable is not the object; it is the name by which the program refers to an object of that class.

Here is the Student class in use. Two objects are created, each given its own values, and each asked to report. The code is an original example written for this article.

The three shared items come from the class description, so every Student object has them. The values in the other two columns are the individual part. Changing a.score to 95 would change object a only. Object b would still hold 75. The structure is shared; the values are not.

The source uses the PrintStream example to show how different objects can share a common subroutine such as println. The key idea is that a subroutine name can be a common interface. When objects share a common characteristic, such as having a println subroutine, code can call that subroutine in the same way regardless of which particular object it is working with.

This is what makes uniform use possible. A program does not need a separate calling pattern for each object that offers the same kind of subroutine. It calls the common subroutine, and each object carries out that operation according to its own structure and values. The class description is what guarantees that the shared subroutine is there in the first place.

A Java class has a dual role. It can contain static variables and subroutines that belong to the class itself, and it can describe the objects created from it. The class name can also be used as a type for variables that hold objects of that class. The class defines the variables and subroutines each object contains, while each object can hold its own variable values. Objects of the same class share that structure, which is why common subroutines such as println can be used across different objects in a uniform way.