Constructors in Java
Complete Deep Dive

public class Demo {

    String name;
    int age;

    // ✅ CONSTRUCTOR — no return type, class ke naam jaisa
    Demo(String name, int age) {
        this.name = name;  // this = current object ka reference
        this.age  = age;
        System.out.println("Constructor called! Object created.");
    }

    // ✅ METHOD — void return type, alag naam
    void introduce() {
        System.out.println("I am " + name + ", age " + age);
    }

    // ❌ YE CONSTRUCTOR NAHI HAI — void hai, method ban gaya
    // void Demo() { ... }  ← common mistake!

    public static void main(String[] args) {

        // Constructor automatically call hoga, hum call nahi karte
        Demo d1 = new Demo("Rahul", 21);  // Constructor runs here!
        Demo d2 = new Demo("Priya", 22);  // Constructor runs again for d2

        // Method explicitly call karte hain
        d1.introduce();
        d2.introduce();
        d1.introduce();  // method baar baar call ho sakta hai

        // d1.Demo("Amit", 20); ← ILLEGAL — constructor directly call nahi hota
    }
}

public class Box {

    int    length;   // default: 0
    int    width;    // default: 0
    double price;   // default: 0.0
    String color;   // default: null
    boolean fragile; // default: false

    // ── Compiler internally add karta hai ye ──
    // Box() {
    //     super();  // Object class ka constructor
    // }
    // Hum kuch likhein ya na likhein, ye already exist karta hai

    void display() {
        System.out.println("Length : " + length);
        System.out.println("Width  : " + width);
        System.out.println("Price  : " + price);
        System.out.println("Color  : " + color);
        System.out.println("Fragile: " + fragile);
    }

    public static void main(String[] args) {
        Box b = new Box();  // no-arg call — default constructor invoked
        b.display();

        System.out.println("\n── Fields manually set karo ──");
        b.length  = 10;
        b.width   = 5;
        b.price   = 299.99;
        b.color   = "Red";
        b.fragile = true;
        b.display();
    }
}

public class Car {
    String model;
    int    year;

    // ── Ye ek parameterized constructor likhte hi default CHALA GAYA ──
    Car(String model, int year) {
        this.model = model;
        this.year  = year;
    }

    // ── SOLUTION: Explicitly no-arg constructor bhi likho ──
    // Ise "user-defined no-arg constructor" kehte hain
    Car() {
        this.model = "Unknown";  // meaningful default value
        this.year  = 2024;
        System.out.println("No-arg constructor called");
    }

    void show() {
        System.out.println("Model: " + model + ", Year: " + year);
    }

    public static void main(String[] args) {
        Car c1 = new Car();                // no-arg → our explicit one
        Car c2 = new Car("Tesla Model 3", 2024); // parameterized
        Car c3 = new Car("Tata Nexon",   2023); // parameterized

        c1.show();
        c2.show();
        c3.show();

        // new Car(); ← COMPILE ERROR agar no-arg explicitly na likha ho
        //            aur sirf parameterized constructor ho
        // Error: constructor Car() is not applicable
    }
}

public class Student {
    String name;   // instance variable
    int    age;    // instance variable
    double gpa;    // instance variable

    // ── Parameter names same as instance variables ──
    // this.name = instance variable
    // name      = parameter (local to constructor)
    Student(String name, int age, double gpa) {
        this.name = name;  // ← this.name is instance variable
        this.age  = age;
        this.gpa  = gpa;
        System.out.println("Student created: " + this.name);
    }

    // ── Without this — confusing but works if names differ ──
    Student(String n, int a) {
        name = n;   // no this needed, names are different
        age  = a;
        gpa  = 0.0;
    }

    void display() {
        System.out.printf("Name: %-10s Age: %2d  GPA: %.1f%n", name, age, gpa);
    }

    public static void main(String[] args) {
        Student s1 = new Student("Rahul",   20, 8.5);
        Student s2 = new Student("Priya",   21, 9.2);
        Student s3 = new Student("Amit",    22);      // 2-param version
        Student s4 = new Student("Sneha",   19, 7.8);

        System.out.println("\n── Student List ──");
        s1.display(); s2.display(); s3.display(); s4.display();
    }
}

public class Rectangle {
    double length, width;
    String color;

    // Constructor 1: No-arg — default square 1×1 white
    Rectangle() {
        length = 1.0; width = 1.0; color = "White";
    }

