Java Classes and Objects

A class defines a type: the data its objects remember and the operations they offer. An object, also called an instance, is one value of that type created while a program runs. Writing a class definition does not create an object.

State and behavior

A pet's name, species, and age make up its state. Those current values live in instance variables, also called fields. An operation such as celebrating a birthday is behavior, written as a method. The birthday method belongs with the age it changes, so the rule is kept in one place.

Think of a class as a building plan. Many houses can follow one plan, but each house has its own contents. Likewise, two pets can follow the same definition and have different ages. You write the field names once; each object gets its own values.

Read a small class

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Read this from the outside in. public class Pet introduces the type, and the outer braces contain its definition. The first three declarations describe state. The block named Pet is a constructor: it gives a new object its first values. celebrateBirthday is a method: it increases the current object's age. The words private and public control access; later examples use them to protect state.

The constructor's parameters are values supplied when an object is created. In this.age = age;, the left side names the object's field and the right side names the supplied parameter. The constructor stores that input so the object can remember it after construction ends.

Put a class to work

You have already used library classes. Scanner describes objects that read input, ArrayList describes lists, and a String object offers operations such as length(). A class you write follows the same basic idea: it makes a useful type available to the rest of your program.

Without Pet, a program might pass a name, species, and age separately to many methods. It must keep each group together correctly. A Pet object carries the related values as one unit. Methods on that object know which age they should use.

Organize and name the code

For ordinary source files, a public class named Pet is saved in Pet.java, with matching capitalization. A separate Main class can contain the program's main method, create pets, and call their methods. Pet needs no main of its own. Classes in the same unnamed package can use one another without imports; the simple examples keep those classes in one folder.

Use UpperCamelCase nouns for classes, such as LibraryBook. Use lowerCamelCase for fields and methods: pageCount names data; giveBack() names an action. These are conventions that help a reader recognize each part, even though the compiler allows many other names.

Creating an object and declaring a variable are different operations. A variable gives you a name through which to reach an object; new creates the object that the name will refer to.

Read an object-creation statement

Pet luna = new Pet("Luna", "cat", 3);

Pet is the variable's type, and luna is its name. new Pet(...) creates a new object and calls a matching constructor with three arguments. The constructor stores the name, species, and age. The resulting reference is assigned to luna.

A reference tells Java which object to use. It is useful to draw a variable as a name with an arrow to an object. The variable is not a second copy of all the object's fields.

Call a method on a particular object

The dot in luna.celebrateBirthday() connects a reference with a method to run on its object. A returning method can supply a value to another expression:

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Here getAge() is a public method that returns the pet's age. The birthday call changes state; the getter reads that state. Pet.celebrateBirthday() fails because this instance method needs a particular pet. The class name alone does not answer whose birthday it is.

Separate objects and shared references

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna was already 4, so the next birthday takes her to 5. Max stays 5. Equal ages do not make them the same object: the two new expressions created separate pets.

Now consider an assignment with no new:

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

The assignment copies Luna's reference. Both names reach one pet, so changing it through other is visible through luna. To make a second pet, call new again.

Match the constructor's parameters

Arguments must fit a declared constructor's number, order, and types. If the only available constructor takes (String, String, int), new Pet() fails to compile. Java does not guess missing values. Swapping the two strings, however, still compiles: new Pet("cat", "Luna", 3) supplies the right types but the wrong meanings. Read the parameter names to check that order.

These two unfinished attempts fail for different reasons:

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

A local variable must be assigned before it is used. Without new, Java searches for a method named Pet, not an object-creation expression. Once an object exists, printing it may show text like Pet@8bcc55f until you supply a readable toString() method; that output does not mean construction failed.

An object needs a field for each value it must remember between method calls. Choose those values before writing methods: they form the object's lasting state.

Declare fields with suitable types

A field sits inside the class braces but outside every constructor and method. A declaration needs a type and a name; an access modifier and an initializer can also appear.

private String title;
private int pageCount;
private boolean lentOut = false;

String suits text, int suits a whole-number count, and boolean suits a yes-or-no condition. Fields can also use class types such as ArrayList<String>. These examples use private; leaving the modifier out gives package access, not private access.

