Object-Oriented Programming in Java

// ❌ Procedural style — data is scattered as loose variables
public class ProceduralStyle {

    // Data floating around — no protection, any method can touch it
    static String studentName = "Rahul";
    static int studentAge = 20;
    static double studentMarks = 88.5;

    static void printStudent() {
        System.out.println("Name: " + studentName);
        System.out.println("Age: " + studentAge);
        System.out.println("Marks: " + studentMarks);
    }

    public static void main(String[] args) {
        printStudent();
        // Problem: What if we need 2 students? We'd need 6 more variables!
        // This does NOT scale at all.
    }
}

// ✅ OOP style — data and behavior bundled inside a class
public class Student {

    // State — instance variables
    String name;
    int age;
    double marks;

    // Behavior — method
    void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age + ", Marks: " + marks);
    }
}

class Main {
    public static void main(String[] args) {

        // Create first student object
        Student s1 = new Student();
        s1.name = "Rahul";
        s1.age = 20;
        s1.marks = 88.5;

        // Create second student object — completely independent!
        Student s2 = new Student();
        s2.name = "Priya";
        s2.age = 22;
        s2.marks = 94.0;

        s1.printInfo();
        s2.printInfo();

        // Scales to 1000 students with just 1 more line each!
    }
}

// Demonstrates all 4 OOP pillars conceptually

// ABSTRACTION — hide implementation via abstract class
abstract class Shape {
    abstract double area();            // contract — every Shape MUST have area()
    void describe() {
        System.out.println("I am a shape with area: " + area());
    }
}

// INHERITANCE — Circle inherits from Shape
class Circle extends Shape {

    // ENCAPSULATION — private field + getter
    private double radius;

    Circle(double radius) { this.radius = radius; }

    public double getRadius() { return radius; }

    // POLYMORPHISM — overrides parent's area()
    @Override
    double area() { return Math.PI * radius * radius; }
}

class Rectangle extends Shape {
    private double width, height;
    Rectangle(double w, double h) { width = w; height = h; }

    @Override
    double area() { return width * height; }
}

public class FourPillarsDemo {
    public static void main(String[] args) {
        // POLYMORPHISM — same type (Shape), different actual objects
        Shape[] shapes = { new Circle(5), new Rectangle(4, 6) };

        for (Shape s : shapes) {
            s.describe();  // area() called depends on actual type at runtime
        }
    }
}

// ABSTRACTION — program to interface, not implementation
public interface UserService {
    User findById(Long id);
    List<User> findAll();
}

// ENCAPSULATION — implementation hidden inside service class
@Service  // Spring annotation — marks this as a managed Bean
public class UserServiceImpl implements UserService {

    // ENCAPSULATION — private dependency, injected by Spring
    private final UserRepository userRepository;

    // Constructor injection — recommended OOP approach
    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public User findById(Long id) {
        return userRepository.findById(id).orElseThrow();
    }

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

// POLYMORPHISM — Controller uses UserService interface
// Spring decides at runtime which implementation to inject
@RestController
public class UserController {

    private final UserService userService;  // Interface reference!

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

public class Student {

    // Instance variables — STATE
    String name;
    int age;
    double marks;

    // Method — BEHAVIOR
    void printInfo() {
        System.out.println("--- Student Info ---");
        System.out.println("Name  : " + name);
        System.out.println("Age   : " + age);
        System.out.println("Marks : " + marks);
    }

    public static void main(String[] args) {

        // Create object — memory allocated in Heap
        Student s1 = new Student();

        // Assign values via dot operator
        s1.name  = "Rahul";
        s1.age   = 20;
        s1.marks = 88.5;

        // Create second independent object
        Student s2 = new Student();
        s2.name  = "Priya";
        s2.age   = 22;
        s2.marks = 94.0;

        s1.printInfo();
        s2.printInfo();
    }
}

public class DefaultValues {

    int     count;       // default: 0
    double  price;       // default: 0.0
    boolean active;      // default: false
    String  label;       // default: null
    char    grade;       // default: '\u0000'

    void showDefaults() {
        System.out.println("int     : " + count);
        System.out.println("double  : " + price);
        System.out.println("boolean : " + active);
        System.out.println("String  : " + label);
        System.out.println("char    : '" + grade + "' (unicode: " + (int) grade + ")");
    }

