Objects, References and Equality in Java

A Java variable holds a value. The important question is whether that value is ordinary data or a reference that leads to an object. Assignment copies that value in both cases.

Primitive data and object references

Java has eight primitive types: byte, short, int, long, float, double, char and boolean. A primitive variable holds its data directly. A reference variable holds a reference to an object or the special value null. Classes such as String, Scanner and ArrayList, your own classes, and arrays are reference types.

In new Counter(), Java creates an object, runs its constructor and produces a reference. The assignment stores that reference in c. Draw the variable as a box with an arrow leading to a separate object. Each evaluation of new creates a separate object, even when the arguments match.

Copy the value, then follow the result

With primitives, changing the copied variable leaves the first variable alone:

int a = 5;
int b = a;
b = b + 1;

The last line reads 5 from b, adds 1 and stores 6 in b. The value in a remains 5.

For a reference example, use this small class:

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Now trace these statements:

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Only the first line creates a counter. The second line copies the reference, so the method call changes the one counter that both variables reach. To make an independent counter with matching data, write new Counter(first.value()). Copying a variable does not call a constructor.

Wrappers and immutable strings

Every primitive type has a wrapper class, such as Integer, Double, Boolean or Character. Wrapper variables hold references or null. Java can convert automatically between a primitive and its wrapper; these conversions are autoboxing and unboxing. Lists hold references, so a list of integers is ArrayList<Integer>.

String is also a reference type, but its objects are immutable: their characters cannot change after creation.

String s = "java";
String t = s;
t = t.toUpperCase();

Here s still refers to "java" and t refers to "JAVA". The last line assigns the result to t; it does not change the shared original string. String methods may reuse the original object when no change is needed.

Printing an object uses its toString() method. Without an override, the inherited result has a form such as Counter@7e9e5f8a: class name, @ and a hexadecimal hash code. Define toString() when printed output should show the object's data.

Two variables that refer to the same object are aliases. An alias gives another route to existing data. To trace a program, keep the variables separate from the objects they reach.

Mutation changes data; reassignment changes a variable

A mutation changes an object's state, such as its stored weight. A reassignment puts a different value into a variable. For a reference variable, that changes its arrow.

Use a box whose weight is in kilograms:

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Follow this sequence:

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Draw variable a pointing to object A, with weight 2.
2. Draw b pointing to that same object A. There is still one box.
3. Change the weight inside object A to 5. Both routes now reach weight 5.
4. Create object B with weight 7 and redirect only b to it.

At the end, a.getWeight() is 5 and b.getWeight() is 7. The fourth statement neither resets object A nor moves a to object B.

Reachability controls an object's lifetime

An object is reachable while the running program can follow some usable chain of references to it. That chain may run through a variable, an object field or a list element. A local variable disappearing is therefore not enough to make an object unreachable if a list still holds it.

Continue the trace with a = null;. Object A, weighing 5 kg, now has no reachable path in this example. It is eligible for garbage collection. Java automatically reclaims memory from unreachable objects, but the collector chooses when; the assignment does not promise immediate collection. Object B remains reachable through b.

You do not free Java objects by hand. When a program loses its last usable reference to an object, it also loses the ability to inspect or change that object's data.

Find the hidden aliases

Aliases arise when an object is added to a list, passed to a method, returned from a method or stored in another object's field. Each operation can pass on a reference. Before mutating an object received from elsewhere, identify which other code can still reach it.

A common bug starts with the thought, "I copied the variable, so I have my own box." Use a fresh object when changes should be independent. To diagnose the bug, count object creations separately from assignments, label each object once, and process every statement in order. Do not redraw an object just because a second variable now points to it.

The value null means that a reference leads to no object. It is useful for an absent result, but a program must handle that absence before it tries to use an object.

Missing is different from empty

String text = ""; refers to a real string with length 0. String text = null; refers to no string, so there is no object on which to call length().

A primitive cannot hold null: int x = null; does not compile. A wrapper can hold it: Integer x = null; compiles. Converting that wrapper to a primitive with int y = x; throws a NullPointerException, because unboxing needs a wrapper object.

Fields get initial default values when an object is created. Reference fields start as null, numeric fields as 0 and boolean fields as false, until initialization assigns other values. Local variables have no default. Reading a local before assigning it causes a compile error, such as "variable might not have been initialized".

Find the missing reference

Calling an instance method through null, accessing an instance field through it or reading an array's length through it throws NullPointerException at runtime. For example:

String name = null;
System.out.println(name.length());

Read the exception's line number, then identify which reference on that line was missing. Helpful messages are enabled by default from Java 15. A message may say Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null. Local names may appear as placeholders such as <local4>, depending on compilation details. Trace back to the constructor, assignment or search that should have supplied the object.