    // Constructor 2: Side only — square banao
    Rectangle(double side) {
        length = side; width = side; color = "White";
    }

    // Constructor 3: Length + Width
    Rectangle(double length, double width) {
        this.length = length;
        this.width  = width;
        this.color  = "White";
    }

    // Constructor 4: Full — sab kuch
    Rectangle(double length, double width, String color) {
        this.length = length;
        this.width  = width;
        this.color  = color;
    }

    double area()      { return length * width; }
    double perimeter() { return 2 * (length + width); }
    boolean isSquare() { return length == width; }

    void info() {
        System.out.printf("[%s] %.1f×%.1f  Area=%.2f  Perim=%.2f  Square=%b%n",
            color, length, width, area(), perimeter(), isSquare());
    }

    public static void main(String[] args) {
        Rectangle r1 = new Rectangle();
        Rectangle r2 = new Rectangle(5.0);
        Rectangle r3 = new Rectangle(8.0, 4.0);
        Rectangle r4 = new Rectangle(10.0, 6.0, "Blue");

        r1.info(); r2.info(); r3.info(); r4.info();
    }
}

public class BankAccount {
    private final String accountId;
    private final String owner;
    private       double balance;

    BankAccount(String accountId, String owner, double initialBalance) {
        // ── Validation — invalid state mein object create nahi honge ──
        if (accountId == null || accountId.trim().isEmpty())
            throw new IllegalArgumentException("Account ID required");
        if (owner == null || owner.trim().isEmpty())
            throw new IllegalArgumentException("Owner name required");
        if (initialBalance < 0)
            throw new IllegalArgumentException("Balance cannot be negative");

        this.accountId      = accountId.trim().toUpperCase();
        this.owner          = owner.trim();
        this.balance        = initialBalance;
        System.out.println("✅ Account created: " + this.accountId);
    }

    void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Positive amount required");
        balance += amount;
    }

    void withdraw(double amount) {
        if (amount > balance) throw new IllegalStateException("Insufficient funds");
        balance -= amount;
    }

    void info() {
        System.out.printf("Account: %-10s Owner: %-12s Balance: ₹%.2f%n",
            accountId, owner, balance);
    }

    public static void main(String[] args) {
        BankAccount acc1 = new BankAccount("hdfc001", "Rahul Sharma", 5000);
        acc1.deposit(2000);
        acc1.withdraw(500);
        acc1.info();

        // Invalid objects — constructor throws exception
        try {
            BankAccount bad = new BankAccount("", "Amit", 1000);
        } catch (IllegalArgumentException e) {
            System.out.println("❌ Error: " + e.getMessage());
        }

        try {
            BankAccount bad2 = new BankAccount("sbi002", "Priya", -500);
        } catch (IllegalArgumentException e) {
            System.out.println("❌ Error: " + e.getMessage());
        }
    }
}

public class Employee {
    String name;
    int    id;
    double salary;
    String department;

    // ── Regular Parameterized Constructor ──
    Employee(String name, int id, double salary, String department) {
        this.name       = name;
        this.id         = id;
        this.salary     = salary;
        this.department = department;
    }

    // ── Copy Constructor ──
    // Parameter: same class ka object
    // String immutable hai — shallow copy safe hai
    Employee(Employee other) {
        this.name       = other.name;       // String immutable → safe
        this.id         = other.id + 1000;  // new ID (different for copy)
        this.salary     = other.salary;
        this.department = other.department;
        System.out.println("Copy of " + other.name + " created → ID: " + this.id);
    }

    void show() {
        System.out.printf("ID:%-5d  %-12s  ₹%-10.0f  %s%n",
            id, name, salary, department);
    }

    public static void main(String[] args) {
        Employee emp1 = new Employee("Rahul", 101, 75000, "Engineering");
        Employee emp2 = new Employee(emp1);     // copy constructor call
        Employee emp3 = new Employee(emp1);     // another copy

        System.out.println("\n── Original ──");
        emp1.show();
        System.out.println("── Copies ──");
        emp2.show();
        emp3.show();

        // Prove they're independent objects
        emp2.name   = "Priya";
        emp2.salary = 85000;
        System.out.println("\n── After modifying emp2 ──");
        System.out.println("emp1 (unchanged): "); emp1.show();
        System.out.println("emp2 (modified):  "); emp2.show();
    }
}

import java.util.Arrays;