    public static void main(String[] args) {
        new DefaultValues().showDefaults();
    }
}

public class ReferenceTrap {

    String name;
    int age;

    public static void main(String[] args) {

        ReferenceTrap obj1 = new ReferenceTrap();
        obj1.name = "Arjun";
        obj1.age  = 25;

        // ⚠️ This does NOT create a new object!
        // obj2 is just another reference to the SAME Heap object
        ReferenceTrap obj2 = obj1;

        obj2.name = "Changed!";  // modifies the shared object

        // Both reflect the change — same object!
        System.out.println("obj1.name = " + obj1.name);
        System.out.println("obj2.name = " + obj2.name);
        System.out.println("Same object? " + (obj1 == obj2));
    }
}

public class Car {

    String brand;
    int    year;
    double price;

    void display() {
        System.out.printf("%-10s | %d | ₹%.2f%n", brand, year, price);
    }

    public static void main(String[] args) {

        // Array of Car objects — initially all null
        Car[] fleet = new Car[3];

        fleet[0] = new Car();
        fleet[0].brand = "Toyota";  fleet[0].year = 2022;  fleet[0].price = 1500000;
        fleet[1] = new Car();
        fleet[1].brand = "Honda";   fleet[1].year = 2023;  fleet[1].price = 1200000;
        fleet[2] = new Car();
        fleet[2].brand = "Maruti";  fleet[2].year = 2021;  fleet[2].price = 700000;

        System.out.println("Brand      | Year | Price");
        System.out.println("-----------|------|------------");
        for (Car c : fleet) c.display();
    }
}

import jakarta.persistence.*;

// @Entity maps this Java class to a database table
@Entity
@Table(name = "products")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Double price;
    private Integer stock;

    // Getters and setters (Spring/JPA requires these)
    public Long    getId()    { return id; }
    public String  getName()  { return name; }
    public Double  getPrice() { return price; }
    public Integer getStock() { return stock; }

    public void setName(String name)    { this.name = name; }
    public void setPrice(Double price)  { this.price = price; }
    public void setStock(Integer stock) { this.stock = stock; }
}

public class Calculator {

    // void method — performs action, returns nothing
    void printSum(int a, int b) {
        System.out.println("Sum (void): " + (a + b));
    }

    // int return type — returns computed value to caller
    int getSum(int a, int b) {
        return a + b;
    }

    // double return type
    double getAverage(int a, int b, int c) {
        return (a + b + c) / 3.0;
    }

    // boolean return type — useful for validation
    boolean isEven(int n) {
        return n % 2 == 0;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();

        calc.printSum(5, 3);

        int result = calc.getSum(5, 3);
        System.out.println("Sum (return): " + result);

        System.out.println("Average: " + calc.getAverage(10, 20, 30));
        System.out.println("Is 8 even? " + calc.isEven(8));
        System.out.println("Is 7 even? " + calc.isEven(7));
    }
}

public class OverloadDemo {

    // Overload 1 — different NUMBER of parameters
    int add(int a, int b) {
        System.out.print("add(int,int) → ");
        return a + b;
    }

    int add(int a, int b, int c) {
        System.out.print("add(int,int,int) → ");
        return a + b + c;
    }

    // Overload 2 — different TYPES of parameters
    double add(double a, double b) {
        System.out.print("add(double,double) → ");
        return a + b;
    }

    // Overload 3 — different ORDER of parameter types
    String display(int id, String name) {
        System.out.print("display(int,String) → ");
        return id + ": " + name;
    }

    String display(String name, int id) {
        System.out.print("display(String,int) → ");
        return name + " (ID: " + id + ")";
    }

    public static void main(String[] args) {
        OverloadDemo obj = new OverloadDemo();

        System.out.println(obj.add(2, 3));
        System.out.println(obj.add(2, 3, 4));
        System.out.println(obj.add(2.5, 3.5));
        System.out.println(obj.display(101, "Rahul"));
        System.out.println(obj.display("Priya", 102));
    }
}

class Box {
    int value;
    Box(int v) { value = v; }
}

public class PassByValue {

    // Primitive — original NOT modified
    static void tryDoubleInt(int x) {
        x = x * 2;  // only modifies local copy
    }

    // Object — field CAN be modified via reference copy
    static void tryDoubleBox(Box b) {
        b.value = b.value * 2;  // modifies actual Heap object
    }

