Encapsulation in Java
Complete Deep Dive

public class Rectangle {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        setLength(length);
        setWidth(width);
    }

    public double getLength() { return length; }
    public double getWidth()  { return width; }

    public void setLength(double length) {
        if (length <= 0) throw new IllegalArgumentException("Length positive hona chahiye! Got: " + length);
        this.length = length;
    }

    public void setWidth(double width) {
        if (width <= 0) throw new IllegalArgumentException("Width positive hona chahiye! Got: " + width);
        this.width = width;
    }

    // Computed — no separate fields needed
    public double getArea()      { return length * width; }
    public double getPerimeter() { return 2 * (length + width); }
    public boolean isSquare()   { return length == width; }

    @Override
    public String toString() {
        return String.format(
            "Rectangle[%.1f × %.1f] | Area=%.2f | Perimeter=%.2f | Square=%s",
            length, width, getArea(), getPerimeter(), isSquare());
    }

    public static void main(String[] args) {
        Rectangle r1 = new Rectangle(5, 3);
        Rectangle r2 = new Rectangle(4, 4);
        System.out.println(r1);
        System.out.println(r2);
        r1.setLength(10);
        System.out.println("After resize: " + r1);
        try {
            new Rectangle(-2, 5);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

public class Person {
    private String name;
    private int    age;
    private String email;

    public Person(String name, int age, String email) {
        setName(name); setAge(age); setEmail(email);
    }

    public String getName()  { return name; }
    public int    getAge()   { return age; }
    public String getEmail() { return email; }

    public void setName(String name) {
        if (name == null || name.trim().isEmpty())
            throw new IllegalArgumentException("Name required!");
        // Auto title-case: "rahul sharma" → "Rahul Sharma"
        String[] parts = name.trim().split("\\s+");
        StringBuilder sb = new StringBuilder();
        for (String p : parts) {
            if (!p.isEmpty()) sb.append(Character.toUpperCase(p.charAt(0)))
                              .append(p.substring(1).toLowerCase()).append(" ");
        }
        this.name = sb.toString().trim();
    }

    public void setAge(int age) {
        if (age < 1 || age > 120)
            throw new IllegalArgumentException("Age 1-120 ke beech hona chahiye!");
        this.age = age;
    }

    public void setEmail(String email) {
        if (email == null || !email.contains("@") || !email.contains("."))
            throw new IllegalArgumentException("Valid email required (must have @ and .)");
        this.email = email.toLowerCase().trim();
    }

    public String getCategory() {
        if      (age < 13) return "Child";
        else if (age < 18) return "Teenager";
        else if (age < 60) return "Adult";
        else               return "Senior";
    }

    @Override
    public String toString() {
        return String.format("Person{name='%s', age=%d (%s), email='%s'}",
            name, age, getCategory(), email);
    }

    public static void main(String[] args) {
        Person p = new Person("rahul SHARMA", 25, "RAHUL@Gmail.Com");
        System.out.println(p);  // name auto-formatted, email lowercase

        try { new Person("Test", 200, "test@a.com"); }
        catch (IllegalArgumentException e) { System.out.println("Age Error: "+e.getMessage()); }

        try { new Person("Test", 20, "invalidemail"); }
        catch (IllegalArgumentException e) { System.out.println("Email Error: "+e.getMessage()); }
    }
}

public class Counter {
    private int       count;
    private final int minValue;
    private final int maxValue;
    private int       totalIncrements;
    private int       totalDecrements;

    public Counter(int initial, int min, int max) {
        if (min >= max)      throw new IllegalArgumentException("min must be < max!");
        if (initial < min || initial > max)
            throw new IllegalArgumentException("Initial must be in [min, max]");
        this.count = initial; this.minValue = min; this.maxValue = max;
    }

    public Counter() { this(0, 0, Integer.MAX_VALUE); }  // default

    public boolean increment() {
        if (count >= maxValue) { System.out.println("Max ("+maxValue+") reached!"); return false; }
        count++; totalIncrements++; return true;
    }

    public boolean decrement() {
        if (count <= minValue) { System.out.println("Min ("+minValue+") reached!"); return false; }
        count--; totalDecrements++; return true;
    }

    public void incrementBy(int n) { for (int i=0; iif(!increment()) break; }
    public void reset()            { count = minValue; }

    public int    getCount()           { return count; }
    public int    getTotalIncrements() { return totalIncrements; }
    public int    getTotalDecrements() { return totalDecrements; }
    public boolean isAtMax()          { return count == maxValue; }
    public boolean isAtMin()          { return count == minValue; }

    @Override
    public String toString() {
        return String.format("Counter{count=%d, range=[%d,%d], +%d, -%d}",
            count, minValue, maxValue, totalIncrements, totalDecrements);
    }

    public static void main(String[] args) {
        Counter c = new Counter(0, 0, 5);
        c.incrementBy(7);       // only goes to 5
        System.out.println(c);
        c.decrement(); c.decrement();
        System.out.println(c);
        c.reset();
        System.out.println("After reset: " + c.getCount());
        for (int i=0; i<3; i++) c.decrement(); // only 1 works
    }
}

public class Circle {
    private double radius;
    private static final double PI = Math.PI;

    public Circle(double radius) { setRadius(radius); }

    public double getRadius() { return radius; }
    public void   setRadius(double radius) {
        if (radius <= 0) throw new IllegalArgumentException("Radius must be positive!");
        this.radius = radius;
    }

    public double getArea()          { return PI * radius * radius; }
    public double getCircumference() { return 2 * PI * radius; }
    public double getDiameter()      { return 2 * radius; }

    public boolean isLargerThan(Circle other) { return this.getArea() > other.getArea(); }
    public boolean canFitInside(Circle other)  { return this.radius < other.radius; }
    public boolean intersectsWith(Circle other, double distBetweenCenters) {
        return distBetweenCenters < (this.radius + other.radius);
    }

    @Override
    public String toString() {
        return String.format("Circle[r=%.1f | area=%.2f | circumf=%.2f]",
            radius, getArea(), getCircumference());
    }

    public static void main(String[] args) {
        Circle c1 = new Circle(5.0);
        Circle c2 = new Circle(3.0);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println("c1 larger than c2: " + c1.isLargerThan(c2));
        System.out.println("c2 fits in c1:     " + c2.canFitInside(c1));
        System.out.println("Intersect (d=6):   " + c1.intersectsWith(c2, 6));
    }
}

public class Product {
    private final String  productId;
    private       String  name;
    private       double  price;
    private       int     stock;
    private       double  discountPercent;
    private       int     totalSold;

    public Product(String id, String name, double price, int stock) {
        this.productId = id;
        setName(name); setPrice(price); restock(stock);
    }

    public void setName(String name) {
        if (name == null || name.trim().isEmpty()) throw new IllegalArgumentException("Name required!");
        this.name = name.trim();
    }
    public void setPrice(double price) {
        if (price < 0) throw new IllegalArgumentException("Price negative nahi ho sakti!");
        this.price = price;
    }

    public void applyDiscount(double percent) {
        if (percent < 0 || percent > 90) throw new IllegalArgumentException("Discount 0-90% ke beech!");
        this.discountPercent = percent;
        System.out.printf("💰 %s pe %.0f%% discount applied! Effective price: Rs %.2f%n",
            name, percent, getEffectivePrice());
    }

    public double getEffectivePrice() { return price * (1 - discountPercent / 100); }

    public void restock(int qty) {
        if (qty <= 0) throw new IllegalArgumentException("Restock qty positive hona chahiye!");
        stock += qty;
        System.out.println("📦 " + name + ": Restocked " + qty + ". Total stock: " + stock);
    }

    public boolean buy(int qty) {
        if (qty <= 0)    { System.out.println("Invalid qty!"); return false; }
        if (stock < qty) { System.out.println("❌ Insufficient stock! Available: "+stock); return false; }
        stock     -= qty;
        totalSold += qty;
        System.out.printf("🛒 Bought %d x %s @ Rs %.2f each. Total: Rs %.2f%n",
            qty, name, getEffectivePrice(), qty * getEffectivePrice());
        if (stock < 5) System.out.println("⚠️ Low stock alert! Only " + stock + " left.");
        return true;
    }

    public String  getProductId() { return productId; }
    public String  getName()      { return name; }
    public double getPrice()      { return price; }
    public int    getStock()      { return stock; }
    public int    getTotalSold()  { return totalSold; }
    public boolean isOutOfStock() { return stock == 0; }

    @Override
    public String toString() {
        return String.format("[%s] %s | MRP:Rs%.0f | Eff:Rs%.2f | Stock:%d | Sold:%d",
            productId, name, price, getEffectivePrice(), stock, totalSold);
    }

    public static void main(String[] args) {
        Product p = new Product("PROD001", "Laptop", 55000, 10);
        System.out.println(p);
        p.applyDiscount(15);
        p.buy(3);
        p.buy(5);
        p.buy(4);  // insufficient
        System.out.println(p);
    }
}

public class Car {
    private final String  brand;
    private final String  model;
    private       double  fuelLevel;       // liters
    private       int     speed;           // km/h
    private       int     gear;            // 1-6
    private       boolean engineOn;

    private static final double MAX_FUEL       = 50.0;
    private static final int    MAX_SPEED      = 200;
    private static final double FUEL_PER_KM   = 0.08;

    public Car(String brand, String model) {
        this.brand = brand; this.model = model;
        this.fuelLevel = MAX_FUEL; this.gear = 1;
    }

    public void startEngine() {
        if (fuelLevel <= 0) { System.out.println("⛽ No fuel! Cannot start."); return; }
        engineOn = true; System.out.println("🔑 Engine started! Vroom...");
    }

    public void accelerate(int amount) {
        if (!engineOn)         { System.out.println("Start engine first!"); return; }
        if (fuelLevel <= 1.0)  { System.out.println("⚠️ Low fuel! Speed maintained."); return; }
        if (amount <= 0) throw new IllegalArgumentException("Acceleration positive hona chahiye!");
        speed = Math.min(speed + amount, MAX_SPEED);
        fuelLevel -= amount * FUEL_PER_KM * 0.5;
        fuelLevel = Math.max(0, fuelLevel);
        System.out.printf("🚗 Speed: %d km/h | Fuel: %.1f L | Gear: %d%n", speed, fuelLevel, gear);
    }

    public void brake(int amount) {
        speed = Math.max(0, speed - amount);
        if (speed == 0) { engineOn = false; System.out.println("🛑 Stopped."); }
        else System.out.println("Speed reduced to: " + speed + " km/h");
    }

    public void shiftGear(int newGear) {
        if (newGear < 1 || newGear > 6) throw new IllegalArgumentException("Gear 1-6 ke beech!");
        if (Math.abs(newGear - gear) > 1) { System.out.println("⚠️ Skip gear not recommended!"); }
        gear = newGear; System.out.println("Gear shifted to: " + gear);
    }

    public void refuel(double liters) {
        if (liters <= 0) throw new IllegalArgumentException("Refuel amount positive hona chahiye!");
        fuelLevel = Math.min(fuelLevel + liters, MAX_FUEL);
        System.out.printf("⛽ Refueled. Fuel: %.1f/%.1f L%n", fuelLevel, MAX_FUEL);
    }

    public String  getBrand()     { return brand; }
    public String  getModel()     { return model; }
    public int    getSpeed()     { return speed; }
    public double getFuelLevel() { return fuelLevel; }
    public int    getGear()      { return gear; }
    public boolean isEngineOn() { return engineOn; }

    public static void main(String[] args) {
        Car car = new Car("Maruti", "Swift");
        car.startEngine();
        car.accelerate(40);
        car.shiftGear(2);
        car.accelerate(60);
        car.shiftGear(3);
        car.accelerate(80);
        car.brake(50);
        car.brake(130);
    }
}

public class Temperature {
    private double celsius;  // internal storage always Celsius
    private static final double ABSOLUTE_ZERO_C = -273.15;

    private Temperature(double celsius) { setCelsius(celsius); }

    // Factory Methods — create from any unit
    public static Temperature fromCelsius(double c)    { return new Temperature(c); }
    public static Temperature fromFahrenheit(double f) { return new Temperature((f - 32) * 5 / 9); }
    public static Temperature fromKelvin(double k)     { return new Temperature(k + ABSOLUTE_ZERO_C); }

    public void setCelsius(double celsius) {
        if (celsius < ABSOLUTE_ZERO_C)
            throw new IllegalArgumentException("Absolute zero ("+ABSOLUTE_ZERO_C+"°C) se neeche nahi ja sakte!");
        this.celsius = celsius;
    }

    // Getters in all 3 formats
    public double getCelsius()    { return celsius; }
    public double getFahrenheit() { return celsius * 9 / 5 + 32; }
    public double getKelvin()     { return celsius - ABSOLUTE_ZERO_C; }

    public String getState() {
        if      (celsius <= 0)   return "Ice ❄️";
        else if (celsius < 100) return "Liquid 💧";
        else                    return "Steam 💨";
    }

    @Override
    public String toString() {
        return String.format("%.2f°C = %.2f°F = %.2fK [%s]",
            celsius, getFahrenheit(), getKelvin(), getState());
    }

    public static void main(String[] args) {
        System.out.println(Temperature.fromCelsius(100));
        System.out.println(Temperature.fromCelsius(0));
        System.out.println(Temperature.fromFahrenheit(98.6));  // body temp
        System.out.println(Temperature.fromKelvin(0));         // absolute zero

        try {
            Temperature.fromCelsius(-300);  // below absolute zero!
        } catch (IllegalArgumentException e) { System.out.println("Error: " + e.getMessage()); }
    }
}

import java.util.HashMap;
import java.util.Map;

public class AppConfig {
    // Single instance — private static
    private static AppConfig instance;

    // Private fields
    private final Map<String, String> configs;
    private String environment;
    private boolean debugMode;

    // PRIVATE constructor — new AppConfig() bahar se IMPOSSIBLE!
    private AppConfig() {
        configs     = new HashMap<>();
        environment = "development";
        debugMode   = false;
        loadDefaults();
        System.out.println("⚙️ AppConfig initialized (only once!)");
    }

    private void loadDefaults() {
        configs.put("db.host",      "localhost");
        configs.put("db.port",      "5432");
        configs.put("app.version",  "1.0.0");
        configs.put("max.threads",  "10");
    }

    // Public access point — ONLY WAY to get instance
    public static synchronized AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();  // lazy init — sirf pehli baar
        }
        return instance;
    }

    public String  get(String key)              { return configs.getOrDefault(key, "NOT_FOUND"); }
    public void    set(String key, String value) { configs.put(key, value); }
    public int     getInt(String key)            { return Integer.parseInt(get(key)); }
    public String  getEnvironment()               { return environment; }
    public void    setEnvironment(String env)     {
        if (!env.matches("development|staging|production"))
            throw new IllegalArgumentException("Valid env: development, staging, production");
        this.environment = env;
    }
    public boolean isDebugMode()                  { return debugMode; }
    public void    setDebugMode(boolean debug)    { this.debugMode = debug; }

    public static void main(String[] args) {
        // getInstance() hi ek way hai
        AppConfig config1 = AppConfig.getInstance();
        AppConfig config2 = AppConfig.getInstance();

        System.out.println("Same instance? " + (config1 == config2));  // true!

        config1.set("db.host", "prod-server.db.com");
        config1.setEnvironment("production");
        config1.setDebugMode(false);

        // config2 pe access karo — same data!
        System.out.println("DB Host:  " + config2.get("db.host"));
        System.out.println("Env:      " + config2.getEnvironment());
        System.out.println("Threads:  " + config2.getInt("max.threads"));

        try {
            config1.setEnvironment("invalid");  // invalid env
        } catch (IllegalArgumentException e) {
            System.out.println("Env Error: " + e.getMessage());
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Pizza {
    // Immutable fields — set once via Builder
    private final String       size;
    private final String       crust;
    private final String       sauce;
    private final List<String>  toppings;
    private final boolean      extraCheese;
    private final double       price;

    // PRIVATE constructor — sirf Builder se banana possible!
    private Pizza(Builder b) {
        this.size        = b.size;
        this.crust       = b.crust;
        this.sauce       = b.sauce;
        this.toppings    = Collections.unmodifiableList(new ArrayList<>(b.toppings));
        this.extraCheese = b.extraCheese;
        this.price       = b.calculatePrice();
    }

    // ── Getters only — fully immutable ──
    public String       getSize()        { return size; }
    public String       getCrust()       { return crust; }
    public String       getSauce()       { return sauce; }
    public List<String> getToppings()    { return toppings; }
    public boolean      isExtraCheese()  { return extraCheese; }
    public double       getPrice()       { return price; }

    @Override
    public String toString() {
        return String.format(
            "🍕 %s Pizza | Crust: %s | Sauce: %s | Toppings: %s | ExtraCheese: %s | Price: Rs %.0f",
            size, crust, sauce, toppings, extraCheese, price);
    }

    // ── STATIC INNER BUILDER CLASS ──
    public static class Builder {
        // Required
        private final String size;
        // Optional with defaults
        private String       crust       = "Thin";
        private String       sauce       = "Tomato";
        private List<String> toppings    = new ArrayList<>();
        private boolean      extraCheese = false;

        public Builder(String size) {
            if (!size.matches("Small|Medium|Large"))
                throw new IllegalArgumentException("Size: Small, Medium, Large only!");
            this.size = size;
        }

        public Builder crust(String crust)    { this.crust = crust;         return this; }
        public Builder sauce(String sauce)    { this.sauce = sauce;         return this; }
        public Builder addTopping(String t)  {
            if (toppings.size() >= 5) throw new IllegalStateException("Max 5 toppings!");
            toppings.add(t); return this;
        }
        public Builder extraCheese()           { this.extraCheese = true;    return this; }

        double calculatePrice() {
            double base = size.equals("Small") ? 199 : size.equals("Medium") ? 299 : 399;
            return base + toppings.size() * 30 + (extraCheese ? 50 : 0);
        }

        public Pizza build() { return new Pizza(this); }
    }

    public static void main(String[] args) {
        // Builder pattern — readable, step by step
        Pizza p1 = new Pizza.Builder("Large")
            .crust("Thick")
            .sauce("BBQ")
            .addTopping("Mushrooms")
            .addTopping("Peppers")
            .addTopping("Onions")
            .extraCheese()
            .build();
        System.out.println(p1);

        Pizza p2 = new Pizza.Builder("Small")
            .addTopping("Paneer")
            .build();  // defaults for rest
        System.out.println(p2);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Patient {
    private final String      patientId;
    private final String      name;
    private final int         age;
    private final String      bloodGroup;
    private       double      weight;
    private       double      height;
    private final List<String> prescriptions = new ArrayList<>();
    private final List<String> allergies     = new ArrayList<>();
    private       boolean     criticalStatus;
    private static final String[] VALID_BLOOD_GROUPS =
        {"A+","A-","B+","B-","AB+","AB-","O+","O-"};

    public Patient(String id, String name, int age, String bloodGroup, double wt, double ht) {
        if (age < 0 || age > 150) throw new IllegalArgumentException("Invalid age!");
        if (!isValidBloodGroup(bloodGroup)) throw new IllegalArgumentException("Invalid blood group!");
        if (wt <= 0 || ht <= 0)  throw new IllegalArgumentException("Weight/Height positive hona chahiye!");
        this.patientId = id; this.name = name; this.age = age;
        this.bloodGroup = bloodGroup; this.weight = wt; this.height = ht;
    }

    private boolean isValidBloodGroup(String bg) {
        for (String valid : VALID_BLOOD_GROUPS) if (valid.equals(bg)) return true;
        return false;
    }

    // Doctor privilege method — structured prescription
    public void addPrescription(String medicine, String dosage, String doctorId) {
        if (medicine == null || medicine.trim().isEmpty())
            throw new IllegalArgumentException("Medicine name required!");
        prescriptions.add(String.format("%s | %s | Dr.%s", medicine.trim(), dosage, doctorId));
        System.out.println("💊 Prescription added: " + medicine);
    }

    public void addAllergy(String allergen) {
        if (allergen == null || allergen.trim().isEmpty())
            throw new IllegalArgumentException("Allergen name required!");
        allergies.add(allergen.trim());
        System.out.println("⚠️ Allergy recorded: " + allergen);
    }

    public double getBMI() { return weight / (height * height); }
    public String getBMICategory() {
        double bmi = getBMI();
        if      (bmi < 18.5) return "Underweight";
        else if (bmi < 25.0) return "Normal";
        else if (bmi < 30.0) return "Overweight";
        else                  return "Obese";
    }

    // Getters
    public String      getPatientId()     { return patientId; }
    public String      getName()          { return name; }
    public int         getAge()           { return age; }
    public String      getBloodGroup()    { return bloodGroup; }
    public double      getWeight()        { return weight; }
    public boolean     isCritical()       { return criticalStatus; }
    public void        setCritical(boolean c) { this.criticalStatus = c; }
    // Defensive copy — caller cannot modify internal list
    public List<String> getPrescriptions() { return Collections.unmodifiableList(prescriptions); }
    public List<String> getAllergies()     { return Collections.unmodifiableList(allergies); }

    public void printSummary() {
        System.out.println("\n═══════════ PATIENT SUMMARY ═══════════");
        System.out.printf("ID: %s | Name: %s | Age: %d%n", patientId, name, age);
        System.out.printf("Blood: %s | Weight: %.1fkg | BMI: %.1f (%s)%n",
            bloodGroup, weight, getBMI(), getBMICategory());
        System.out.println("Status: " + (criticalStatus ? "🔴 CRITICAL" : "🟢 Stable"));
        System.out.println("Allergies: " + (allergies.isEmpty() ? "None" : allergies));
        System.out.println("Prescriptions:");
        for (String rx : prescriptions) System.out.println("  • " + rx);
        System.out.println("════════════════════════════════════════");
    }

    public static void main(String[] args) {
        Patient p = new Patient("PAT001", "Rahul Gupta", 35, "A+", 75.5, 1.75);
        p.addAllergy("Penicillin");
        p.addAllergy("Dust");
        p.addPrescription("Paracetamol", "500mg x 3/day", "DR123");
        p.addPrescription("Vitamin D", "1000IU x 1/day", "DR123");
        p.printSummary();

        try {
            p.getPrescriptions().add("Hacked!");  // unmodifiable!
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify prescriptions directly! " + e.getClass().getSimpleName());
        }
    }
}