toString, equals, hashCode and records

What every object inherits

Every Java class extends java.lang.Object, directly or indirectly, and inherits methods including toString(), equals(Object) and hashCode(). The default versions are rarely what you want: toString prints something like Product@1b6d3586, and equals behaves like == (same object only).

toString

public class Product {
    private final String sku;
    private final double price;
    public Product(String sku, double price) { this.sku = sku; this.price = price; }

    @Override
    public String toString() {
        return "Product[sku=" + sku + ", price=" + price + "]";
    }
}
System.out.println(new Product("PEN-01", 20));   // Product[sku=PEN-01, price=20.0]

equals and hashCode: a contract

equals decides whether two objects are "the same value" (two Product objects with the same SKU, for example). hashCode returns an int used by hash-based collections (HashMap, HashSet) to decide which bucket an object goes into. The contract: if a.equals(b) is true, then a.hashCode() must equal b.hashCode(). If you override equals but not hashCode, two equal objects land in different buckets and a HashSet will happily store both "duplicates".

import java.util.Objects;

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Product other)) return false;   // pattern matching (Java 16+)
    return sku.equals(other.sku);
}

@Override
public int hashCode() {
    return Objects.hash(sku);   // same fields as equals
}

Records: data classes in one line

Many classes just carry data: a DTO from an API, a point, a money amount. Writing fields, a constructor, getters, equals, hashCode and toString by hand is long and error-prone. A record (Java 16+) declares the components once, and the compiler generates the rest. Records are immutable: their fields are private and final, and there are no setters.

public record Product(String sku, double price) { }

Product p = new Product("PEN-01", 20);
System.out.println(p.sku());           // accessor is sku(), not getSku()
System.out.println(p);                 // Product[sku=PEN-01, price=20.0]
System.out.println(p.equals(new Product("PEN-01", 20)));   // true (all components compared)

Compact constructors for validation

public record Money(long paise, String currency) {
    public Money {                      // compact constructor: no parameter list
        if (paise < 0) throw new IllegalArgumentException("Negative amount");
        currency = currency.toUpperCase();   // you may normalise parameters before they are stored
    }
    public Money plus(Money other) { return new Money(paise + other.paise, currency); }
}

Records can have methods and static members, and can implement interfaces, but cannot extend another class and cannot declare extra instance fields. Use a normal class when the object needs mutable state or inheritance.