    // Object reassignment — does NOT affect original reference
    static void tryReplaceBox(Box b) {
        b = new Box(999);  // only changes local copy of reference
    }

    public static void main(String[] args) {
        int num = 10;
        tryDoubleInt(num);
        System.out.println("After tryDoubleInt: " + num);  // still 10

        Box box = new Box(10);
        tryDoubleBox(box);
        System.out.println("After tryDoubleBox: " + box.value);  // 20 — changed!

        Box box2 = new Box(10);
        tryReplaceBox(box2);
        System.out.println("After tryReplaceBox: " + box2.value);  // still 10
    }
}

public class PersonBuilder {

    String name;
    int age;
    String city;

    // Each setter returns 'this' → enables chaining
    PersonBuilder setName(String name) {
        this.name = name;
        return this;
    }

    PersonBuilder setAge(int age) {
        this.age = age;
        return this;
    }

    PersonBuilder setCity(String city) {
        this.city = city;
        return this;
    }

    void print() {
        System.out.println(name + " | Age: " + age + " | City: " + city);
    }

    public static void main(String[] args) {
        // Fluent method chaining
        new PersonBuilder()
            .setName("Rahul")
            .setAge(25)
            .setCity("Mumbai")
            .print();
    }
}

@Service
public class OrderService {

    private final OrderRepository repo;

    public OrderService(OrderRepository repo) {
        this.repo = repo;
    }

    // Overloaded methods — same intent, different filters
    public List<Order> findOrders() {
        return repo.findAll();
    }

    public List<Order> findOrders(String status) {
        return repo.findByStatus(status);
    }

    public List<Order> findOrders(String status, Long userId) {
        return repo.findByStatusAndUserId(status, userId);
    }

    // void method — side effect only (send email, log, etc.)
    public void cancelOrder(Long orderId) {
        Order order = repo.findById(orderId).orElseThrow();
        order.setStatus("CANCELLED");
        repo.save(order);
    }
}

class Student {
    String name;   // instance var → HEAP (inside object)
    int    age;    // instance var → HEAP (inside object)
    Student(String name, int age) { this.name=name; this.age=age; }
}

public class MemoryDemo {

    static void printStudent(Student s) {
        // 's' = local reference on THIS frame → points to same Heap object
        int localVar = 42;  // on THIS stack frame only, gone after return
        System.out.println(s.name + " | Age: " + s.age);
    }

    public static void main(String[] args) {
        Student s1 = new Student("Rahul", 20);  // s1 ref on Stack, object on Heap
        Student s2 = new Student("Priya", 22);  // s2 ref on Stack, new object on Heap
        Student s3 = s1;                     // s3 ref on Stack, SAME Heap object as s1

        printStudent(s1);
        printStudent(s2);

        s3.name = "Changed via s3";
        System.out.println("s1.name = " + s1.name);  // reflects s3's change!

        s1 = null;  // object still alive — s3 still points to it
        System.out.println("s3.name = " + s3.name);
        s3 = null;  // NOW → 0 references → GC eligible
    }
}

public class StackOverflowDemo {

    static void recurse(int n) {
        System.out.println("Call #" + n);
        recurse(n + 1);  // no base case → infinite stack frames
    }

    public static void main(String[] args) {
        try {
            recurse(1);
        } catch (StackOverflowError e) {
            System.out.println("💥 StackOverflowError! Stack memory exhausted.");
        }
    }
}

public class StringPoolDemo {
    public static void main(String[] args) {

        String a = "hello";             // goes to String Pool
        String b = "hello";             // reuses same pooled object
        String c = new String("hello"); // new Heap object, bypasses pool
        String d = new String("hello"); // another new Heap object

        // == compares REFERENCES (addresses)
        System.out.println("a == b        : " + (a == b));        // true  — same pool obj
        System.out.println("a == c        : " + (a == c));        // false — different objects
        System.out.println("c == d        : " + (c == d));        // false — two new objects

        // .equals() compares CONTENT — use this always for Strings!
        System.out.println("a.equals(c)   : " + a.equals(c));   // true  — same content

        // intern() forces into the pool
        String e = c.intern();
        System.out.println("a == e interned: " + (a == e));  // true
    }
}

// SINGLETON — one Heap object for entire app lifetime (default)
@Service
public class UserService { }

// PROTOTYPE — new Heap object every time it's requested
@Component
@Scope("prototype")
public class ReportGenerator { }

// JVM Heap tuning flags for Spring Boot production:
// java -Xms256m -Xmx1g -jar myapp.jar
//  -Xms = initial heap size (avoid expensive resizing at startup)
//  -Xmx = max heap size (cap it based on your server's RAM)

import java.util.Arrays;

public class PrimitiveArray {
    public static void main(String[] args) {

        // Create and initialise
        int[] marks = {85, 92, 78, 96, 88};

        // length property — NOT a method, no parentheses
        System.out.println("Length: " + marks.length);

        // Standard for loop — with index
        System.out.print("Marks: ");
        for (int i = 0; i < marks.length; i++)
            System.out.print(marks[i] + " ");
        System.out.println();

        // Enhanced for-each — cleaner when index not needed
        int sum = 0;
        for (int m : marks) sum += m;
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + (double) sum / marks.length);