Printing a String variable whose value is null prints "null"; concatenating it produces text such as "Hi null". These operations do not need to call an instance method through that variable. They can reveal missing data before a later method call fails.

Check before using

The operator && short-circuits: it evaluates the right side only if the left side is true.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

When name is null, the first test is false and length() is skipped. Reversing the two tests loses that protection: the method call would run first.

The fixed string is a known object, so its equals can receive null and return false. command.equals("quit") fails when command is null. Likewise, x.equals(null) is no way to check whether x exists: it already requires an object.

Make absence a clear design choice

Initialize a list field to new ArrayList<>() so that an empty collection is available immediately. If a search returns null for "not found", document that result and check it at the call site. Avoid filling every field with arbitrary objects merely to silence an exception: supply the object the program needs, or give absence a clear meaning that the calling code handles.

Java passes every argument by value. A parameter is a new variable that receives a copy of the argument's value. For an object argument, the copied value is a reference.

Change the parameter or change the object?

A primitive parameter has its own data:

static void addTen(int n) {
    n = n + 10;
}

If x is 5, calling addTen(x) leaves x at 5. Only the local parameter n becomes 15.

A reference parameter can reach the same object as the caller. Suppose Person.growOlder() increases the stored age:

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

During celebrate(ana), the parameter p and variable ana are aliases. The changed age remains visible afterward. During replace(ana), assigning p redirects only that parameter. The caller's ana still refers to the original person. A method that swaps two reference parameters has the same limit: it swaps its own copies, not the caller's variables.

Receive another class's object

A gate can read a person's height and keep its own count of checks. This class expects a non-null person with a getHeight() method returning centimeters:

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

For a gate set to 120 cm, checking people of 132 cm and 115 cm returns true and false. The gate then reports 2 checks. It reads the person's height through a public method and changes its own counter.

Receive another object of the same class

Inside SimpleDate.before(SimpleDate other), this is the date receiving the call and other is the argument. A class can read the private fields of any object of that same class.

For fields day, month and year, compare in order:

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

For 14 March 2001 and 2 November 2001, years match and month 3 is less than month 11, so the first date is earlier. Equal dates return false because neither is before the other.

Person.olderThan(other) can delegate to birthday.before(other.birthday). The date comparison belongs with the date data. Methods that call instance methods on a parameter need a non-null argument; either check it or make that requirement part of the method's documented use.

An object-returning method returns a reference. Its type tells you what kind of object can be returned, but it does not tell you whether the object is new, shared or absent. The method's purpose must make that choice clear.

Create a result

A factory method supplies an object. It can create one or reuse an existing one. Here each call deliberately creates a separate ticket:

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

The machine expects a Ticket constructor that stores its number. Three calls create three tickets numbered 1, 2 and 3. Returning a local variable is safe: its reference is copied to the caller, which can keep the object reachable after the local variable goes out of scope.

A copy method promises an independent object. In the Counter class:

Counter copy() {
    return new Counter(this.value);
}

After Counter a = new Counter(4); Counter b = a.copy(); b.increase();, a.value() is 4 and b.value() is 5. Replacing a.copy() with a would share the counter.

A method can also build a computed object. For a Point with double fields x and y:

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

Points (2, 4) and (6, 10) give (4.0, 7.0). The method computes each coordinate and passes both to a new point; neither original point changes.

Return an object already stored

A register's findByName should return the matching stored person if callers need to work with that entry. Creating new Person(name, 0) would return invented replacement data and disconnect later changes from the register.

A search may return null when no match exists:

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

If p is the stored person, changes through p also change the person reached by the register. A return statement does not copy the object.

Keep mutable internal state under control

Suppose Person.getBirthday() returns its SimpleDate field and that date has setters. A caller can then change the person's birthday without calling a Person method. This is an exposure of mutable state.

To protect the field, return a new date built from its values:

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

This version requires a birthday object to have been initialized. Other designs use an immutable date or offer specific queries without a date getter. Choose the behavior for each method: find normally shares a stored entry, while copy creates independence. A getter's short name alone is no promise of protection.

Composition builds a class using fields whose types are other classes. It expresses a "has a" relationship: a person has a birthday; a course has a teacher. The outer object stores a reference to the contained object.

Create and connect the objects

A constructor can receive an existing date:

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

Calling new Person("Ana", new SimpleDate(14, 3, 2001)) first creates a date and then gives its reference to the person. Alternatively, a person constructor can receive day, month and year and create the date inside its body. With that approach, the caller does not retain a reference to that newly created date.

