Java provides several foundational mechanisms for abstraction, encapsulation, and functional programming. Understanding how abstract classes, nested classes, wrapper types, interfaces, and lambda expressions interrelate is essential for writing robust, maintainable, and expressive object-oriented code.

Abstract Classes: Blueprint with Shared Logic

An abstract class serves as a skeletal template — it cannot be instantiated directly but defines common structure, state, and behavior for subclasses. It may contain both abstract methods (declared without implementation) and concrete methods (with full logic). This hybrid nature makes abstract classes ideal for modeling hierarchies where shared functionality coexists with subclass-specific variations.

The syntax follows standard class declaration rules, prefixed with the abstract keyword:

abstract class Vehicle {
    protected String model;
    protected int year;

    public Vehicle(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // Abstract method — must be implemented by subclasses
    public abstract double calculateFuelEfficiency();

    // Concrete method — inherited as-is or optionally overridden
    public void start() {
        System.out.println(model + " engine started.");
    }
}

Subclasses like Car and Truck extend Vehicle, implementing calculateFuelEfficiency() while reusing start(). Polymorphic references allow uniform treatment:

Vehicle v1 = new Car("Civic", 2023);
Vehicle v2 = new Truck("F-150", 2022);
v1.start(); // "Civic engine started."
v2.start(); // "F-150 engine started."

Crucially, abstract classes support constructors — invoked during subclass instantiation to initialize inherited fields. They also permit access modifiers (private, protected, public) on members, unlike interfaces.

Nested Classes: Encapsulation at the Class Level

Java allows defining classes inside other classes, enabling tighter coupling and improved scoping control. Four categories exist:

1. Member Inner Classes

Declared as non-static members of an enclosing class, they hold an implicit reference to an instance of the outer class and can access all its members — including private ones.

public class BankAccount {
    private double balance = 1000.0;

    class TransactionLogger {
        void logDeposit(double amount) {
            balance += amount; // Direct access to outer's private field
            System.out.printf("Deposited %.2f, new balance: %.2f%n", amount, balance);
        }
    }
}

// Usage:
BankAccount account = new BankAccount();
BankAccount.TransactionLogger logger = account.new TransactionLogger();
logger.logDeposit(200.0); // "Deposited 200.00, new balance: 1200.00"

2. Static Nested Classes

Declared with static, they behave like top-level classes but reside within another class’s namespace. They cannot access non-static outer members unless via an explicit outer instance.

public class NetworkConfig {
    private static final String DEFAULT_PROTOCOL = "TCP";

    public static class ConnectionBuilder {
        private String host;
        private int port;

        public ConnectionBuilder setHost(String host) {
            this.host = host;
            return this;
        }

        public Connection build() {
            return new Connection(host, port, DEFAULT_PROTOCOL);
        }
    }
}

3. Local Classes

Defined inside a method or block, their scope is limited to that context. They capture effectively final local variables and can access outer class members freely.

4. Anonymous Classes

Inline, nameless classes used for one-off implementations — especially common with functional interfaces before lambdas. They combine declaration and instantiation in a single expression:

Comparator<String> lengthComparator = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
};

Wrapper Types: Bridging Primitives and Objects

Wrapper classes (Integer, Boolean, Double, etc.) enable primitive values to participate in object-oriented contexts — such as collections, generics, and reflection. Java’s autoboxing/unboxing automates conversions between primitives and wrappers:

List<Integer> numbers = new ArrayList<>();
numbers.add(42);          // Autoboxing: int → Integer
int value = numbers.get(0); // Auto-unboxing: Integer → int

The Integer class caches instances for values from −128 to 127. Thus, Integer.valueOf(100) == Integer.valueOf(100) evaluates to true, whereas Integer.valueOf(200) == Integer.valueOf(200) is false. This optimization reduces memory overhead for commonly used small integers.

Utility methods like parseInt(), toHexString(), and compare() further enrich numeric manipulation beyond raw arithmetic.

Interfaces: Contracts and Behavioral Abstraction

An interface declares a contract — a set of method signatures that implementing classes must fulfill. Historically limited to abstract methods and constants, modern interfaces support richer constructs:

• Default methods (default): Provide optional, reusable implementations. Resolved at runtime using dynamic dispatch.
• Static methods: Utility functions scoped to the interface (e.g., Collection.emptyList()).
• Private methods (JDK 9+): Refactor repeated logic across default/static methods without exposing it externally.

A class may implement multiple inetrfaces, enabling flexible composition. For example:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }
interface Serializable { byte[] serialize(); }

class Image implements Drawable, Resizable, Serializable {
    @Override public void draw() { /* ... */ }
    @Override public void resize(double f) { /* ... */ }
    @Override public byte[] serialize() { /* ... */ }
}

Unlike abstract classes, interfaces cannot declare instance fields or constructors. Their primary role is to define what a type can do — not how it does it.

Lambda Expressions: Concise Functional Programming

Lambdas provide compact syntax for implementing functional interfaces — interfaces with exactly one abstract method (SAM). They eliminate boilerplate associated with anonymous inner classes:

// Before: Anonymous inner class
Runnable oldStyle = new Runnable() {
    public void run() {
        System.out.println("Running...");
    }
};

// After: Lambda
Runnable newStyle = () -> System.out.println("Running...");

Syntax follows the pattern (parameters) -> expression_or_block. Parameter types are inferred; parentheses may be omitted for single parameters; braces and return are optional for single-expression bodies.

Lambdas are especially powerful with the java.util.stream API:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .filter(name -> name.length() > 4)
     .map(String::toUpperCase)
     .forEach(System.out::println); // "CHARLIE"

This declarative style emphasizes what to compute rather than how to iterate — aligning with functional programming principles like immutability and higher-order functions.