Object-Oriented Programming (OOP) & Modern Class Design

package com.accenture.ltt.oop;

public class Account {
    private final String accountId;
    private double balance;
    private static double defaultInterestRate;

    // 1. Static Initialization Block: Runs ONCE when class is first loaded by ClassLoader
    static {
        defaultInterestRate = 0.045; // 4.5% interest
        System.out.println("Step 1: Static block executed (Only once per class!)");
    }

    // 2. Instance Initialization Block: Runs before EVERY constructor
    {
        System.out.println("Step 2: Instance initialization block executed");
    }

    // 3. Overloaded Constructor 1: Takes only accountId, defaults balance to 0.0
    public Account(String accountId) {
        this(accountId, 0.0); // Chaining to Constructor 2! MUST BE LINE 1
        System.out.println("Step 4: Finished single-arg constructor for: " + accountId);
    }

    // 4. Overloaded Constructor 2: Master constructor initializing all fields
    public Account(String accountId, double initialBalance) {
        this.accountId = accountId; // 'this.accountId' resolves ambiguity with parameter 'accountId'
        this.balance = initialBalance;
        System.out.println("Step 3: Master constructor executed. ID: " + accountId + ", Balance: $" + balance);
    }
}

package com.accenture.ltt;

// Customer owns Account's entire lifecycle (Composition)
class Customer {
    private String customerName;
    private Account account;

    public Customer() {
        // Composition: Account object is instantiated INSIDE Customer constructor!
        this.account = new Account();
        this.account.setAccountNo(9001);
        this.account.setAmount(5000.0);
    }

    public String getCustomerName() { return customerName; }
    public void setCustomerName(String name) { this.customerName = name; }
    public Account getAccount() { return account; }
}

public class CompositionTester {
    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.setCustomerName("John");

        System.out.println("Customer Name: " + customer.getCustomerName());
        System.out.println("Account Number: " + customer.getAccount().getAccountNo());
        System.out.println("Balance Amount: $" + customer.getAccount().getAmount());
    }
}

package com.accenture.ltt;

class Faculty {
    private int facultyId;
    private String facultyName;

    public int getFacultyId() { return facultyId; }
    public void setFacultyId(int id) { this.facultyId = id; }
    public String getFacultyName() { return facultyName; }
    public void setFacultyName(String name) { this.facultyName = name; }
}

class Department {
    private String departmentName;
    private Faculty faculty; // Weak reference: injected from outside!

    public void setDepartmentName(String name) { this.departmentName = name; }
    public String getDepartmentName() { return departmentName; }
    public void setFaculty(Faculty f) { this.faculty = f; }
    public Faculty getFaculty() { return faculty; }
}

public class AggregationTester {
    public static void main(String[] args) {
        Department department = new Department();
        department.setDepartmentName("Computer Science");

        // Faculty exists independently on the Heap BEFORE Department assigns it:
        Faculty faculty = new Faculty();
        faculty.setFacultyId(1001);
        faculty.setFacultyName("Dr. Smith");

        department.setFaculty(faculty); // Loose aggregation association
        System.out.println("Dept: " + department.getDepartmentName() + " | Faculty: " + department.getFaculty().getFacultyName());
    }
}

public class PolymorphicDispatchDemo {

    abstract static class PaymentService {
        abstract void process(double amount);
    }

    static class CreditCardPayment extends PaymentService {
        @Override
        void process(double amount) {
            System.out.println("Charging $" + amount + " to Visa Card via Payment Gateway");
        }
    }

    static class UpiPayment extends PaymentService {
        @Override
        void process(double amount) {
            System.out.println("Transferring $" + amount + " instantly via UPI Virtual ID");
        }
    }

    public static void main(String[] args) {
        // Reference type is parent PaymentService, but heap object is CreditCardPayment
        PaymentService service = new CreditCardPayment();
        
        // Under the hood: JVM uses 'invokevirtual' opcode and consults the vtable of CreditCardPayment!
        service.process(150.0);

        // Swapping the heap instance to UpiPayment
        service = new UpiPayment();
        service.process(75.0);
    }
}

package com.accenture.ltt;

class Employee {
    private String employeeName;
    private int employeeId;

    public Employee(String name, int id) {
        this.employeeName = name;
        this.employeeId = id;
    }

    public void displayDetails() {
        System.out.println("Employee: " + employeeName + " | ID: " + employeeId);
    }
}

class Manager extends Employee {
    private int numberOfReportees;

    public Manager(String name, int id, int reportees) {
        super(name, id);
        this.numberOfReportees = reportees;
    }

    @Override
    public void displayDetails() {
        System.out.println("Manager with " + numberOfReportees + " reportees!");
    }

    public int getNumberOfReportees() { return numberOfReportees; }
}