        // Sort and print
        Arrays.sort(marks);
        System.out.println("Sorted: " + Arrays.toString(marks));
    }
}

class Student {
    String name;
    int    marks;
    Student(String name, int marks) {
        this.name  = name;
        this.marks = marks;
    }
}

public class ObjectArray {
    public static void main(String[] args) {

        // Step 1: create array of 3 null references
        Student[] batch = new Student[3];

        // Step 2: create each object and assign to its slot
        batch[0] = new Student("Rahul", 88);
        batch[1] = new Student("Priya", 94);
        batch[2] = new Student("Arjun", 79);

        // Iterate and print
        System.out.println("Student Results:");
        for (Student s : batch)
            System.out.printf("  %-10s → %d%n", s.name, s.marks);

        // Find topper
        Student topper = batch[0];
        for (Student s : batch)
            if (s.marks > topper.marks) topper = s;
        System.out.println("Topper: " + topper.name + " (" + topper.marks + ")");
    }
}

public class ArrayBoundsDemo {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};  // valid indices: 0, 1, 2

        // Safe access
        System.out.println(nums[2]);  // 30 — OK

        // Dangerous — catching the exception
        try {
            System.out.println(nums[5]);  // index 5 doesn't exist!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("💥 Caught: " + e.getMessage());
        }

        // Common off-by-one mistake — use < not <=
        for (int i = 0; i < nums.length; i++)  // correct: i < length
            System.out.print(nums[i] + " ");
    }
}

public class MatrixDemo {
    public static void main(String[] args) {

        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // Print as grid
        System.out.println("Matrix:");
        for (int[] row : matrix) {
            for (int val : row)
                System.out.printf("%3d", val);
            System.out.println();
        }

        // Sum of diagonal
        int diag = 0;
        for (int i = 0; i < matrix.length; i++)
            diag += matrix[i][i];
        System.out.println("Diagonal sum: " + diag);
    }
}

@RestController
public class ProductController {

    // Inject comma-separated config into a String array
    @Value("${app.allowed-categories}")   // application.properties:
    private String[] allowedCategories;   // app.allowed-categories=books,food,electronics

    // Multiple query params → String array
    @GetMapping("/products")
    public List<Product> getProducts(
            @RequestParam(required = false) String[] tags) {
        // GET /products?tags=java&tags=spring  →  tags = {"java","spring"}
        if (tags == null) return productService.findAll();
        return productService.findByTags(Arrays.asList(tags));
    }
}

public class Employee {

    // static — ONE copy shared by all Employee objects
    static int count = 0;

    // instance — each Employee has their own
    String name;
    int    id;

    Employee(String name) {
        this.name = name;
        count++;            // increments the SHARED counter
        this.id = count;     // auto-assign unique id
    }

    void display() {
        System.out.printf("ID: %d | Name: %s%n", id, name);
    }

    public static void main(String[] args) {
        Employee e1 = new Employee("Rahul");
        Employee e2 = new Employee("Priya");
        Employee e3 = new Employee("Arjun");

        e1.display();
        e2.display();
        e3.display();

        // Access via class name — correct way
        System.out.println("Total employees: " + Employee.count);
    }
}

public class StaticBlockOrder {

    static int x;
    static int y;

    // Static block 1 — runs first
    static {
        x = 10;
        System.out.println("Static block 1: x = " + x);
    }

    // Static block 2 — runs second (multiple blocks allowed)
    static {
        y = x * 2;  // can use x — block 1 already ran
        System.out.println("Static block 2: y = " + y);
    }

    StaticBlockOrder() {
        System.out.println("Constructor called");
    }

    public static void main(String[] args) {
        System.out.println("main() started");
        new StaticBlockOrder();
        new StaticBlockOrder();  // static blocks do NOT run again
    }
}

public class StaticMethodDemo {

    String instanceVar = "I am instance";
    static String staticVar = "I am static";

    // Static method — belongs to class
    static void staticMethod() {
        System.out.println(staticVar);         // ✅ can access static
        // System.out.println(instanceVar);   // ❌ compile error — no 'this'

        // Workaround: pass object reference
        StaticMethodDemo obj = new StaticMethodDemo();
        System.out.println(obj.instanceVar);    // ✅ via explicit object
    }

    // Instance method — has 'this', can access everything
    void instanceMethod() {
        System.out.println(instanceVar);  // ✅ both accessible
        System.out.println(staticVar);   // ✅
    }

    public static void main(String[] args) {
        staticMethod();              // no object needed
        new StaticMethodDemo().instanceMethod();
    }
}

// Without static import: Math.sqrt(16), Math.PI
// With static import: sqrt(16), PI  — no Math. prefix needed
import static java.lang.Math.*;

public class StaticImportDemo {
    public static void main(String[] args) {
        System.out.println(sqrt(144));        // 12.0
        System.out.println(pow(2, 10));      // 1024.0
        System.out.println(PI);              // 3.141592653589793
        System.out.println(abs(-42));       // 42
    }
}

// ── Constants class — all static final ──────────────────────
public class AppConstants {
    public static final String ROLE_ADMIN   = "ROLE_ADMIN";
    public static final String ROLE_USER    = "ROLE_USER";
    public static final int    MAX_PAGE_SIZE = 50;
    private AppConstants() {}  // prevent instantiation
}

// ── Logger — standard Spring Boot pattern ───────────────────
@Service
public class OrderService {

    // static final logger — one per class, shared, immutable
    private static final Logger log =
        LoggerFactory.getLogger(OrderService.class);

    public void placeOrder(Order order) {
        log.info("Placing order for user: {}", order.getUserId());
        // ...
    }
}

// ── @Value into static field (requires setter trick) ────────
@Component
public class Config {
    public static String apiKey;

    @Value("${app.api-key}")
    public void setApiKey(String key) {
        Config.apiKey = key;  // @Value on setter, assigns to static field
    }
}

public class BankAccount {

    // Step 1: private fields — no direct outside access
    private String owner;
    private double balance;
    private int    pin;

    // Constructor
    public BankAccount(String owner, double initialDeposit, int pin) {
        this.owner   = owner;
        this.balance = initialDeposit;
        this.pin     = pin;
    }

    // Step 2: getter — read-only for balance
    public String getOwner()   { return owner; }
    public double getBalance() { return balance; }
    // No getter for pin — completely hidden!

    // Step 3: controlled operations with validation
    public void deposit(double amount) {
        if (amount <= 0)
            throw new IllegalArgumentException("Deposit must be positive");
        balance += amount;
        System.out.printf("Deposited ₹%.2f | New balance: ₹%.2f%n", amount, balance);
    }

    public void withdraw(double amount, int enteredPin) {
        if (enteredPin != pin) {
            System.out.println("❌ Wrong PIN!");
            return;
        }
        if (amount > balance) {
            System.out.println("❌ Insufficient funds!");
            return;
        }
        balance -= amount;
        System.out.printf("Withdrew ₹%.2f | New balance: ₹%.2f%n", amount, balance);
    }

    public static void main(String[] args) {
        BankAccount acc = new BankAccount("Rahul", 5000.0, 1234);

        // acc.balance = 99999; // ❌ compile error — private!
        // acc.pin = 0000;      // ❌ compile error — private!

        acc.deposit(1500.0);
        acc.withdraw(2000.0, 9999);   // wrong PIN
        acc.withdraw(2000.0, 1234);   // correct PIN
        acc.withdraw(9000.0, 1234);   // insufficient funds
        System.out.println("Final balance: ₹" + acc.getBalance());
    }
}

public class Student {

    private String name;
    private int    age;
    private double marks;
    private boolean passed;     // derived — no setter needed

    // Getters
    public String  getName()   { return name; }
    public int     getAge()    { return age; }
    public double  getMarks()  { return marks; }
    public boolean isPassed()  { return passed; }   // "is" for boolean

    // Setters with validation
    public void setName(String name) {
        if (name == null || name.isBlank())
            throw new IllegalArgumentException("Name cannot be blank");
        this.name = name.trim();
    }

    public void setAge(int age) {
        if (age < 1 || age > 120)
            throw new IllegalArgumentException("Age out of range: " + age);
        this.age = age;
    }

    public void setMarks(double marks) {
        if (marks < 0 || marks > 100)
            throw new IllegalArgumentException("Marks must be 0-100");
        this.marks  = marks;
        this.passed = marks >= 35;   // auto-derived field
    }

    public static void main(String[] args) {
        Student s = new Student();
        s.setName("Rahul");
        s.setAge(20);
        s.setMarks(72.5);

        System.out.printf("%s | Age: %d | Marks: %.1f | Passed: %b%n",
            s.getName(), s.getAge(), s.getMarks(), s.isPassed());

        try {
            s.setAge(-5);   // triggers validation
        } catch (IllegalArgumentException e) {
            System.out.println("❌ Error: " + e.getMessage());
        }
    }
}

public class AccessControl {

    private final String id;       // READ-ONLY: getter only, no setter
    private       String password; // WRITE-ONLY: setter only, no getter
    private       String email;    // READ-WRITE: both getter and setter

    public AccessControl(String id, String password, String email) {
        this.id       = id;
        this.password = password;
        this.email    = email;
    }

    // READ-ONLY — getter, no setter
    public String getId() { return id; }

    // WRITE-ONLY — setter, no getter (password stays hidden)
    public void setPassword(String newPwd) {
        if (newPwd.length() < 8)
            throw new IllegalArgumentException("Password too short");
        this.password = newPwd;  // stored as-is (use BCrypt in real apps)
    }

    // READ-WRITE — both
    public String getEmail()           { return email; }
    public void   setEmail(String email) { this.email = email; }

    public static void main(String[] args) {
        AccessControl user = new AccessControl("USR001", "secret99", "r@mail.com");
        System.out.println("ID: "    + user.getId());
        System.out.println("Email: " + user.getEmail());
        // user.getId() works; user.id = "X" → compile error
        // user.password → compile error (write-only)
        user.setPassword("newSecure123");
        System.out.println("Password updated successfully");
    }
}

// ── Entity — private fields, full getter/setter for JPA ─────
@Entity
public class User {
    @Id @GeneratedValue
    private Long   id;
    private String name;
    private String email;
    private String passwordHash;  // never exposed to API

    public Long   getId()           { return id; }
    public String getName()         { return name; }
    public String getEmail()        { return email; }
    public void   setName(String n) { this.name = n; }
    public void   setEmail(String e) { this.email = e; }
    // No getter for passwordHash — encapsulated completely
}

// ── DTO — only expose what the API consumer should see ──────
public class UserResponseDTO {
    private Long   id;
    private String name;
    private String email;
    // passwordHash intentionally NOT included

    public UserResponseDTO(User user) {
        this.id    = user.getId();
        this.name  = user.getName();
        this.email = user.getEmail();
    }
    public Long   getId()    { return id; }
    public String getName()  { return name; }
    public String getEmail() { return email; }
}

public class Student {
    String name;
    int    age;
    double marks;

    // Without this → name conflict bug
    Student(String name, int age, double marks) {
        this.name  = name;   // instance var = parameter
        this.age   = age;
        this.marks = marks;
    }

    void display() {
        // this. optional here (no conflict) but makes intent clear
        System.out.printf("Name: %s | Age: %d | Marks: %.1f%n",
            this.name, this.age, this.marks);
    }

    public static void main(String[] args) {
        new Student("Rahul", 20, 88.5).display();
        new Student("Priya", 22, 94.0).display();
    }
}

public class Box {
    int length, width, height;

    // Master constructor — does all the real work
    Box(int length, int width, int height) {
        this.length = length;
        this.width  = width;
        this.height = height;
        System.out.println("Box("+length+","+width+","+height+") created");
    }

    // Cube shortcut — delegates to master
    Box(int side) {
        this(side, side, side);  // MUST be first line
        System.out.println("Cube shortcut used");
    }

    // Default 1x1x1 box
    Box() {
        this(1);  // chains to Box(int side)
        System.out.println("Default box used");
    }