Delegate work to the contained object

The call birthday.before(other.birthday) asks the date object to compare dates. Person does not need to repeat the year-month-day comparisons. Concatenation in toString() also delegates: Java calls the birthday object's toString() to obtain its text.

A date object can help compute age. Start with the current year minus the birth year. Then form this year's birthday and subtract one if the current date comes before it. A person born on 14 March 2001 is 24 on 1 January 2026: the year difference is 25, but the birthday has not arrived. On 14 March 2026, the birthday has arrived and the age is 25. Keeping the date comparison in SimpleDate avoids reproducing its rules in every person method.

Decide whether the inner object is shared

The constructor above stores its argument directly. If two people receive one mutable SimpleDate, both birthday fields point to the same date. Changing that date affects both people.

A defensive constructor can copy the incoming date's day, month and year. An immutable date has no state-changing methods and keeps its values fixed; simple primitive fields can be final. Copying on input matters even if a getter later returns a copy, because the original caller may still hold the incoming object.

Handle optional connections

A Course might have no teacher yet. If that is a meaningful state, teacherName() can check the field and return "no teacher yet". Otherwise, require a teacher at construction.

In course.getTeacher().getName(), each instance call needs an object: a null course fails at getTeacher(), and a null teacher fails at getName(). A method on the course can keep that absence check in one place and avoid making every caller know the same chain.

An ArrayList<Person> is an object whose elements hold references to people. The list controls its sequence of entries; each person controls its own fields. These are separate kinds of change.

Add an object and reach it again

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

This code needs import java.util.ArrayList; and an existing non-null person ana. add copies the reference. The growOlder() call reaches the same person as ana, so the age change is visible through either route. The list never creates a second person here.

You can create an object while adding it: people.add(new Person("Lin", 1998));, using a person constructor that accepts a name and birth year. The list then gives the program a route to that new person through get or a loop. List type arguments must be reference types, so use ArrayList<Integer> for whole numbers.

Compute from objects and select an object

Suppose a list holds parcels with weights 2.5 kg, 4.0 kg and 1.5 kg. A loop adds each parcel's weight:

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

The running totals are 2.5, 6.5 and 8.0 kg. Selecting the heaviest parcel needs a reference as well as a comparison:

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

This selection expects a nonempty list. The result is the 4.0 kg parcel object, so the caller can use its other methods too. For an empty list, decide on an absent result before reading element 0.

Search every entry

A name search in a class that stores people can use:

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

This version expects non-null people with non-null names. The first match is returned immediately. The final return null belongs after the loop: a failed comparison on the first person does not rule out later matches.

contains, indexOf and remove(Object) search using equals. If Person inherits identity-based equality, a newly constructed person will not match an existing one just because their fields match.

Remove membership without destroying an object

One object can appear twice in one list or in several lists. Removing an entry does not destroy the object or remove other references to it.

Do not remove entries directly from the same list during a for-each traversal. It can trigger ConcurrentModificationException. Collect candidates first, then remove them:

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

The traversal finishes before the list's membership changes. removeAll uses equality, so it removes entries equal to the collected candidates.

A class can keep a list in a private field and offer operations that describe its purpose. A playlist stores songs, counts them and calculates duration. Callers should not need to manage its list directly.

Initialize and wrap the collection

This playlist expects non-null Song objects with a seconds() method:

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Without new ArrayList<>(), the reference field remains null; the first call to add then fails. An empty list is already a usable object, with size 0.

For songs lasting 210 s, 185 s and 247 s, count() returns 3. The total grows from 210 to 395 to 642 s. Integer division by 60 gives 10 minutes, with remainder 42 seconds. A longest() method can select and return the 247 s song, using the same reference-selection pattern as the heaviest parcel. Define an absent result for an empty playlist.

Protect membership through methods

Keeping songs private blocks direct field access, but return songs; exposes that very list. A caller could call clear() and bypass every playlist rule.

Specific operations such as add, count and totalSeconds keep responsibility with the playlist. Its add method could enforce a maximum size or refuse duplicates with songs.contains(song). Content-based duplicate checks need the song class's equals to define which fields make two songs equal.

When a constructor receives an initial list, copy its structure with this.songs = new ArrayList<>(initialSongs);. Storing the parameter directly would let the caller keep an alias to the playlist's internal list.

A new list can still share songs

A query can return new ArrayList<>(songs). This is a shallow copy: a new list object, containing the existing song references.

A songsLongerThan(200) query creates a fresh result list, loops over the stored songs and adds those whose duration exceeds 200 s. For the three songs above it returns the 210 s and 247 s songs. When song values must also be independent, copy the mutable songs or make Song immutable.