Every object gets a separate copy of each instance field. Two Rectangle objects each have a width and a height, even though the declarations appear only once in the class.

Defaults are not always usable starting values

A default is assigned to a field when storage for the object is created. It may not fit the object's purpose. A list field with the value null is not an empty list: you still need to create the list before adding an item.

Local variables receive no such default. Inside a method, int total; followed by System.out.println(total); fails to compile because total has not been assigned. Keep the field rule and the local-variable rule separate.

Decide what must last

A field remains with its object. A parameter is available during its call, and a local variable is available in its block while that call runs. If a counter must retain its count from one call to the next, the count belongs in a field. A temporary subtotal used for one calculation can be local.

Store the inputs; calculate derived values

public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

The dimensions are in centimeters, so area() returns an area in square centimeters. Storing a separate area field would create another value to update whenever either dimension changed. Computing it from the dimensions keeps the answer consistent.

Use an instance final field for a value assigned once, such as private final String title;. Give it a value in its declaration or in every constructor. final prevents reassignment. static has a different meaning: it creates one shared class field. Adding static to a pet's name would make different pets share one name variable.

A constructor sets up an object when new creates it. Its name must match the class, and it has no return type. Even void would turn the declaration into a method.

Transfer inputs into state

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

A constructor usually accepts inputs as parameters and stores them in fields. Here each parameter has the same name as its field. The bare name age means the parameter; this.age means the field of the object being created. The assignment reads the supplied value on the right and writes the field on the left.

For new Pet("Luna", "cat", 3), first the new object's fields receive defaults: null, null, and 0. The constructor then receives the three arguments and replaces those defaults. When construction finishes, new produces the reference that the caller stores.

Two bugs that compile

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

Both occurrences of name refer to the parameter, so the first line assigns that parameter to itself. The object's name stays null. The code is legal, which is why checking the new object's values matters.

A declaration inside the constructor causes a related problem:

String nick = initialNick;

If a field named nick already exists, this line creates a local variable with the same name. The local disappears when construction ends. Write this.nick = initialNick; to store the input in the field; do not repeat the type.

Know when a no-argument constructor exists

If a class declares no constructors, Java supplies a default constructor with no parameters. For a simple class, its fields keep their declared initializers or default values. As soon as you declare any constructor, Java stops supplying that default one.

A class with only Pet(String name, String species, int age) therefore cannot be created with new Pet(). Add an explicit no-argument constructor only when there is a useful starting state for it. Also watch for public void Pet(...): that is a method, so it does not provide the intended constructor at all.

Set internal starting values too

Not every field needs to come from an argument. A new book can always start with this.lentOut = false;. A class that owns a list can initialize it like this, with ArrayList imported:

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

The empty list is ready for add. Leaving tracks at null makes a later tracks.add(...) fail with NullPointerException.

A field initializer runs before the constructor body. If private int score = 10; is followed by this.score = 5; in the constructor, the finished object's score is 5. Test the values after construction, not just the values written beside the field declarations. Constructors also need the same validation rules as later changes, so the first state is valid.

A class can offer several useful ways to create an object. Constructor overloading means declaring constructors with different parameter lists.

Distinguish constructors by parameters

Java tells constructors apart by the number, types, and order of their parameters. Parameter names do not distinguish them. Box(String label) and Box(String name) describe the same parameter list, so they cannot both be declared in one class.

A pet may be created with an age or as a newborn:

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") selects the two-parameter constructor. That constructor supplies 0 as the missing age and calls the three-parameter constructor. The new object ends with the state "Pip", "rabbit", and 0.

Chain setup on the same object

Inside a constructor, this(...) calls another constructor of the same class. The shorter constructor chooses defaults; the fuller constructor does the shared setup. Checks placed in that setup apply to both construction routes.

Contrast two lines that look similar:

The second line does not fill the current object's fields. If its result is never stored, that extra pet is discarded. The current pet may still have null fields.

Follow a chain before tracing later code

A clock can offer midnight as a default:

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

For new Clock(), enter the no-argument constructor, follow this(0, 0), and assign both fields in the two-argument constructor. Then control returns to the no-argument constructor. This creates one clock, not two. A call to new Clock(9, 5) starts directly in the fuller constructor.

