Classes & Objects in Java

/**
 * An order in the system.
 * Immutable identity, controlled state changes.
 */
public class Order {

    // === IMMUTABLE IDENTITY (set once, never change) ===
    private final String orderId;
    private final Customer customer;
    private final Instant createdAt;

    // === MUTABLE STATE (changes through controlled methods) ===
    private final List<OrderItem> items;  // final = can't reassign, but CAN modify contents
    private OrderStatus status;

    // === CONSTRUCTOR: Validates and initializes ===
    public Order(String orderId, Customer customer) {
        // Validate inputs
        if (orderId == null || orderId.isBlank()) {
            throw new IllegalArgumentException("orderId required");
        }
        Objects.requireNonNull(customer, "customer required");

        // Initialize immutable fields
        this.orderId = orderId;
        this.customer = customer;
        this.createdAt = Instant.now();

        // Initialize mutable state
        this.items = new ArrayList<>();
        this.status = OrderStatus.PENDING;
    }

    // === BEHAVIOR: Controlled state changes ===
    public void addItem(OrderItem item) {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("Cannot modify non-pending order");
        }
        Objects.requireNonNull(item);
        items.add(item);
    }

    public BigDecimal getTotal() {
        return items.stream()
            .map(OrderItem::getPrice)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    // === GETTERS: Read-only access ===
    public String getOrderId() { return orderId; }
    public Customer getCustomer() { return customer; }
    public OrderStatus getStatus() { return status; }

    // Return COPY to prevent external modification
    public List<OrderItem> getItems() {
        return List.copyOf(items);  // Immutable copy
    }
}

public class EmailAddress {
    private static final Pattern EMAIL_PATTERN =
        Pattern.compile("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$");

    private final String value;

    public EmailAddress(String email) {
        // Validate BEFORE the object can exist
        if (email == null || email.isBlank()) {
            throw new IllegalArgumentException("Email cannot be empty");
        }
        if (!EMAIL_PATTERN.matcher(email).matches()) {
            throw new IllegalArgumentException("Invalid email format: " + email);
        }
        this.value = email.toLowerCase();  // Normalize
    }

    public String getValue() {
        return value;
    }
}

// These FAIL at construction - invalid objects cannot exist
new EmailAddress("");              // IllegalArgumentException
new EmailAddress("not-an-email");  // IllegalArgumentException
new EmailAddress(null);            // IllegalArgumentException
new EmailAddress(12345);           // COMPILE ERROR: wrong type

// If you have an EmailAddress, you KNOW it's valid

public class Counter {
    // static = belongs to the CLASS, not instances
    private static int count = 0;

    // non-static = belongs to each INSTANCE
    private final int id;

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

    // Static method: called on class, not instance
    public static int getTotal() {
        return count;
    }

    // Instance method: called on instance
    public int getId() {
        return this.id;
    }

    public static void reset() {
        count = 0;
    }
}

// Usage:
Counter.getTotal();      // Static: called on class
Counter c = new Counter();
c.getId();               // Instance: called on object

public class Animal {
    private final String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Can be overridden by subclasses
    public String speak() {
        return "...";
    }
}

public class Dog extends Animal {
    private final String breed;

    public Dog(String name, String breed) {
        super(name);  // MUST call parent constructor first
        this.breed = breed;
    }

    @Override  // Explicit annotation - compiler checks this
    public String speak() {
        return "Woof!";
    }

    public String getBreed() {
        return breed;
    }
}

// Single inheritance only (use interfaces for multiple behaviors)
// class FlyingDog extends Dog, Bird  // COMPILE ERROR

public class Money {
    private final BigDecimal amount;
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    @Override
    public boolean equals(Object obj) {
        // 1. Same reference?
        if (this == obj) return true;

        // 2. Null or wrong type?
        if (obj == null || getClass() != obj.getClass()) return false;

        // 3. Compare fields
        Money money = (Money) obj;
        return Objects.equals(amount, money.amount)
            && Objects.equals(currency, money.currency);
    }

    @Override
    public int hashCode() {
        // MUST override if you override equals()
        return Objects.hash(amount, currency);
    }
}

Money m1 = new Money(new BigDecimal("100"), "USD");
Money m2 = new Money(new BigDecimal("100"), "USD");
m1.equals(m2);  // true (value equality)
m1 == m2;       // false (identity/reference)

// This single line generates:
// - Constructor
// - Getters (x(), y())
// - equals()
// - hashCode()
// - toString()
// - ALL fields are final (immutable)

public record Point(double x, double y) { }

// Usage:
Point p = new Point(1.0, 2.0);
p.x();      // 1.0 (note: method, not field)
p.x = 5.0;  // COMPILE ERROR: records are immutable

// You can add validation:
public record Point(double x, double y) {
    public Point {  // "Compact constructor"
        if (Double.isNaN(x) || Double.isNaN(y)) {
            throw new IllegalArgumentException("Coordinates cannot be NaN");
        }
    }
}