3.4 Abstract Classes, Static Members, and Object Methods (`equals`, `hashCode`, `toString`)

Abstract Classes, Static Members, and Object Methods

Abstract classes and common Object methods define the contract and behavior of Java types. Mastering abstract class constraints, static member scoping, and the contracts of equals, hashCode, and toString is essential for developing correct enterprise applications and excelling on the 1Z0-829 examination.

---

1. Abstract Classes and Method Mechanics

An abstract class is declared with the abstract keyword. It represents an incomplete conceptual model that cannot be instantiated directly using new.

Key Abstract Class Rules

1. Direct Instantiation Forbidden: Attempting new AbstractClass() causes a compile-time error: AbstractClass is abstract; cannot be instantiated.
2. Abstract Method Presence: If a class defines even one abstract method (or inherits an abstract method without implementing it), the class must be declared abstract.
3. Zero Abstract Methods Allowed: An abstract class is not required to contain abstract methods. Declaring a class abstract without any abstract methods is valid and frequently used to prevent instantiation.
4. Constructors and State: Abstract classes can declare constructors, instance fields, static fields, concrete instance methods, and static methods. Constructors are executed via super(...) when concrete subclasses are instantiated.
5. Concrete Implementation Requirement: The first concrete (non-abstract) subclass in the inheritance chain must implement all inherited abstract methods.

Abstract Method Constraints

An abstract method declares a signature followed by a semicolon, without a method body (abstract void process();).

abstract class PaymentGateway {
    protected String merchantId;

    public PaymentGateway(String merchantId) { // Legal constructor
        this.merchantId = merchantId;
    }

    public abstract boolean processPayment(double amount); // Abstract method

    public void logTransaction(String txId) { // Concrete method
        System.out.println("Merchant " + merchantId + " tx: " + txId);
    }
}

---

2. Static Variables and Methods

Static members belong to the class itself rather than any specific instance. They are loaded into memory when the class is initialized and shared across all instances.

Static Member Access Rules

• Static members can be accessed directly using the class name: Math.max(10, 20).
• Static methods and initializers run in a class-level context without a this reference. They cannot access instance fields, invoke instance methods, or use super without creating or receiving an explicit instance.

The Null Reference Static Trap

Java permits accessing static members through an object reference variable (instance.staticMethod()). The compiler resolves this access using the declared type of the reference, completely ignoring the runtime object on the heap.

public class Device {
    public static int deviceCount = 100;
    public static void reset() {
        System.out.print("Reset ");
    }

    public static void main(String[] args) {
        Device dev = null;
        dev.reset();                     // Outputs: Reset (No NullPointerException!)
        System.out.println(dev.deviceCount); // Outputs: 100 (No NullPointerException!)
    }
}

Even though dev is null, no NullPointerException is thrown. The compiler translates dev.reset() directly into Device.reset() and dev.deviceCount into Device.deviceCount.

---

3. The java.lang.Object Method Contracts

java.lang.Object is the root of the Java class hierarchy. Three of its methods are central to collection behavior and object equality: equals, hashCode, and toString.

The equals(Object obj) Contract

The default implementation in Object evaluates reference equality (this == obj). To compare objects based on their internal state, classes must override equals(Object).

The general contract of equals specifies five mandatory properties for any non-null references x, y, and z:

1. Reflexive: x.equals(x) must return true.
2. Symmetric: x.equals(y) must return true if and only if y.equals(x) returns true.
3. Transitive: If x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) must return true.
4. Consistent: Multiple invocations of x.equals(y) consistently return true or consistently return false, provided no fields used in the comparison are modified.
5. Non-nullity: For any non-null reference x, x.equals(null) must return false without throwing an exception.

The hashCode() Contract

The hashCode() method returns an integer hash code used by hash-based collections (HashMap, HashSet, Hashtable).

The contract specifies:

1. Consistency: Multiple invocations on the same object during an application run must return the same integer, provided equality-determining fields remain unmodified.
2. Equal Objects Must Have Equal Hash Codes: If x.equals(y) returns true, then x.hashCode() == y.hashCode() must be true.
3. Unequal Objects May Share Hash Codes: If x.equals(y) returns false, x.hashCode() and y.hashCode() are not required to be distinct (a hash collision). However, distinct hash codes improve hash table performance.

The toString() Method

The default implementation in Object returns:

getClass().getName() + "@" + Integer.toHexString(hashCode())

Overriding toString() provides human-readable diagnostic text representing the object's state. It is invoked automatically during string concatenation ("User: " + user) and printing (System.out.println(user)).

Proper Implementation Pattern

import java.util.Objects;

public class Employee {
    private int id;
    private String department;

    public Employee(int id, String department) {
        this.id = id;
        this.department = department;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true; // Reflexive check
        if (obj == null || getClass() != obj.getClass()) return false; // Null and exact type check
        Employee other = (Employee) obj;
        return this.id == other.id && Objects.equals(this.department, other.department);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, department); // Consistent with equals
    }

    @Override
    public String toString() {
        return "Employee[id=" + id + ", department=" + department + "]";
    }
}