Keep the chain legal and clear

A constructor can contain at most one this(...) call. The chain must eventually reach setup that does not call back into the chain: two constructors that delegate to each other cause a compile-time recursive-constructor error.

Putting this(...) first is a clear style that works across Java versions. In Java 24 and earlier without preview features, it must be first. Java 25 allows earlier statements for tasks such as computing or checking arguments. Those statements cannot read the current object's instance fields or call its instance methods; assignments to fields declared in the class without declaration initializers are allowed.

Offer overloads because callers have different useful inputs. A midnight clock is meaningful; a book with no title may not be. The existence of a full constructor does not create any shorter overloads automatically.

An instance method runs for one particular object. Declare it without static, and use fields of that object through names such as this.width. Decide what the caller needs: a state change, a returned result, or both.

Return calculations; keep state changes explicit

For a rectangle whose dimensions are stored in centimeters:

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

A rectangle with sides 3.0 and 4.0 has area 12.0 square centimeters and perimeter 14.0 centimeters. scale(2) changes the sides to 6.0 and 8.0. The next calls return area 48.0 and perimeter 28.0. Each method reads the current fields, so no stored area needs updating.

area() returns a number that can be stored or used in a calculation. If it only printed the number and had return type void, the caller could not write double twice = r.area() * 2;. Leave printing to the caller when a method's job is to compute a value.

Update related fields in order

A clock's advance() method must handle both minute and hour rollover:

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

At 23:58, the first call reaches 23:59 and skips both reset blocks. The next call briefly reaches minute 60, resets it to 0, raises the hour to 24, and resets that to 0. The finished state is 00:00. One more call gives 00:01.

Trace objects separately

Write a row after each statement and a column for each object's fields. Change only the object named by the receiver of the call. For pets aged 2 and 7, two birthdays on the first pet and setAge(1) on the second leave ages 4 and 1. Do not run a method's body for every instance just because they share a class.

A local declaration can hide the field you meant to update. public void reset() { int count = 0; } only creates a temporary variable. this.count = 0; resets the lasting count.

Reuse methods and complete return paths

Within an instance method, area() and this.area() call the same object's area method. A description method can reuse that calculation instead of copying its expression. A method may also change state and return success, as lend() does when it marks a book as borrowed and reports true.

A non-void method cannot simply reach the end without returning a compatible value. If get() returns only inside if (count > 0), what happens when the count is 0? Add the needed return path or throw an exception for a value the method rejects. A path that throws does not return to the caller and needs no return value.

Ask who owns a value or an operation before deciding whether to use static. A pet's age belongs to one pet. A count of all pets created belongs to the class as a whole.

The current object is this

Inside a constructor or instance method, this refers to the object being constructed or receiving the call. In this.age++, it identifies whose age changes. In this.name = name, it separates the field from a same-named parameter. this(...) is the constructor-chaining form.

A static method has no current object, so this cannot be used there. It may still create an object or receive a reference and use that reference to call instance methods.

Shared fields and per-object fields

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

After two new Counter() calls, there are two separate count fields, both initially 0, and one created field equal to 2. Incrementing the first counter changes its count to 1; the second stays 0. Counter.getCreated() still returns 2 because no new object was constructed.

Work through an object from main

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

The classic main method is static. A bare call to increment() there would have no target object and would fail to compile. The variable c supplies that target. Making count static to silence the error would change the design: every counter would then share one count.

Java 25 also supports instance forms of main, but the classic static header remains valid. These examples use it consistently.

Choose methods and constants deliberately

An operation that needs an object's fields should be an instance method. An operation that depends only on its parameters can be static, like a helper that converts a total number of minutes into hours. Static calls normally use the class name: Math.sqrt(16) or Counter.getCreated().

A shared fixed value is usually declared as a constant:

public static final int MAX_CELSIUS = 30;

public makes it available to callers, static gives the class one shared field, and final prevents reassignment. UPPER_SNAKE_CASE signals a constant by convention. This is a common exception to making fields private. Do not use static for ordinary names, dimensions, or other state that must differ between objects.