Identity asks whether two references lead to the same object. Content equality asks whether objects have the same relevant data, according to the class's rules. Two separate book objects can describe the same title and publication year without being identical.

Choose the right comparison

Every class inherits equals(Object) from Object. That default checks identity. Java does not inspect all the fields of a new class automatically.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String creates a separate object, while String.equals compares its characters. Text comparison is case-sensitive: "Java".equals("java") is false. equalsIgnoreCase gives a case-insensitive comparison when that is the intended rule.

Why identity sometimes seems to compare content

Equal string literals share a string object, so "java" == "java" is true. This can hide a bug in a small test. Text obtained from input or constructed while a program runs need not share that object. Use equals for content regardless of how the text was obtained.

Wrapper comparisons have a similar trap:

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

Autoboxing reuses Integer objects for values from -128 through 127. Whether larger values share an object is not a portable numeric comparison rule. On a standard setup the two 1000 wrappers are separate, but a larger cache is permitted. Use wrapper equals for matching wrapper values or compare primitives. If one side of == is an int, Java unboxes the wrapper and compares numeric values; unboxing a null wrapper fails.

Decide which fields define equality

For a book catalog, title and publication year might define equality while the current borrower is ignored. Those selected fields must drive the equality method. Another program could choose a unique identifier instead; the useful rule depends on what its objects represent.

An ArrayList uses equals in contains, indexOf and remove(Object). Suppose Book only stores fields and inherits equals. Adding one new Book("Dune", 1965) does not make contains(new Book("Dune", 1965)) true: the second expression creates a different object. Overriding equality by title and year lets a search find that equal content.

HashSet and HashMap also use hashCode to narrow the candidate objects before checking equality. Defining content equality therefore requires a matching hash-code rule as well.

An equality method must replace the inherited equals(Object) and compare the fields that define your object's meaning. The correct signature matters as much as the comparisons inside it.

A complete equality pattern

This class uses title and year, allows a null title, and keeps its equality fields fixed:

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Read equals in four steps. The identity check accepts the same object immediately. The type check rejects anything that is not a book, including null. The cast gives a Book variable through which the fields can be read. The final expression checks both equality fields.

The parameter type is Object, not Book. Writing equals(Book other) overloads the name with another method and leaves the inherited equals(Object) unchanged. A direct call can then appear to work while ArrayList.contains still uses identity. @Override makes the compiler catch that signature mistake.

From Java 16, the type check and cast can be combined: if (!(other instanceof Book book)) { return false; }. After the check succeeds, book is available for field comparisons.

Match comparisons to field types

Use == for integral, character and boolean fields. Use an object's equals for its content. For a nullable object field, Objects.equals(a, b) returns true when both are null, false when only one is null, and otherwise uses equality.

For double fields, Double.compare(x, other.x) == 0 supplies consistent special-value handling: two NaNs compare as equal, and positive and negative zero are distinguished. Pair that choice with a compatible hash rule. Raw floating-point == treats NaN differently.

Check the equality contract

For non-null references, equality must be:

• Reflexive: x.equals(x) is true.
• Symmetric: x.equals(y) and y.equals(x) agree.
• Transitive: if x equals y and y equals z, x equals z.
• Consistent: repeated calls agree while the compared data stays unchanged.
• False for null: x.equals(null) is false.

Two books for "Dune", 1965 compare equal; changing one year to 1984 makes them unequal. A book must not compare equal to a string containing its title: the string would reject the book, breaking symmetry.

Some implementations use other == null || getClass() != other.getClass() for the type check. It rejects different runtime classes. instanceof can accept subclasses; for the final class above, no subclass exists and the two checks agree.

A hash code is an integer used to narrow a search. HashSet and HashMap use it to find candidate objects, then use equals to confirm a match. It is not a unique object identifier.

The contract goes in one direction

Equal objects must return the same hash code. Unequal objects may also share a code; that is a collision. A collision does not make them equal, because equality is still checked.

A hash code must stay consistent while the information used by equals stays unchanged. For a correct implementation, different hash codes rule out equality, but equal hash codes do not establish it.

When a class overrides equals but inherits Object.hashCode, separate equal objects commonly receive different codes. A set may then retain both, and a map lookup using a fresh equal key may miss. The exact failure is not guaranteed, because different objects can have colliding inherited codes. Fix the contract instead of relying on a particular failed lookup.

Compute from the equality fields

For the book class that compares title and year:

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Import java.util.Objects. The same field values now produce the same result. A book set stores one entry after adding two equal books, and a map can retrieve a value using a fresh equal book key.