public class Marksheet {
    String studentName;
    int[]  scores;     // mutable reference — deep copy zaroori

    Marksheet(String name, int[] scores) {
        this.studentName = name;
        this.scores = scores.clone();  // input bhi clone karo (defensive copy)
    }

    // ── SHALLOW Copy Constructor (Problematic) ──
    // Marksheet(Marksheet other) {
    //     this.studentName = other.studentName;
    //     this.scores = other.scores;  ← Same array shared!
    // }

    // ── DEEP Copy Constructor (Correct) ──
    Marksheet(Marksheet other) {
        this.studentName = other.studentName;
        this.scores      = other.scores.clone();  // NEW array = independent
    }

    int total() { int s = 0; for (int x : scores) s += x; return s; }

    void show() {
        System.out.printf("%-10s  Scores: %-30s  Total: %d%n",
            studentName, Arrays.toString(scores), total());
    }

    public static void main(String[] args) {
        Marksheet m1 = new Marksheet("Rahul", new int[]{85, 90, 78, 92, 88});

        // Deep copy
        Marksheet m2 = new Marksheet(m1);

        // Modify m2's scores — should NOT affect m1
        m2.studentName = "Priya";
        m2.scores[0]   = 99;  // deep copy → m1 safe

        System.out.println("── After modifying m2 ──");
        m1.show();  // Rahul's score[0] still 85
        m2.show();  // Priya's score[0] is 99

        // Same object? No!
        System.out.println("Same array? " + (m1.scores == m2.scores));  // false
    }
}

public class Pizza {
    String size;
    String crust;
    String sauce;
    String cheese;
    boolean extraCheese;

    // ── Master Constructor — sab values ——————————————
    // Actual initialization yahan hoti hai, ek jagah
    Pizza(String size, String crust, String sauce, String cheese, boolean extra) {
        this.size        = size;
        this.crust       = crust;
        this.sauce       = sauce;
        this.cheese      = cheese;
        this.extraCheese = extra;
    }

    // ── Without extra cheese (calls 5-param) ──
    Pizza(String size, String crust, String sauce, String cheese) {
        this(size, crust, sauce, cheese, false);  // ← must be FIRST line
    }

    // ── With default sauce (calls 4-param) ──
    Pizza(String size, String crust) {
        this(size, crust, "Tomato", "Mozzarella");  // defaults
    }

    // ── Just size (calls 2-param) ──
    Pizza(String size) {
        this(size, "Thin Crust");  // default crust
    }

    void describe() {
        System.out.println("Pizza: " + size + " | Crust: " + crust +
            " | Sauce: " + sauce + " | Cheese: " + cheese +
            " | Extra: " + extraCheese);
    }

    public static void main(String[] args) {
        Pizza p1 = new Pizza("Small");
        Pizza p2 = new Pizza("Medium", "Thick Crust");
        Pizza p3 = new Pizza("Large", "Stuffed", "BBQ", "Cheddar");
        Pizza p4 = new Pizza("XL", "Pan", "Pesto", "Gouda", true);

        p1.describe(); p2.describe(); p3.describe(); p4.describe();
    }
}

public class Config {
    String host;
    int    port;
    int    timeout;
    boolean ssl;

    // ── Constructor A: no-arg → calls B ──
    Config() {
        this("localhost", 8080);  // → B runs first
        System.out.println("A: no-arg constructor done");
    }

    // ── Constructor B: host+port → calls C ──
    Config(String host, int port) {
        this(host, port, 30, false);    // → C runs first
        System.out.println("B: host+port constructor done");
    }

    // ── Constructor C: all params — ACTUAL INIT ──
    Config(String host, int port, int timeout, boolean ssl) {
        this.host    = host;
        this.port    = port;
        this.timeout = timeout;
        this.ssl     = ssl;
        System.out.println("C: full constructor done → initialized");
    }

    void show() {
        System.out.printf("Config: %s:%d  timeout=%ds  ssl=%b%n",
            host, port, timeout, ssl);
    }

    public static void main(String[] args) {
        System.out.println("═══ new Config() ═══");
        Config c1 = new Config();

        System.out.println("\n═══ new Config(host, port) ═══");
        Config c2 = new Config("api.example.com", 443);

        System.out.println("\n═══ new Config(all) ═══");
        Config c3 = new Config("db.prod.com", 5432, 60, true);

        System.out.println("\n── Configs ──");
        c1.show(); c2.show(); c3.show();
    }
}

// ── Level 1: GrandParent ──
class Person {
    String name;
    int    id;

    Person(String name, int id) {
        this.name = name;
        this.id   = id;
        System.out.println("1. Person constructor: " + name);
    }
}

// ── Level 2: Parent ──
class Employee extends Person {
    double salary;

    Employee(String name, int id, double salary) {
        super(name, id);           // ← Parent (Person) constructor call
        this.salary = salary;
        System.out.println("2. Employee constructor: salary=" + salary);
    }
}

// ── Level 3: Child ──
class Manager extends Employee {
    int    teamSize;
    String project;

    Manager(String name, int id, double salary, int teamSize, String project) {
        super(name, id, salary);   // ← Parent (Employee) constructor call
        this.teamSize = teamSize;
        this.project  = project;
        System.out.println("3. Manager constructor: team=" + teamSize);
    }

    void info() {
        System.out.printf("\n── Manager Info ──%nName: %s  ID: %d  Salary: ₹%.0f%n" +
            "Team: %d  Project: %s%n", name, id, salary, teamSize, project);
    }
}

public class InheritanceChain {
    public static void main(String[] args) {
        System.out.println("═══ Creating Manager Object ═══");
        Manager mgr = new Manager("Rahul", 101, 90000, 5, "Apollo");
        mgr.info();

        System.out.println("\n═══ Creating Employee Object ═══");
        Employee emp = new Employee("Priya", 102, 65000);
    }
}

class Animal {
    String species;

    // ── No-arg constructor — compiler ki zaroorat ──
    Animal() {
        this.species = "Unknown";
        System.out.println("Animal() called (implicit super in Dog)");
    }

    Animal(String species) {
        this.species = species;
        System.out.println("Animal(species) called → " + species);
    }
}

class Dog extends Animal {
    String breed;

    // ── Compiler automatically adds: super(); as first statement ──
    Dog(String breed) {
        // super(); ← ye compiler khud add karta hai yahan!
        this.breed = breed;
        System.out.println("Dog(breed) called → " + breed);
    }

    // ── Explicit super(args) ──
    Dog(String species, String breed) {
        super(species);  // explicitly calling Animal(String)
        this.breed = breed;
        System.out.println("Dog(species, breed) → " + breed);
    }

    void show() {
        System.out.println("Species: " + species + ", Breed: " + breed);
    }
}

public class ImplicitSuper {
    public static void main(String[] args) {
        System.out.println("── Dog(breed) — implicit super() ──");
        Dog d1 = new Dog("Labrador");
        d1.show();

        System.out.println("\n── Dog(species, breed) — explicit super ──");
        Dog d2 = new Dog("Canis lupus", "German Shepherd");
        d2.show();
    }
}

import java.time.LocalDateTime;

// ── Base Entity — common audit fields ──
class BaseEntity {
    private final long          id;
    private final LocalDateTime createdAt;

    BaseEntity(long id) {
        this.id        = id;
        this.createdAt = LocalDateTime.now();
    }

    long          getId()        { return id; }
    LocalDateTime getCreatedAt() { return createdAt; }
}

// ── Product — mid-level ──
class Product extends BaseEntity {
    protected String name;
    protected double price;

    Product(long id, String name, double price) {
        super(id);             // BaseEntity constructor
        this.name  = name;
        this.price = price;
    }

    String getSummary() {
        return "[ID:" + getId() + "] " + name + " ₹" + price;
    }
}

// ── DigitalProduct — child ──
class DigitalProduct extends Product {
    private String  downloadUrl;
    private int     licenseCount;

    DigitalProduct(long id, String name, double price,
                   String downloadUrl, int licenseCount) {
        super(id, name, price);  // Product constructor
        this.downloadUrl  = downloadUrl;
        this.licenseCount = licenseCount;
    }

    void describe() {
        System.out.println(getSummary());
        System.out.println("  URL: "     + downloadUrl);
        System.out.println("  Licenses: " + licenseCount);
        System.out.println("  Created: "  + getCreatedAt().toLocalDate());
    }
}

public class EntityHierarchy {
    public static void main(String[] args) {
        DigitalProduct course = new DigitalProduct(
            1001L, "Java Backend Masterclass", 1999.0,
            "https://cdn.example.com/java-course.zip", 1
        );
        course.describe();
    }
}