    int volume() { return length * width * height; }

    public static void main(String[] args) {
        System.out.println("--- Custom Box ---");
        Box b1 = new Box(3, 4, 5);
        System.out.println("Volume: " + b1.volume());

        System.out.println("--- Cube ---");
        Box b2 = new Box(4);
        System.out.println("Volume: " + b2.volume());

        System.out.println("--- Default ---");
        Box b3 = new Box();
        System.out.println("Volume: " + b3.volume());
    }
}

class Validator {
    boolean isValid(BankAccount acc) {
        return acc.balance >= 0 && acc.owner != null;
    }
}

class BankAccount {
    String owner;
    double balance;

    BankAccount(String owner, double balance) {
        this.owner   = owner;
        this.balance = balance;
    }

    void validate() {
        Validator v = new Validator();
        boolean ok = v.isValid(this);  // pass current object
        System.out.println(owner + " account valid: " + ok);
    }
}

public class PassThisDemo {
    public static void main(String[] args) {
        new BankAccount("Rahul", 5000).validate();
        new BankAccount(null, -100).validate();
    }
}

public class QueryBuilder {
    String table, condition, orderBy;
    int    limit = 10;

    QueryBuilder from(String table) {
        this.table = table; return this;
    }
    QueryBuilder where(String condition) {
        this.condition = condition; return this;
    }
    QueryBuilder orderBy(String col) {
        this.orderBy = col; return this;
    }
    QueryBuilder limit(int n) {
        this.limit = n; return this;
    }

    String build() {
        return "SELECT * FROM " + table
             + " WHERE "    + condition
             + " ORDER BY " + orderBy
             + " LIMIT "    + limit;
    }

    public static void main(String[] args) {
        String query = new QueryBuilder()
            .from("users")
            .where("active = true")
            .orderBy("name")
            .limit(5)
            .build();
        System.out.println(query);
    }
}

// ── Constructor injection — this.field = field ──────────────
@RestController
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;  // classic this use
    }

    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // ResponseEntity uses return this internally — fluent builder
        return ResponseEntity.ok(userService.findById(id));
    }
}

// ── Lombok @Builder — auto-generates return this setters ────
@Entity
@Builder        // Lombok generates full Builder class
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id @GeneratedValue
    private Long   id;
    private String name;
    private String email;
}

// Usage — Lombok Builder (uses this internally):
// User u = User.builder().name("Rahul").email("r@x.com").build();

public class Car {
    String brand;
    String color;
    int    year;

    // 1. No-arg constructor — explicit (needed alongside parameterized)
    Car() {
        this.brand = "Unknown";
        this.color = "White";
        this.year  = 2020;
        System.out.println("No-arg constructor called");
    }

    // 2. Parameterized constructor
    Car(String brand, String color, int year) {
        this.brand = brand;
        this.color = color;
        this.year  = year;
        System.out.println("Parameterized constructor called");
    }

    void display() {
        System.out.printf("  %s | %s | %d%n", brand, color, year);
    }

    public static void main(String[] args) {
        Car c1 = new Car();                        // no-arg
        c1.display();

        Car c2 = new Car("Toyota", "Red", 2023);  // parameterized
        c2.display();
    }
}

public class Product {
    String name;
    double price;
    int    stock;
    String category;

    // Master constructor — all four fields
    Product(String name, double price, int stock, String category) {
        this.name     = name;
        this.price    = price;
        this.stock    = stock;
        this.category = category;
    }

    // No category — delegates, uses "General" as default
    Product(String name, double price, int stock) {
        this(name, price, stock, "General");
    }

    // Name + price only — stock defaults to 0
    Product(String name, double price) {
        this(name, price, 0);
    }

    // Name only — placeholder product
    Product(String name) {
        this(name, 0.0);
    }

    void display() {
        System.out.printf("%-12s | ₹%-8.2f | stock:%-4d | %s%n",
            name, price, stock, category);
    }

    public static void main(String[] args) {
        new Product("Laptop", 75000, 10, "Electronics").display();
        new Product("Pen", 15, 500).display();
        new Product("Notebook", 120).display();
        new Product("TBD").display();
    }
}

public class Demo {

    // TRUE constructor — no return type, auto-called on new
    Demo() {
        System.out.println("Constructor: Demo()");
    }

