Creating a class

A class is a decision about what an object remembers and who is allowed to change it. You pick the fields. You write the one way in. You write the ways out that you actually want, and you leave out the ones you do not. Every one of those choices says what a valid object of your class looks like, and says that nothing outside the class gets to skip the check.

This lesson builds one small class and keeps it the same the whole way through, a Student with a name and a gpa.

Fields, and why they are private

A field is a variable that belongs to an object rather than to a method. Every Student you build carries its own name and its own gpa, separate from every other one.

public class Student
{
    private String name;
    private double gpa;
}

Both fields are private, and that word is doing real work. Nothing outside this file can hand name or gpa a value. The only ways in are the ones written inside the class. Because those are the only ways in, the class gets to decide what counts as a valid Student and can actually hold that line, since it is the only code touching the fields. A public field has no door, so it has no promise attached to it.

Before your code runs at all, Java has already put the object in memory and given every field a default: a reference field like name starts as null, and a numeric field like gpa starts at 0.0. You did not write those values. Overwriting them with real ones, before anybody else can look, is the constructor's job.

The constructor, the one way in

A constructor runs once, at the moment new Student(...) executes, and it has one job: leave the object in a state you are willing to stand behind.

public Student(String name, double gpa)
{
    if (name == null)
    {
        throw new IllegalArgumentException("name cannot be null");
    }
    this.name = name;
    this.gpa = gpa;
}

The check comes before either assignment, and the reason is the word "before". If the name really is null, the throw happens while the object is still half built, and the half-built object never reaches the caller. new hands back nothing at all when the constructor throws. That is what a constructor promises: every object of this class that exists anywhere passed this check.

gpa gets no null check and does not need one. A double is a primitive, so it always holds a number, never the absence of one. name is a reference, so it can point at nothing, and null would otherwise sail straight into the field and sit there until something reads it and dies a long way from here.

The ways out, and the ones you leave out

public String getName()
{
    return this.name;
}

public double getGpa()
{
    return this.gpa;
}

public void setGpa(double gpa)
{
    this.gpa = gpa;
}

The 2 getters are read doors. They hand back a value without letting outside code touch the field. setGpa is a write door, and it exists because you decided a gpa is allowed to move over a student's career. There is no setName, and that absence is a decision, not an oversight: once a Student is built its name does not change, so there is a way to read it and no way to change it.

If you did add a setName later, it would need the same null check the constructor has. A promise about a field is only as strong as the weakest door into that field. A setter that skips the check is a second way in that ignores what the first way in guaranteed, and from then on the class promises nothing.

Putting the rule in one place

When a field has a rule, write the rule in the setter and make the constructor go through the setter instead of around it.

public class Circle
{
    private double radius;

    public Circle(double radius)
    {
        setRadius(radius);
    }

    public void setRadius(double radius)
    {
        if (radius > 0.0)
        {
            this.radius = radius;
        }
        else
        {
            throw new IllegalArgumentException("radius must be greater than 0");
        }
    }
}

Now there is one line in the whole class that decides what a legal radius is. Change the rule and you change it once. Write this.radius = radius; in the constructor instead and you have 2 places that both claim to guard the field, one of which does not, and new Circle(-1.0) builds a circle with a negative radius that nothing will ever complain about. It will not throw. It will just quietly report an area for a shape that cannot exist.

What printing an object shows

If you never say otherwise, printing a Student gives you something like Student@1a2b3c, which is the class name and a number about where the object sits in memory. It tells you nothing about the student. Replacing that with something readable is toString, and it has a lesson of its own: Overriding a method. Write one on every class you build. It costs 5 minutes and it pays for itself the first time you print an object while chasing a bug.

In the practice APE

The practice exam posted on the official site, the one described in the Practice APE Exam Instructions, hands you a Circle with the shape above already half built. The field and the setter are written. The constructors are not.

public class Circle extends Shape
{
    private double radius;

    public Circle(double radius)
    {

    }

    public double area()
    {
       return 0.0f;
    }

    public double circumference()
    {
       return 0.0f;
    }

    public void setRadius(double radius)
    {
        if (radius > 0.0)
            this.radius = radius;
        else
            throw new IllegalArgumentException("radius must be greater than 0");
    }
}

The comment at the top of the file is the specification, and it words the rule for you: the constructor must set the radius and the name using the tools provided in Circle and in Shape, and must not assign into the radius or the name field directly. That sentence is this whole lesson in one line. The door exists, it holds the rule, and going around it puts the rule somewhere it can be forgotten.

The name half of that sentence belongs to the parent class and is covered in Reaching the super class. The radius half is setRadius, which is already written and already correct.

The other practice problem on this topic hands you a Student whose fields, constructor and toString are all written for you, so you can read a finished small class before you write one. Its fields are private String first, last; and private int studentId;, its constructor takes all 3, and its toString returns the last name, a comma, the first name, a colon and the id. That file is the worked example inside Implementing Comparable.

Readiness check

Work each one on paper and write the answer down before you open it.

The one thing to keep

Private fields, a constructor that checks what it must before it assigns anything, and only the doors out you actually chose to build. Every field either gets a setter because you decided it should change or it does not, because you decided it should not. When a field has a rule, the rule lives in one method and everything else calls that method, so there is exactly one line to get right and exactly one line to change.