Object-Oriented Programming in Java

Run a complete example · 01

Observe when conversion happens

Compare integer division, floating division, and widening before multiplication.

public class Main {

    public static void main(String[] args) {
        int trips = 7, days = 2;
        double late = trips / days;
        double early = (double)trips / days;
        int width = 50000;
        long area = (long)width * width;
        System.out.println("late=" + late);
        System.out.println("early=" + early);
        System.out.println("area=" + area);
        System.out.println("truncate=" + (int)-3.9);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

late=3.0
early=3.5
area=2500000000
truncate=-3

Follow the execution

1. Declare trips and days as int, so the first division uses integer arithmetic.

2. Cast trips before division and width before multiplication to change the operation’s type.

3. Print named results so the point where information is lost is visible.

Read the code step by step

The operands determine the division type before assignment. late receives 3.0 because 7/2 has already become 3. early converts trips first, so division keeps the fractional part.

The cast before multiplication makes the product a long. The final cast truncates toward zero, giving −3 rather than −4. These are language rules, not guesses about processor storage.

Run a complete example · 02

Separate parsing from accepted range

Process fixed text inputs without interactive prompts.

public class Main {

    public static void main(String[] args) {
        for (String text : new String[] {"12", "-2", "twelve", "2147483648"}) {
            try {
                int value = Integer.parseInt(text);
                if (value < 0)
                    System.out.println(text + ": negative count");
                else
                    System.out.println(text + ": accepted " + value);
            } catch (NumberFormatException ex) {
                System.out.println(text + ": invalid int text");
            }
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

12: accepted 12
-2: negative count
twelve: invalid int text
2147483648: invalid int text

Follow the execution

1. The array supplies four contrasting inputs in a fixed order.

2. parseInt validates the decimal int representation before the sign rule runs.

3. The catch reports conversion failure and lets the next iteration proceed.

Read the code step by step

Each text is parsed inside its own try block. A syntactically valid negative integer reaches the domain check. Nonnumeric text and an integer outside the int range both fail parsing.

The loop continues after a failed item because the handler is inside the loop. No invalid value is silently changed to zero.

Run a complete example · 01

Trace the processed prefix

Print the invariant’s state after each update.

public class Main {

    public static void main(String[] args) {
        int[] values = {4, 0, 7};
        int total = 0;
        for (int i = 0; i < values.length; i++) {
            total += values[i];
            System.out.println("processed=" + (i + 1) + ", total=" + total);
        }
        int emptyTotal = 0;
        for (int value : new int[0])
            emptyTotal += value;
        System.out.println("empty total=" + emptyTotal);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

processed=1, total=4
processed=2, total=4
processed=3, total=11
empty total=0

Follow the execution

1. Initialize total to establish the empty-prefix invariant.

2. Use i<length so every indexed read is within bounds.

3. Print after adding, then separately run the same accumulation idea on empty input.

Read the code step by step

Before iteration i, total contains exactly the first i entries. Adding values[i] extends that prefix by one. The printed processed count is i+1 because printing follows the addition.

The empty enhanced-for loop executes no body. Its total remains zero. This contrast checks the boundary without introducing a special-case return.

Run a complete example · 02

Guard null and stop at the first match

Combine short-circuit guards with a bounded search.

public class Main {

    public static void main(String[] args) {
        String[] names = {null, "", "oak", "pine", "elm"};
        int found = -1;
        for (int i = 0; i < names.length; i++) {
            String name = names[i];
            if (name == null || name.isEmpty())
                continue;
            if (name.length() == 4) {
                found = i;
                break;
            }
        }
        System.out.println("first length-four index=" + found);
        System.out.println("matched=" + names[found]);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

first length-four index=3
matched=pine

Follow the execution

1. Use −1 as a documented no-match marker.

2. Skip invalid entries with continue before calling other String methods.

3. Store the first matching index and exit the loop with break.

Read the code step by step

The guard skips missing or empty names. If name is null, || does not call isEmpty. A surviving name is safe to inspect.

The first four-letter name is pine at index three. break preserves the meaning “first match.” The example knows a match exists; a general caller must check found before indexing.

Run a complete example · 01

Compare mutation with reassignment

Keep the caller’s original array visible after the call.

import java.util.Arrays;

public class Main {
    static void change(int[] x) {
        x[0] = 10;
        System.out.println("after mutation=" + Arrays.toString(x));
        x = new int[] {1, 2};
        System.out.println("local replacement=" + Arrays.toString(x));
    }
    public static void main(String[] args) {
        int[] scores = {6, 8};
        change(scores);
        System.out.println("caller=" + Arrays.toString(scores));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

after mutation=[10, 8]
local replacement=[1, 2]
caller=[10, 8]

Follow the execution

1. Pass the scores reference value into a fresh parameter x.

2. Modify the shared element before rebinding the parameter.

3. Inspect scores after return to observe which change survived.

Read the code step by step

Both references initially reach one array. Element assignment changes that array. Reassigning x creates a different route for the callee alone.

The caller still sees [10,8]. Printing inside the method and after return exposes both states without pretending references are numeric addresses.

Run a complete example · 02

Return a replacement deliberately

Contrast copying a primitive wrapper with accepting a returned array.

import java.util.Arrays;

public class Main {
    static void increment(Integer x) {
        x++;
        System.out.println("local count=" + x);
    }
    static int[] doubled(int[] input) {
        int[] result = input.clone();
        for (int i = 0; i < result.length; i++)
            result[i] *= 2;
        return result;
    }
    public static void main(String[] args) {
        Integer count = 4;
        increment(count);
        System.out.println("caller count=" + count);
        int[] values = {2, 5};
        int[] replacement = doubled(values);
        System.out.println("original=" + Arrays.toString(values));
        values = replacement;
        System.out.println("adopted=" + Arrays.toString(values));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

local count=5
caller count=4
original=[2, 5]
adopted=[4, 10]

Follow the execution

1. Observe a local wrapper replacement separately from the caller’s count.

2. Clone before doubling so the input contract has no mutation.

3. Assign the returned reference explicitly at the caller.

Read the code step by step

Incrementing the wrapper reassigns only a local parameter. doubled creates an independent primitive array and edits that copy.

The original remains [2,5] until the caller chooses to replace its variable with the returned reference. Other aliases to the old array would still reach the old array.

Run a complete example · 01

Trace shallow and row-wise copies

Observe which edit crosses each copying boundary.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int[][] original = {{2, 5}, {9}};
        int[][] shallow = original.clone();
        shallow[0][1] = 7;
        shallow[1] = new int[] {4, 6, 8};
        System.out.println("original=" + Arrays.deepToString(original));
        System.out.println("shallow=" + Arrays.deepToString(shallow));
        int[][] isolated = new int[original.length][];
        for (int i = 0; i < original.length; i++)
            isolated[i] = original[i].clone();
        isolated[0][0] = 99;
        System.out.println("original after isolated edit=" +
                           Arrays.deepToString(original));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

original=[[2, 7], [9]]
shallow=[[2, 7], [4, 6, 8]]
original after isolated edit=[[2, 7], [9]]

Follow the execution

1. Clone the outer array and mutate one shared row.

2. Replace one row reference to separate slot mutation from cell mutation.

3. Clone individual rows before making an isolated edit.

Read the code step by step

The outer clone shares both original rows. Editing a cell is visible through original. Replacing shallow[1] changes only that outer slot.

The second copy clones every primitive row. Its later cell edit cannot change original. The example has no null rows; a general copier must check for them.

Run a complete example · 02

Handle null rows and checked stores

Show two array boundaries without letting the program crash.

public class Main {

    public static void main(String[] args) {
        int[][] rows = {{1, 2}, null, {}, {3}};
        int cells = 0;
        for (int[] row : rows)
            if (row != null)
                cells += row.length;
        System.out.println("cells=" + cells);
        Object[] values = new String[2];
        values[0] = "safe";
        try {
            values[1] = Integer.valueOf(5);
        } catch (ArrayStoreException ex) {
            System.out.println("incompatible store rejected");
        }
        System.out.println("second slot=" + values[1]);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

cells=3
incompatible store rejected
second slot=null

Follow the execution

1. Guard row!=null before reading length.

2. Assign a String array to a wider reference type while retaining its actual component type.

3. Catch the deliberate store failure and inspect unchanged state.

Read the code step by step

Counting uses each existing row’s own length. The null row contributes no count because no array exists there.

The Object[] variable aliases an actual String array. The Integer store throws before changing the slot, so the final slot remains null. This illustrates why generic collections choose invariant type rules.

Run a complete example · 01

Separate text value from object identity

Use distinct objects so literal interning cannot hide a bad comparison.

public class Main {

    public static void main(String[] args) {
        String a = new String("harbor");
        String b = new String("harbor");
        System.out.println("identity=" + (a == b));
        System.out.println("content=" + a.equals(b));
        a.toUpperCase(java.util.Locale.ROOT);
        System.out.println("ignored result=" + a);
        a = a.toUpperCase(java.util.Locale.ROOT);
        System.out.println("assigned result=" + a);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

identity=false
content=true
ignored result=harbor
assigned result=HARBOR

Follow the execution

1. Create equal text in different objects and print both comparison rules.

2. Call a transformation without assigning its result.

3. Assign the returned String and inspect the changed variable.

Read the code step by step

new guarantees distinct String objects for this comparison. equals checks their content. Locale.ROOT makes the case conversion independent of the machine’s default locale.

The first conversion result is discarded. The second is assigned to a, which changes the reference held by the variable rather than mutating the old String.

Run a complete example · 02

Build labels and count Unicode units

Contrast text assembly with the unit used for indexing.

public class Main {

    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        for (int day = 1; day <= 3; day++) {
            if (day > 1)
                builder.append(", ");
            builder.append("Day ").append(day);
        }
        System.out.println(builder.toString());
        String symbol = new String(Character.toChars(0x1F680));
        System.out.println("code units=" + symbol.length());
        System.out.println("code points=" + symbol.codePointCount(0, symbol.length()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

Day 1, Day 2, Day 3
code units=2
code points=1

Follow the execution

1. Append separators conditionally while the loop generates labels.

2. Create a supplementary code point with Character.toChars.

3. Compare length with codePointCount using the same complete String range.

Read the code step by step

The separator is added only after the first label, avoiding a leading comma. Chained appends operate on the same builder.

The rocket code point is outside the basic multilingual plane. Java represents it with two code units, while codePointCount reports one code point. This does not claim that code points always equal user-perceived characters.

Run a complete example · 01

Protect a capacity invariant

Test success, rejection, and independent instance state.

public class Main {
    static final class Dispenser {
        private final int capacity;
        private int level;
        Dispenser(int capacity, int level) {
            if (capacity < 0 || level < 0 || level > capacity)
                throw new IllegalArgumentException("invalid state");
            this.capacity = capacity;
            this.level = level;
        }
        void fill(int amount) {
            if (amount < 0 || amount > capacity - level)
                throw new IllegalArgumentException("does not fit");
            level += amount;
        }
        int level() {
            return level;
        }
    }
    public static void main(String[] args) {
        Dispenser a = new Dispenser(12, 4);
        Dispenser b = new Dispenser(8, 0);
        a.fill(5);
        System.out.println("after fill=" + a.level());
        try {
            a.fill(4);
        } catch (IllegalArgumentException ex) {
            System.out.println("rejected");
        }
        System.out.println("after rejection=" + a.level());
        System.out.println("other instance=" + b.level());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

after fill=9
rejected
after rejection=9
other instance=0

Follow the execution

1. Construct two valid instances with separate fields.

2. Accept five units, then reject four without mutation.

3. Read both instances to test rejection and isolation.

Read the code step by step

The constructor establishes the invariant once. Every fill preserves it by checking remaining capacity before addition. Private fields keep unchecked writes outside the public operation.

The rejected request leaves level at nine. The second instance remains empty because level is an instance field, not shared static state.

Run a complete example · 02

Protect an internal array

Attack both input and output aliases with deliberate edits.

import java.util.Arrays;

public class Main {
    static final class Snapshot {
        private final int[] values;
        Snapshot(int[] values) {
            this.values = values.clone();
        }
        int[] values() {
            return values.clone();
        }
    }
    public static void main(String[] args) {
        int[] supplied = {2, 5};
        Snapshot snapshot = new Snapshot(supplied);
        supplied[0] = 99;
        int[] exported = snapshot.values();
        exported[1] = 77;
        System.out.println("supplied=" + Arrays.toString(supplied));
        System.out.println("exported=" + Arrays.toString(exported));
        System.out.println("protected=" + Arrays.toString(snapshot.values()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

supplied=[99, 5]
exported=[2, 77]
protected=[2, 5]

Follow the execution

1. Copy the array at construction rather than retaining the caller’s alias.

2. Return a copy when exposing the values.

3. Print a fresh getter result after both outside edits.

Read the code step by step

The constructor stores a clone, so editing supplied cannot change the snapshot. The getter returns another clone, so editing exported cannot change it either.

This is sufficient for primitive integer cells. An array of mutable objects would need a deeper ownership policy. The final field alone would not supply either protection.

Run a complete example · 03

Protect a score snapshot from outside changes

Mina records three quiz scores. She gives the array to a report object, then corrects her own working array. The printed report unexpectedly changes. Making the field private did not stop this: both variables still pointed to the same array. She changes the constructor to copy the input. Then she notices that a getter can leak the same array again. A second copy at the output boundary makes the report a stable snapshot.

import java.util.Arrays;
public class Main {
    static final class ScoreSnapshot {
        private final int[] scores;
        ScoreSnapshot(int[] source) {
            if (source == null) throw new IllegalArgumentException("missing scores");
            int[] copy = source.clone();
            for (int score : copy) {
                if (score < 0 || score > 100)
                    throw new IllegalArgumentException("score out of range");
            }
            scores = copy;
        }
        int[] values() { return scores.clone(); }
        int total() {
            int sum = 0;
            for (int score : scores) sum = Math.addExact(sum, score);
            return sum;
        }
    }
    public static void main(String[] args) {
        int[] input = {70, 80, 90};
        ScoreSnapshot report = new ScoreSnapshot(input);
        input[0] = 0;
        int[] exported = report.values();
        exported[1] = 0;
        assert report.total() == 240;
        System.out.println("snapshot: " + Arrays.toString(report.values()));
        System.out.println("total: " + report.total());
        try { new ScoreSnapshot(new int[]{101}); }
        catch (IllegalArgumentException error) { System.out.println("invalid score rejected"); }
        assert new ScoreSnapshot(new int[0]).total() == 0;
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

snapshot: [70, 80, 90]
total: 240
invalid score rejected

Follow the execution

1. Copy before storing. Validation examines the actual copy that the object will own.

2. The getter returns another array. Changing that return value cannot change the owned array.

3. Mutate both outside arrays, then check the report. This tests the boundary, not just the initial total.

4. Reject 101. Accept an empty array with total zero. addExact turns an integer overflow into an explicit error.

Read the code step by step

The invariant is 0 <= scores[i] <= 100 for every stored element. Because callers cannot reach the owned array, ordinary external writes cannot break it. final stops reassignment of the field; it does not freeze an array. The two copies perform the protection.

For n scores, construction and each values() call cost O(n) time and O(n) new storage. total() costs O(n) time and O(1) auxiliary space. This is a deliberate cost for a stable interface. A primitive int[] needs only one-level copying. An array of mutable objects would require a separate decision about copying those objects.

Engineering route: first write the invariant, then choose an owner, then test every boundary that accepts or returns mutable data. This example is single-threaded; copying is not a substitute for synchronization when the source is being modified concurrently.

Run a complete example · 01

Observe a token followed by a line

All input is supplied in memory.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner("12\nlamp\n")) {
            int count = scanner.nextInt();
            String remainder = scanner.nextLine();
            String name = scanner.nextLine();
            System.out.println("count=" + count);
            System.out.println("remainder length=" + remainder.length());
            System.out.println("name=" + name);
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

count=12
remainder length=0
name=lamp

Follow the execution

1. Supply a number line followed by a name line.

2. Read the token and explicitly inspect the leftover line.

3. Read the next full line and close the owned scanner.

Read the code step by step

nextInt stops after the digits. The first nextLine reads the remaining empty part of that same line. The following nextLine reads lamp.

Try-with-resources closes the locally owned scanner. This program intentionally shows mixed token and line reading; a consistent line-based format often avoids this boundary surprise.

Run a complete example · 02

Validate complete equipment records

Reject malformed and negative quantities without losing the good records.

import java.io.BufferedReader;
import java.io.StringReader;

public class Main {

    public static void main(String[] args) throws Exception {
        String data = "lamp,3\nchair,5\ndesk,many\nshelf,-2\n";
        int total = 0, lineNumber = 0;
        try (BufferedReader reader = new BufferedReader(new StringReader(data))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lineNumber++;
                String[] fields = line.split(",", -1);
                if (fields.length != 2 || fields[0].trim().isEmpty()) {
                    System.out.println("line " + lineNumber + ": bad structure");
                    continue;
                }
                try {
                    int count = Integer.parseInt(fields[1].trim());
                    if (count < 0) {
                        System.out.println("line " + lineNumber + ": negative count");
                        continue;
                    }
                    total += count;
                } catch (NumberFormatException ex) {
                    System.out.println("line " + lineNumber + ": bad integer");
                }
            }
        }
        System.out.println("accepted total=" + total);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

line 3: bad integer
line 4: negative count
accepted total=8

Follow the execution

1. Read whole lines and maintain a one-based line number.

2. Check record structure before numeric conversion and domain validation.

3. Accumulate only accepted records and report a stable final total.

Read the code step by step

readLine returns null only at end of input. split with −1 preserves an empty final field, allowing structure checks instead of accidentally hiding a missing count.

Only a structurally valid, parsed, nonnegative record contributes to total. The supplied small quantities cannot overflow this demonstration; a large general dataset needs a wider accumulator or checked addition.

Run a complete example · 01

Write and read a sensor record

Use byte-array streams so the program needs no file.

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            out.writeInt(258);
            out.writeDouble(18.5);
        }
        byte[] record = bytes.toByteArray();
        System.out.println("bytes=" + record.length);
        try (DataInputStream in =
                 new DataInputStream(new ByteArrayInputStream(record))) {
            System.out.println("station=" + in.readInt());
            System.out.println("temperature=" + in.readDouble());
            System.out.println("at end=" + (in.read() == -1));
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

bytes=12
station=258
temperature=18.5
at end=true

Follow the execution

1. Write fields in a named, fixed order.

2. Extract the byte array and verify its complete size.

3. Read the matching types and confirm no bytes remain.

Read the code step by step

The writer fixes field order as int then double. The reader repeats that order, consuming four then eight bytes. A final read returns −1 at end of the in-memory stream.

Closing the DataOutputStream flushes its wrapper. ByteArrayOutputStream still permits extracting its bytes afterward. This verifies the chosen primitive layout without filesystem behavior.

Run a complete example · 02

Inspect exact bytes and reject truncation

A shortened copy deliberately lacks one required int byte.

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            out.writeInt(258);
        }
        byte[] full = bytes.toByteArray();
        StringBuilder hex = new StringBuilder();
        for (byte value : full) {
            if (hex.length() > 0)
                hex.append(' ');
            hex.append(String.format(java.util.Locale.ROOT, "%02X", value & 0xff));
        }
        System.out.println("hex=" + hex);
        byte[] shortRecord = java.util.Arrays.copyOf(full, 3);
        try (DataInputStream in =
                 new DataInputStream(new ByteArrayInputStream(shortRecord))) {
            in.readInt();
            System.out.println("unexpected complete record");
        } catch (EOFException ex) {
            System.out.println("truncated int rejected");
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

hex=00 00 01 02
truncated int rejected

Follow the execution

1. Encode a known integer and format each unsigned byte.

2. Create a deterministic three-byte truncated record.

3. Catch only EOFException from the incomplete primitive read.

Read the code step by step

Masking a signed byte with 0xff produces its unsigned display value. Two hexadecimal digits represent each byte. The printed order is 00 00 01 02.

The three-byte copy cannot encode a full DataOutput int. The handler identifies truncation instead of making up the fourth byte. No unrelated I/O exception is silently swallowed.

Run a complete example · 01

Represent events, uniqueness, and counts

Use one input sequence to expose three different contracts.

import java.util.*;

public class Main {

    public static void main(String[] args) {
        List<String> arrivals = Arrays.asList("Mia", "Leo", "Mia");
        Set<String> unique = new HashSet<>(arrivals);
        Map<String, Integer> counts = new LinkedHashMap<>();
        for (String name : arrivals)
            counts.put(name, counts.getOrDefault(name, 0) + 1);
        System.out.println("events=" + arrivals);
        System.out.println("unique count=" + unique.size());
        System.out.println("counts=" + counts);
        counts.put("Mia", 3);
        System.out.println("after replacement=" + counts + ", keys=" + counts.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

events=[Mia, Leo, Mia]
unique count=2
counts={Mia=2, Leo=1}
after replacement={Mia=3, Leo=1}, keys=2

Follow the execution

1. Retain event order in a List and derive unique membership with a Set.

2. Accumulate one map count for every equal name.

3. Replace one mapping and inspect the unchanged key count.

Read the code step by step

The list preserves all arrival events. HashSet supplies only its size here, so unspecified set order cannot affect stdout. LinkedHashMap preserves insertion order for displayed counts.

getOrDefault supplies zero for a new name. put then records the incremented count. A later equal-key put replaces a value rather than creating another logical key.

Run a complete example · 02

Contrast FIFO and LIFO with a deque

Both examples use endpoint operations rather than indexes.

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Deque<String> queue = new ArrayDeque<>();
        queue.addLast("oak");
        queue.addLast("pine");
        queue.addLast("elm");
        StringJoiner fifo = new StringJoiner(", ");
        while (!queue.isEmpty())
            fifo.add(queue.removeFirst());
        Deque<String> stack = new ArrayDeque<>();
        stack.push("oak");
        stack.push("pine");
        stack.push("elm");
        StringJoiner lifo = new StringJoiner(", ");
        while (!stack.isEmpty())
            lifo.add(stack.pop());
        System.out.println("FIFO=" + fifo);
        System.out.println("LIFO=" + lifo);
        System.out.println("empty poll=" + queue.pollFirst());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

FIFO=oak, pine, elm
LIFO=elm, pine, oak
empty poll=null

Follow the execution

1. Enqueue at one end and dequeue at the other.

2. Push and pop at the same end to form a stack.

3. Contrast throwing removal with sentinel-returning polling on empty input.

Read the code step by step

Adding at the tail and removing at the head gives arrival order. push and pop both use the same end, giving reverse arrival order.

removeFirst requires a nonempty queue, so the loop guards it. pollFirst instead returns null for an empty deque. ArrayDeque rejects null elements, keeping that sentinel unambiguous.

Run a complete example · 01

Use immutable seats as value keys

Equal separate objects become one logical set member.

import java.util.*;

public class Main {
    static final class Seat {
        private final String row;
        private final int number;
        Seat(String row, int number) {
            this.row = Objects.requireNonNull(row);
            this.number = number;
        }
        @Override
        public boolean equals(Object other) {
            if (this == other)
                return true;
            if (!(other instanceof Seat))
                return false;
            Seat seat = (Seat)other;
            return number == seat.number && row.equals(seat.row);
        }
        @Override
        public int hashCode() {
            return Objects.hash(row, number);
        }
    }
    public static void main(String[] args) {
        Seat a = new Seat("B", 7), b = new Seat("B", 7);
        Set<Seat> seats = new HashSet<>();
        seats.add(a);
        seats.add(b);
        seats.add(new Seat("B", 8));
        System.out.println("identity=" + (a == b));
        System.out.println("equal=" + a.equals(b));
        System.out.println("equal hashes=" + (a.hashCode() == b.hashCode()));
        System.out.println("logical seats=" + seats.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

identity=false
equal=true
equal hashes=true
logical seats=2

Follow the execution

1. Define equality through Object so collections reach the correct override.

2. Compute hashes from exactly the equality fields.

3. Insert separate equal instances and inspect logical membership count.

Read the code step by step

Seat is final, and its equality fields are stable. equals handles identity, unrelated types, and then the two logical fields. hashCode uses the same fields.

The set size is two even though three objects were created. No set traversal order is printed. This isolates equality behavior from ordering.

Run a complete example · 02

Keep unequal colliding keys distinct

A deliberately poor hash still needs correct equality.

import java.util.*;

public class Main {
    static final class Key {
        private final int id;
        Key(int id) {
            this.id = id;
        }
        @Override
        public boolean equals(Object other) {
            return other instanceof Key && id == ((Key)other).id;
        }
        @Override
        public int hashCode() {
            return 42;
        }
    }
    public static void main(String[] args) {
        Map<Key, String> values = new HashMap<>();
        values.put(new Key(1), "north");
        values.put(new Key(2), "south");
        values.put(new Key(1), "updated");
        System.out.println("keys=" + values.size());
        System.out.println("key 1=" + values.get(new Key(1)));
        System.out.println("key 2=" + values.get(new Key(2)));
        System.out.println("same hash=" +
                           (new Key(1).hashCode() == new Key(2).hashCode()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

keys=2
key 1=updated
key 2=south
same hash=true

Follow the execution

1. Use an immutable integer ID for equality.

2. Force collisions with a constant hash code.

3. Look up each ID through a newly constructed equal key.

Read the code step by step

Both IDs hash to 42. equals still distinguishes one from two, so both mappings survive. Inserting another key with ID one replaces only its equal mapping.

The example deliberately avoids measuring timing. A legal but low-quality hash demonstrates correctness under collisions, not a recommended hashing strategy.

Run a complete example · 03

Use a value object as a map key

A robot club labels floor tiles by row and column. Mina stores a note under one tile object. Later she creates another object for the same coordinates and expects to find the note. Reference identity cannot answer this question. She defines coordinate equality, matches it with a hash function, and keeps the coordinates fixed while the object is used as a key.

import java.util.HashMap;
import java.util.Map;
public class Main {
    static final class Cell {
        private final int row;
        private final int column;
        Cell(int row, int column) { this.row = row; this.column = column; }
        @Override public boolean equals(Object other) {
            if (this == other) return true;
            if (!(other instanceof Cell)) return false;
            Cell cell = (Cell) other;
            return row == cell.row && column == cell.column;
        }
        @Override public int hashCode() { return 31 * row + column; }
    }
    public static void main(String[] args) {
        Cell a = new Cell(2, 3);
        Cell b = new Cell(2, 3);
        Cell collision = new Cell(1, 34);
        Map<Cell, String> notes = new HashMap<>();
        notes.put(a, "charging");
        notes.put(collision, "door");
        assert a != b && a.equals(b) && b.equals(a);
        assert a.hashCode() == collision.hashCode();
        assert !a.equals(collision) && !a.equals(null);
        assert "charging".equals(notes.get(b));
        System.out.println("same object: " + (a == b));
        System.out.println("same value: " + a.equals(b));
        System.out.println("lookup: " + notes.get(b));
        System.out.println("collision keeps both: " + notes.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

same object: false
same value: true
lookup: charging
collision keeps both: 2

Follow the execution

1. Compare both coordinates, rather than memory identity. final prevents subclasses from adding incompatible equality rules.

2. Compute the hash from the same fields used by equals. Equal coordinate pairs therefore have equal hashes.

3. Use (1,34) to deliberately collide with (2,3): both hashes are 65. They are still unequal keys.

4. Query with b, which was never inserted. The successful lookup tests value-based lookup.

Read the code step by step

A hash narrows the search; equals decides whether a candidate is the requested key. The implication is a.equals(b) => a.hashCode() == b.hashCode(). The reverse implication is false, as the collision demonstrates.

The formula h = 31r + c uses row r and column c. It is a small teaching hash, not a cryptographic function. Java int arithmetic can wrap here; the equality contract still requires only equal values to produce equal hashes. A better distribution can reduce collisions but cannot eliminate all collisions for an unbounded key space.

Do not change equality-related fields while a key is stored. The map may look in the bucket corresponding to a new hash, while the entry remains where it was inserted. Immutable keys avoid that failure. Ordinary HashMap access is not made thread-safe by immutable keys.

Run a complete example · 01

Inject a recording collaborator

Test message ordering without external output services.

import java.util.*;

public class Main {
    interface Sink {
        void send(String text);
    }
    static final class RecordingSink implements Sink {
        final List<String> messages = new ArrayList<>();
        public void send(String text) {
            messages.add(Objects.requireNonNull(text));
        }
    }
    static final class Reporter {
        private final Sink sink;
        Reporter(Sink sink) {
            this.sink = Objects.requireNonNull(sink);
        }
        void sendAll(List<String> messages) {
            for (String message : messages)
                sink.send(message);
        }
    }
    public static void main(String[] args) {
        RecordingSink sink = new RecordingSink();
        Reporter reporter = new Reporter(sink);
        reporter.sendAll(Arrays.asList("ready", "running", "done"));
        System.out.println(sink.messages);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

[ready, running, done]

Follow the execution

1. Declare the capability the reporter requires.

2. Pass a concrete recording implementation through the interface.

3. Inspect the ordered effects after the reporter delegates all messages.

Read the code step by step

Reporter stores a Sink interface, not a specific output device. Its loop delegates one send for each message. The recording sink exposes the sequence for this local test.

The test double owns its list. A public production API would normally provide a protected snapshot instead of exposing mutable state. The example’s purpose is responsibility and substitution.

Run a complete example · 02

Preserve a superclass contract

A named counter adds description while retaining valid counting operations.

public class Main {
    static class Counter {
        private int value;
        Counter(int start) {
            if (start < 0)
                throw new IllegalArgumentException();
            value = start;
        }
        void add(int amount) {
            if (amount < 0 || amount > Integer.MAX_VALUE - value)
                throw new IllegalArgumentException();
            value += amount;
        }
        int value() {
            return value;
        }
        String describe() {
            return "count=" + value;
        }
    }
    static final class NamedCounter extends Counter {
        private final String name;
        NamedCounter(String name, int start) {
            super(start);
            this.name = name;
        }
        @Override
        String describe() {
            return name + "=" + value();
        }
    }
    public static void main(String[] args) {
        Counter counter = new NamedCounter("samples", 2);
        counter.add(3);
        System.out.println(counter.describe());
        try {
            counter.add(-1);
        } catch (IllegalArgumentException ex) {
            System.out.println("negative rejected");
        }
        System.out.println("count=" + counter.value());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

samples=5
negative rejected
count=5

Follow the execution

1. Initialize the superclass before storing subclass-specific state.

2. Call inherited operations through a supertype reference.

3. Override presentation without weakening the state invariant.

Read the code step by step

super(start) establishes the inherited valid count. The subclass reads it through value rather than directly changing the private field. Its override changes description only.

The variable has type Counter, but the runtime receiver supplies the named description. add retains its superclass checks, including overflow prevention.