public class DynamicBindingTester {
    public static void main(String[] args) {
        // Reference is parent Employee, object on heap is Manager
        Employee emp = new Manager("Cooper", 3001, 4);

        // Dynamic Binding: At runtime, JVM calls Manager's displayDetails()!
        emp.displayDetails();

        // COMPILE ERROR if uncommented: Reference type 'Employee' does not declare getNumberOfReportees()!
        // System.out.println(emp.getNumberOfReportees());
    }
}

package com.accenture.ltt.oop;

@FunctionalInterface
public interface ModernOrderService {

    // 1. Single Abstract Method (SAM): Makes it eligible for Lambdas!
    boolean processOrder(String orderId, double amount);

    // 2. Java 8 Default Method: Backward-compatible business logic
    default void logAuditTrail(String orderId, String status) {
        formatAndPrintAudit("AUDIT", orderId, status);
    }

    // 3. Java 8 Static Method: Utility helper bound to the interface
    static boolean isValidOrderId(String orderId) {
        return orderId != null && orderId.startsWith("ORD-");
    }

    // 4. Java 9 Private Method: Encapsulates shared logic between default methods
    private void formatAndPrintAudit(String prefix, String orderId, String status) {
        System.out.println("[" + prefix + "] Order " + orderId + " status updated to: " + status);
    }
}

package com.accenture.ltt.sampleclasses;

/**
 * Java 17 Sealed Class: Restricts hierarchy to strictly permitted subclasses.
 * Enables exhaustive pattern matching switch in modern backend systems.
 */
public sealed abstract class Product 
    permits ElectronicsProducts, KidsProducts, BeautyProducts {

    abstract public String getProductDescription();
}

// Subclasses MUST explicitly declare their inheritance posture:
// - 'final': Cannot be extended any further
// - 'sealed': Extends the sealed hierarchy to another set of permitted subclasses
// - 'non-sealed': Opens the class up for general inheritance
public final class ElectronicsProducts extends Product {
    @Override
    public String getProductDescription() {
        return "Certified Enterprise Electronic Device";
    }
}

public class UserRecordDemo {

    // Modern Java 16 Record: A 1-line immutable data carrier!
    // Automatically generates: private final fields, constructor, getters (id(), email()), equals(), hashCode(), toString()
    public record UserDTO(Long id, String username, String email) {
        
        // Compact Constructor: Used for validation without repeating 'this.x = x' boilerplate
        public UserDTO {
            if (email == null || !email.contains("@")) {
                throw new IllegalArgumentException("Invalid email format: " + email);
            }
        }
    }

    public static void main(String[] args) {
        UserDTO user = new UserDTO(101L, "john_doe", "john@accenture.com");

        // Accessor methods use field name (id(), not getId())
        System.out.println("User Email: " + user.email());
        System.out.println("Auto toString(): " + user);
    }
}

public class OrderStatusEnumDemo {

    public enum OrderStatus {
        PENDING(100, "Awaiting Payment"),
        PROCESSING(200, "Packing in Warehouse"),
        SHIPPED(300, "In Transit"),
        DELIVERED(400, "Delivered to Customer");

        private final int statusCode;
        private final String description;

        // Enum constructor is always private
        OrderStatus(int statusCode, String description) {
            this.statusCode = statusCode;
            this.description = description;
        }

        public int getStatusCode() { return statusCode; }
        public String getDescription() { return description; }

        public boolean isTerminal() {
            return this == DELIVERED;
        }
    }

    public static void main(String[] args) {
        OrderStatus status = OrderStatus.PROCESSING;
        System.out.println("Status Code: " + status.getStatusCode() + " -> " + status.getDescription());
        System.out.println("Is complete? " + status.isTerminal());
    }
}

public class CloningDeepCopyDemo {

    static class Address {
        String city;
        Address(String city) { this.city = city; }
    }

    static class Customer implements Cloneable {
        String name;
        Address address;

        Customer(String name, Address address) {
            this.name = name;
            this.address = address;
        }

        // Shallow Copy: Default Object.clone() only copies primitive values & address references!
        public Customer shallowCopy() throws CloneNotSupportedException {
            return (Customer) super.clone();
        }

        // Deep Copy: Explicitly duplicates nested objects so modifications don't corrupt original!
        public Customer deepCopy() {
            return new Customer(this.name, new Address(this.address.city));
        }
    }

    public static void main(String[] args) throws Exception {
        Customer original = new Customer("Alice", new Address("New York"));

        // 1. Shallow Copy Test
        Customer shallow = original.shallowCopy();
        shallow.address.city = "London";
        System.out.println("Shallow copy changed original city to: " + original.address.city); // London! Shared object corrupted!

        // 2. Deep Copy Test
        Customer deep = original.deepCopy();
        deep.address.city = "Tokyo";
        System.out.println("Deep copy changed its city to Tokyo, original stays: " + original.address.city); // London! Safe!
    }
}