Encapsulation keeps an object's state together with the code that controls it. Fields are usually private, while callers use public operations. This hides storage details and gives the class a place to enforce its rules.

Choose an access level

A package groups classes. The simple examples place ordinary classes together without a package declaration, in one unnamed package. Package access is the result of leaving the modifier out; there is no package access keyword to add to a field.

Start with the narrowest useful access. Make fields private, constructors and operations needed by other classes public, and internal helper methods private. Public constants are a common exception for fields.

Put the class in charge of changes

If Pet declares private int age;, a separate Main class cannot assign luna.age = -5;. The compiler rejects the access. A call such as luna.setAge(-5) can be allowed, because the public method belongs to Pet and can decide whether to store the argument.

A public field would let any caller bypass that method. Once all changes go through the class's code, the checks can live in one place. Private access alone does not validate an age; the methods must perform the checks too.

Keep the public interface stable

Suppose a clock initially stores separate hours and minutes fields. Callers use getHours() and getMinutes(). You later replace the fields with a single minutesSinceMidnight value:

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

With 615 stored minutes, division returns 10 and remainder returns 15. The clock reports 10:15 through the same methods. Callers do not need rewriting because they depended on the public operations, not on how the state was stored. This freedom to change internals is information hiding.

Access belongs to classes, not individual objects

Code inside Pet can read a private field of another Pet object. The access permission comes from being inside the class. A different top-level class does not gain permission by holding a pet reference or being in the same folder.

For ordinary top-level class declarations, the access choices are public or no modifier. A top-level private class Pet is illegal. A public top-level class goes in the matching source file, and one ordinary source file contains at most one public top-level class.

Private fields are a program-design boundary. They prevent other ordinary code from depending directly on internal fields, but they are not a way to keep a value secret from a person who can inspect the program. Use them to control your class's interface and protect its state.

A class can let callers read or change selected parts of its state through methods. Decide which operations the class should offer before creating access methods for every field.

Return values with getters

A getter, also called an accessor, returns information without changing the object. A common getter reads a field:

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

public int getAge() {
    return this.age;
}

The returned type matches the information being supplied. A getter that prints and returns void cannot give a value to an expression such as pet.getAge() + 1. The caller should receive the value and decide how to use it.

Change selected values with setters

A setter, also called a mutator, takes a new value and updates state:

public void setName(String name) {
    this.name = name;
}

this.name is the field. name is the parameter. Writing name = name; compiles but changes no field. There is no return value here because this setter's job is to perform a change.

For a pet whose age is 3:

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

The caller never touches a field directly. The setter changes the name, and the getters return the current values for the caller to combine.

Follow names that other Java code expects

Capitalize the first letter of the field name after get, set, or the usual boolean prefix is. A name such as getname() may compile, but it does not follow the convention that tools and other programmers expect.

Expose only useful operations

A book's title may have a getter and no setter because callers should read it but not replace it. A private final field can enforce that it is assigned once. An internal counter may need neither getter nor setter if only the class uses it.

An unchecked setter can accept the same damaging value as a public field. Add checks where a change has restrictions. Also consider an action method: celebrateBirthday() expresses increasing the age by one, and lend() expresses a lending attempt. lend() can inspect the current state and reject a second loan. A setter can perform that check too; the action name makes the operation clearer to its caller.

A getter can compute an answer. getArea() may return the product of width and height without any area field.

An invariant is a rule about an object's state that holds after construction and after every public operation. A thermostat might allow targets from 5 °C through 30 °C. Every way to set its target must preserve that range.

Choose what invalid input means

Three useful responses are to keep the old value, clamp the value to a limit, or throw an exception. They have different effects, so choose a clear response for each operation.

For a nonnegative pet age, an ignoring setter can assign only inside if (age >= 0). If the stored age is 4, setAge(-2) leaves it at 4. It does not turn the age into 0.

Put range checks inside the class

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

Starting at 20 °C, setTarget(35) stores 30. setTarget(-3) stores 5. After setTarget(29), a call to raise() stores 30; another call still stores 30. Reusing the setter prevents raise() from slipping past the upper limit.