    // This looks like a constructor but has void — it is a METHOD!
    // Java allows methods with same name as class (confusing but legal)
    void Demo() {  // ← this is a regular method, NOT a constructor
        System.out.println("Method: void Demo() — I am a method, not a constructor!");
    }

    public static void main(String[] args) {
        Demo d = new Demo();  // only constructor runs
        d.Demo();              // explicit call runs the method
    }
}

// ── Constructor injection (recommended over @Autowired field) ──
@Service
@RequiredArgsConstructor  // Lombok: generates constructor for final fields
public class OrderService {

    private final OrderRepository orderRepo;   // injected via constructor
    private final PaymentService  paymentSvc;  // injected via constructor

    // Lombok generates this automatically:
    // OrderService(OrderRepository orderRepo, PaymentService paymentSvc) {
    //     this.orderRepo   = orderRepo;
    //     this.paymentSvc  = paymentSvc;
    // }
}

// ── JPA Entity — must have no-arg constructor ──────────────────
@Entity
@NoArgsConstructor             // Hibernate needs this
@AllArgsConstructor            // convenient for creating instances
public class Order {
    @Id @GeneratedValue
    private Long   id;
    private String product;
    private int    quantity;
}

// Usage:
// Order o = new Order(null, "Laptop", 2);  ← @AllArgsConstructor
// Order o = new Order();                   ← @NoArgsConstructor (Hibernate)

public class Student {
    String name;
    int    age;

    // Regular parameterized constructor
    Student(String name, int age) {
        this.name = name;
        this.age  = age;
    }

    // Copy constructor — takes a Student, copies its fields
    Student(Student other) {
        this.name = other.name;  // String is immutable — safe
        this.age  = other.age;   // primitive — direct copy
    }

    void display(String label) {
        System.out.printf("%s → name=%-8s age=%d%n", label, name, age);
    }

    public static void main(String[] args) {
        Student s1 = new Student("Rahul", 20);

        // ❌ Reference copy — same object
        Student ref = s1;

        // ✅ Copy constructor — new independent object
        Student s2 = new Student(s1);

        // Modify s2 and ref
        s2.name  = "Priya";
        s2.age   = 22;
        ref.name = "Changed!";  // also changes s1

        s1.display("s1 ");   // affected by ref change
        s2.display("s2 ");   // independent — unaffected
        ref.display("ref");  // same as s1
    }
}

import java.util.Arrays;

public class Gradebook {
    String  student;
    int[]   scores;   // mutable reference type — needs deep copy

    Gradebook(String student, int[] scores) {
        this.student = student;
        this.scores  = scores;
    }

    // SHALLOW copy constructor — copies the array REFERENCE
    Gradebook(Gradebook other, boolean deep) {
        this.student = other.student;
        if (deep) {
            // DEEP copy — new array with same values
            this.scores = Arrays.copyOf(other.scores, other.scores.length);
        } else {
            // SHALLOW copy — copies the reference, shares array
            this.scores = other.scores;
        }
    }

    void display(String label) {
        System.out.println(label + " " + student
            + ": " + Arrays.toString(scores));
    }

    public static void main(String[] args) {
        Gradebook original = new Gradebook("Rahul", new int[]{90,85,92});

        Gradebook shallow = new Gradebook(original, false);
        Gradebook deep    = new Gradebook(original, true);

        // Modify via shallow copy
        shallow.scores[0] = 99;

        System.out.println("After shallow.scores[0] = 99:");
        original.display("original:");  // AFFECTED — shared array!
        shallow.display("shallow: ");

        // Modify via deep copy
        deep.scores[0] = 55;
        System.out.println("After deep.scores[0] = 55:");
        original.display("original:");  // UNAFFECTED — independent array
        deep.display("deep:    ");
    }
}

public class Point {
    int x, y;

    Point(int x, int y) { this.x=x; this.y=y; }

    // ✅ Copy constructor — clean, no exceptions, no Cloneable
    Point(Point other) {
        this.x = other.x;
        this.y = other.y;
    }

    public static void main(String[] args) {
        Point p1 = new Point(3, 4);
        Point p2 = new Point(p1);  // copy constructor

        p2.x = 10;
        System.out.println("p1: ("+p1.x+","+p1.y+")");  // unchanged
        System.out.println("p2: ("+p2.x+","+p2.y+")");  // independent
        System.out.println("Same object? " + (p1 == p2));    // false
    }
}