Objects.hash combines the field hashes using 31. For "Dune", the string hash is 2141736. Combining that title and year 1965 gives 31 multiplied by the sum of 31 and 2141736, then adds 1965: the result is 66396742.

String hashing also uses 31. For "ab", character codes 97 and 98 give 97 multiplied by 31 plus 98, or 3105. Longer calculations can overflow the int range and wrap, so a negative hash code is normal.

Do not change the key during storage

Suppose a book's year is mutable and affects its hash code. After insertion in a set, changing the year can make contains(book) fail even with that same reference: the lookup now searches using a different code. The set can still report size 1.

Keep equality fields stable while an object is a set element or a map key. If they must change, remove the object while its old values still apply, change it and insert it again. Trying removal only after the change can encounter the same lookup problem.

Generated equality still needs a sound data choice

Java 16 and later support records, such as record Book(String title, int year) {}. A record generates accessors title() and year(), plus equality, hashing and a readable string form from all its components. Component fields are final. This example is a useful immutable value because its components are a string and an integer; a record holding a mutable list would still share that list's state.

For ordinary classes, an IDE can generate equals and hashCode together. Select the fields that define the intended equality and keep both methods aligned when that choice changes.

The user interface reads input and displays output. The program logic stores data and applies rules. A separated design passes values into the logic and gets results back; its logic classes do not use Scanner or System.out.

Connect the objects in main

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

With import java.util.Scanner;, this wiring creates one input reader, one log and one interface. It belongs inside the program's entry class. UserInterface stores the supplied objects in fields so that every command works with that same log.

Return values that any caller can use

A log might provide add(double celsius), count(), average() and max(). Readings of 18.5, 21.0 and 19.5 °C have sum 59.0, count 3, maximum 21.0 and average about 19.6667 °C. The UI can round the returned average with Math.round(average * 10) / 10.0 and show 19.7 °C.

Returning the number makes direct checks easy. A method named printAverage() that does only printing couples a calculation to console output, which makes reuse more awkward.

For a simple command loop, suppose add accepts valid temperatures and count returns their number:

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

The loop handles interaction. It asks the log for a result and prints it without knowing how readings are stored. An average command should handle an empty log according to the logic's documented result or check count() before calling a method that requires readings.

Validate at the right boundary

The logic can make add return false without storing a reading below -273.15 °C. Every caller then gets the same data rule. The UI decides how to report that rejection and ask again. Converting nonnumeric input into a useful error message is also interface work.

Use one Scanner for System.in and pass it to readers. Multiple scanners can compete for buffered input, and closing one closes the underlying input stream. Keep the lifetime of the shared scanner with the code that owns the program's input.

The logic can later support another interface through the same public methods. Reuse comes from keeping calculations and validity rules available as method results, independently of a particular command loop.

A separated program can grow one small change at a time. Give the logic a useful method, check it directly, then connect a command that gathers its input and displays its result.

Add a query to the logic

A TemperatureLog storing an initialized ArrayList<Double> readings can count readings above a limit:

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

The strict comparison excludes readings exactly equal to the limit. For 18.5, 21.0, 19.5 and 23.0 °C, countAbove(20.0) returns 2. Put the comparison in the log so every caller gets the same rule.

The UI command reads a limit, calls log.countAbove(limit) and prints the count. If each command grows long, split start() into private helpers such as addReading() and showStatistics(). The helpers organize interaction; they do not move the data rules out of the log.

Check without typing commands

Create the logic object and call its methods with values whose answers you know:

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

The sum is 82.0, so the expected average is 20.5. These particular values have exact binary representations, making these direct equality checks suitable for the example. Also check an empty log according to its documented behavior, a limit matching a reading, and rejection of invalid input without changing the count. Automated test tools build on the same idea of a known input and an expected result.

Change storage only when it still supports the queries

An interface that calls only average, count and max need not know whether the log holds a list. Running sum, count and maximum fields can answer those three queries without retaining every reading.

An arbitrary countAbove(limit) query needs more information. The samples 18, 22, 23 and 20, 20, 23 have the same sum 63, count 3 and maximum 23, but their counts above 20 are 2 and 1. Keeping only those three aggregates loses the distinction. The public methods describe what must still work after a storage change.

Combine the design ideas

A recipe book can own a private list of recipes. Each recipe can contain ingredients measured in grams and a cooking time in minutes. Equality can support duplicate checks, while a UI adds, lists and searches recipes through the book's methods. A copied result list can protect membership while still sharing recipe objects; decide whether callers may change those recipes.

Work in small steps: implement one method, check it and then add its command. If a change breaks an existing result, return to a working state and isolate that change before adding another feature.