Checks in Main alone cannot protect the thermostat. Another caller could forget them. The class must check the input at the place where it controls storage.

Validate the first state too

public Thermostat(int target) {
    setTarget(target);
}

With this clamping constructor, new Thermostat(50) finishes at 30 °C. Directly assigning this.target = target; would allow the invalid first state of 50. A shared private checking method is another way to reuse validation in constructors and later methods.

Throwing is useful when an invalid argument signals a programming error. For example, a constructor can reject a negative count with throw new IllegalArgumentException("count must not be negative");. The object is not successfully constructed, so no invalid finished object is given to the caller. Ignoring input is simpler but silent; the caller may need another way to notice that nothing changed.

Keep mutable internal data inside

A private list can still escape if a getter returns the original list. A caller could then add or remove entries without using the class's methods, bypassing a maximum-size rule.

For an ArrayList<String> field named tracks, return new ArrayList<>(this.tracks); gives a separate list containing the same strings. Changing that returned list does not change the internal list. Operations such as addTrack(String title) can keep list changes inside the class and check its rules before accepting them.

A useful object should be easy to inspect as text. Java's built-in toString() returns a class name, an @ sign, and a hexadecimal hash code, such as Pet@8bcc55f. A named package becomes part of the class name. The hash text varies and usually says little about the object's state.

Return a readable description

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

For Luna, a cat aged 3, the returned string is "Luna (cat, 3 years)". The method reads fields and builds a string. It does not change the pet or send output to the screen.

@Override asks the compiler to check that the declaration really replaces an existing method. That catches errors such as writing tostring with a lowercase s. It does not format the result for you; the return expression determines the text.

Recognize automatic calls

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

The first line prints the pet's readable description. The second builds "Pet: Luna (cat, 3 years)". The third asks for the same description explicitly and stores it without printing. When an ArrayList of pets is printed, its display uses each pet's toString() inside the list's square delimiters.

Automatic conversion is why returning text matters. The caller may be printing, storing, or joining the result. A method that only prints cannot supply the string needed by all those callers.

Match the method header

Use the exact no-argument header and include the annotation. An overload with parameters may be a valid separate method, but printing an object does not provide those parameters.

Format values without changing them

A clock needs two-digit hours and minutes. Inside its toString() method:

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

For hours 9 and minutes 5, the string is "09:05". Each %02d formats an integer in at least two positions, using a leading zero when needed. String.format(java.util.Locale.US, "%.2f", 7.5) returns "7.50". Supplying the locale makes the decimal-point output independent of the computer's default formatting locale.

Keep the description short enough to read while debugging. It can reveal unset state: joining a null name field to a string produces the text "null", which points you back to initialization. The description should report the current state, so printing the object twice should not advance a clock or celebrate a birthday.

Start with what one object must remember, what callers can ask it to do, and which states must be allowed. Then turn each part into fields, constructors, and methods.

Extract the design from a description

"A library book has a title, an author, and a page count. It can be lent out and given back. It cannot be lent out again while already on loan."

Use LibraryBook as the class name. Store the three descriptive values and a boolean loan status. The title, author, and page count stay fixed, so make them final. The loan status changes through meaningful actions. A setter for every field is unnecessary.

Build the complete class

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

The constructor establishes availability. lend() checks the existing state before changing it; returning false on a second loan preserves the rule. giveBack() makes the book available. The getter reports status, and toString() describes the whole book without changing it.

Write expectations before running calls

In a separate Main class's classic main method:

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

The second loan attempt is essential: a method that always sets the flag and returns true would pass the first call but fail this check. Test state as well as return values with isLentOut(). Also try a second book to check that a loan on one book leaves the other available.

Test where behavior changes

Cover every constructor and public method. For range checks, try both endpoints and values just outside them. For a clock, check minute rollover and midnight rollover. For a rejecting or ignoring setter, check that invalid input has the promised effect on the old state. Write the expected result first so an unexpected output does not quietly become your new expectation.

Build in small increments: fields and constructor first, then a readable description, then one operation and its checks at a time. Save ordinary public classes in matching files, compile them together, and run the class containing main. Keeping model operations separate from screen output lets the same class serve different programs.