Classes & Objects

🔍 What Is It?

Class

A class is a template that defines:

• →Fields (instance variables) — the data/state each object holds
• →Methods — the behavior/actions objects can perform
• →Constructors — special methods to initialize objects
• →Static members — shared across all instances (class-level, not instance-level)

Object

An object is a runtime instance of a class:

• →Has its own copy of instance fields
• →Shares methods with all other instances (methods are in the class, not each object)
• →Lives on the heap, referenced by a variable on the stack

Records (Java 16+)

Immutable data classes with auto-generated constructor, getters, equals, hashCode, toString:

record Point(int x, int y) {}

Key Concepts:

• →this — refers to the current object instance
• →static — belongs to the class, not instances
• →final — on a class: cannot be subclassed; on a field: cannot be reassigned; on a method: cannot be overridden
• →Access modifiers: private, package-private (default), protected, public

🎯 Why Do We Need It?

Classes and objects are the core of OOP. They solve:

• →Modeling real-world entities — Employee, Order, Product are natural classes
• →Encapsulation — bundle data and behavior together; hide implementation details
• →Reusability — define once, instantiate many times
• →Code organization — group related functionality into cohesive units

Without classes, you'd have scattered variables and functions with no clear ownership — like C procedural code. In enterprise Java, every entity (User, Order, Product), every service (OrderService, PaymentService), and every configuration (AppConfig) is a class.

🏗️ What Happens in Real Projects?

In a real Spring Boot enterprise project:

// Entity class (JPA)
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    private String customerId;
    private BigDecimal totalAmount;
    private OrderStatus status;
    // getters, setters, business methods
}

// Service class
@Service
public class OrderService {
    private final OrderRepository repo;
    public Order createOrder(CreateOrderRequest req) { ... }
}

// Value object (Record, Java 16+)
record CreateOrderRequest(String customerId, List<OrderItem> items) {}

⚙️ How It Works

Object Creation:

1. JVM allocates memory on the heap for the object
2. All instance fields are initialized to defaults (0, null, false)
3. Constructor runs, setting fields to specified values
4. Reference to the object is returned to the caller

Constructor Chaining:

• →this() calls another constructor in the same class
• →super() calls the parent class constructor (implicit first line if not specified)

Static vs Instance:

• →Static fields: one copy shared by all instances — stored in Metaspace
• →Instance fields: each object has its own copy — stored on Heap
• →Static methods: called on the class, cannot access instance fields
• →Instance methods: called on an object, can access both static and instance fields

Garbage Collection:

Objects become eligible for GC when no references point to them.

💻 Example

Building a Real Enterprise Class — A complete Employee class showing all key concepts in one place.

public class Employee {
    // Static field — shared by all instances
    private static int totalEmployees = 0;
    
    // Instance fields — each object has its own copy
    private final Long id;          // final: set once in constructor
    private String name;
    private String department;
    private BigDecimal salary;
    
    // Primary constructor
    public Employee(Long id, String name, String department, BigDecimal salary) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.salary = salary;
        totalEmployees++;           // update shared counter
    }
    
    // Convenience constructor — chains to primary
    public Employee(Long id, String name) {
        this(id, name, "Unassigned", BigDecimal.ZERO);
    }
    
    // Business method
    public void giveRaise(BigDecimal percentage) {
        if (percentage.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Raise must be positive");
        }
        BigDecimal multiplier = BigDecimal.ONE.add(
            percentage.divide(new BigDecimal("100"))
        );
        this.salary = this.salary.multiply(multiplier)
                          .setScale(2, RoundingMode.HALF_UP);
    }
    
    // Static factory method (preferred over constructor in many cases)
    public static Employee newHire(String name, String department) {
        return new Employee(
            System.currentTimeMillis(),  // generate ID
            name, department,
            new BigDecimal("50000.00")   // default starting salary
        );
    }
    
    // Static utility
    public static int getTotalEmployees() { return totalEmployees; }
    
    // Getters (no public setters for id — immutable)
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getDepartment() { return department; }
    public BigDecimal getSalary() { return salary; }
    public void setName(String name) { this.name = name; }
    
    @Override
    public String toString() {
        return "Employee{id=%d, name='%s', dept='%s', salary=%s}"
            .formatted(id, name, department, salary);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee other)) return false;
        return Objects.equals(id, other.id);  // equality by ID
    }
    
    @Override
    public int hashCode() { return Objects.hash(id); }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits