Procedural programming employs linear thinking—executing steps sequentially—which suits simple, straightforward tasks. Object-oriented programming adopts a categorical mindset, first classifying components needed to solve a problem, then examining each category independently before drilling down to procedural details within specific classes. While OOP provides the architectural framework for complex systems, procedural logic handles microscopic operations within methods.

The essence of OOP involves organizing source code through class structures while encapsulating data within object instances. A class serves as an abstract template extracting common characteristics from similar entities, whereas objects represent concrete manifestations of these abstractions. Code execution requires classes to exist before objects can be instantiated.

Three core characteristics define OOP: encapsulation, inheritance, and polymorphism. Polymorphism enables different objects derived from the same class to produce distinct results when invoking identical methods.

Classes function as abstract data types describing overall characteristics of entity categories without representing specific instances. For example, a Vehicle class defines properties like speed and capacity alongside behaviors like accelerate() or brake(), but does not constitute an actual automobile. Objects materialize these abstractions—myCar becomes a specific Vehicle instance with actual values.

Object creation utilizes the new operator, which allocates heap memory, applies default initialization (numeric fields to 0/0.0, booleans to false, references to null), and invokes constructors. Constructors must share the class name exactly and declare no return type—not even void. Explicit constructor definition overrides the compiler-generated default no-argument constructor, necessitating manual declaration if zero-parameter instantiation remains required.

public class CustomerProfile {
    // Explicit no-arg constructor
    public CustomerProfile() {
    }
    
    // Parameterized constructor
    public CustomerProfile(String accountId) {
        this.accountId = accountId;
    }
}

Memory architecture divides into three primary regions. The stack stores method frames and object references (variables holding memory addresses). The heap contains actual object instances with their instance variables. The method area (within heap space) stores class templates, static variables, and method code.

// Memory allocation example
OrderProcessor op = new OrderProcessor();

The variable op resides in stack memory as a reference, while the OrderProcessor object occupies heap space. Method invocations create stack frames containing local variables and return addresses.

Class attributes (member variables) differ fundamentally from local variables declared within methods. Attributes reside in heap memory attached to objects, receive default initialization, and persist for the object's lifetime. Local variables occupy stack frames, require explicit initialization before use, and exist only during method execution. Reference variables always store memory addresses pointing to heap-allocated structures.

Method declarations follow the structure: modifiers returnType methodName(parameterList) { body }. The return statement exits the method and optionally passes values back to callers, distinct from break which exits loops or switch statements.

Static methods, declared with the static modifier, bind to the class itself rather than instances. They load when the class loads and invoke via ClassName.methodName(). Instance methods require object instantiation (new) before invocation and can access both instance and static members.

public class MathUtilities {
    // Static method
    public static double computeCircleArea(double radius) {
        return Math.PI * radius * radius;
    }
    
    // Instance method
    public void displayResult(double value) {
        System.out.println("Calculated: " + value);
    }
}

Method overloading allows multiple methods sharing identical names within the same class, provided parameter lists differ in count, type, or order. Return types and parameter names do not constitute overloadnig criteria. The compiler resolves invocations by matching argument types to parameter lists, preferring exact matches over type promotions.

Variable arity parameters (varargs), introduced in JDK 5, handle uncertain argument counts using syntax type... parameterName. Internally implemented as arrays, varargs must occupy the final position in parameter lists.

public void logMessages(String severity, String... messages) {
    for (String msg : messages) {
        System.out.println("[" + severity + "] " + msg);
    }
}

Java employs pass-by-value semantics exclusively. For primitive parameters, method calls copy the actual data value into the parameter variable. For reference parameters, the memory address gets copied—both variables point to identical heap objects. Modifications through one reference affect the shared object visible to all references.

Recursive methods invoke themselves, decomposing complex problems into smaller identical subproblems. Effective recursion requires a base case terminating the descent and a recursive case reducing problem size.

public long computeFactorial(int n) {
    if (n <= 1) return 1;  // Base case
    return n * computeFactorial(n - 1);  // Recursive case
}

Access control through encapsulation restricts direct field manipulation. The four visibility levels—private, package-private (default), protected, and public—govern member accessibility. Private fields exposed through public getter and setter methods enable validation logic and implementation hiding.

public class BankAccount {
    private double balance;
    private String accountNumber;
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            this.balance += amount;
        }
    }
}

Package declarations organize classes into namespaces, preventing naming collisions and managing complexity. Package names follow reverse domain conventions (com.example.project) and correspond to directory structures. The import statement references classes outside the current package (except java.lang classes). Only one package declaration may appear per source file, positioned before imports.

Constructor overloading provides multiple initialization pathways. Explicit constructor declaration eliminates the default no-argument constructor, requiring explicit definition if needed. Constructors initialize object state during instantiation but do not constitute methods—they lack return types and participate in inheritance differently.

JavaBeans conventions standardize reusable component architecture: public classes with public no-argument constructors, private fields accessed through public getter and setter methods following naming conventions.