public class BankAccount {
    // Private data (encapsulated)
    private int balance;
    private String accountHolder;
    
    // Constructor
    public BankAccount(String name, int initialBalance) {
        this.accountHolder = name;
        this.balance = initialBalance;
    }
    
    // Methods to interact with data
    public void displayBalance() {
        System.out.println("Balance: " + balance);
    }
    
    public boolean withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount);
            return true;
        } else {
            System.out.println("Insufficient funds");
            return false;
        }
    }
    
    // Getter method
    public int getBalance() {
        return balance;
    }
}

// Using the class
public class Main {
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount("John", 1000);
        BankAccount account2 = new BankAccount("Alice", 1500);
        
        account1.displayBalance();
        account1.withdraw(200);
    }
}

// Student.java
public class Student {
    // Attributes (data members)
    private String name;
    private int rollNumber;
    private String branch;
    private double percentage;
    
    // Constructor
    public Student(String name, int rollNumber, 
                  String branch, double percentage) {
        this.name = name;
        this.rollNumber = rollNumber;
        this.branch = branch;
        this.percentage = percentage;
    }
    
    // Methods (behaviors)
    public void displayDetails() {
        System.out.println("=== Student Details ===");
        System.out.println("Name: " + name);
        System.out.println("Roll Number: " + rollNumber);
        System.out.println("Branch: " + branch);
        System.out.println("Percentage: " + percentage + "%");
    }
    
    public char getGrade() {
        if (percentage >= 90) return 'A';
        else if (percentage >= 80) return 'B';
        else if (percentage >= 70) return 'C';
        else if (percentage >= 60) return 'D';
        else return 'F';
    }
    
    public boolean isEligibleForPlacement() {
        return percentage >= 65.0;
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        // Creating objects (instances)
        Student student1 = new Student(
            "Alice Johnson", 
            101, 
            "Computer Science", 
            87.5
        );
        
        Student student2 = new Student(
            "Bob Smith", 
            102, 
            "Information Technology", 
            92.3
        );
        
        Student student3 = new Student(
            "Charlie Brown", 
            103, 
            "Electronics", 
            76.8
        );
        
        // Using object methods
        student1.displayDetails();
        System.out.println("Grade: " + student1.getGrade());
        System.out.println("Placement Eligible: " + 
                         student1.isEligibleForPlacement());
        
        System.out.println("\n" + "=".repeat(30) + "\n");
        
        student2.displayDetails();
        System.out.println("Grade: " + student2.getGrade());
        System.out.println("Placement Eligible: " + 
                         student2.isEligibleForPlacement());
    }
}

// Parent class
public class Vehicle {
    protected String brand;
    protected String model;
    protected int year;
    protected double price;
    
    public Vehicle(String brand, String model, int year, double price) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.price = price;
    }
    
    public void start() {
        System.out.println(brand + " " + model + " is starting...");
    }
    
    public void stop() {
        System.out.println(brand + " " + model + " has stopped.");
    }
    
    public void displayInfo() {
        System.out.println("Vehicle: " + brand + " " + model + " (" + year + ")");
        System.out.println("Price: $" + price);
    }
    
    public double calculateDepreciation(int years) {
        return price * Math.pow(0.85, years); // 15% per year
    }
}

// Child class
public class Car extends Vehicle {
    private int numberOfDoors;
    private String fuelType;
    private boolean hasAirConditioning;
    
    public Car(String brand, String model, int year, double price,
              int doors, String fuelType, boolean hasAC) {
        super(brand, model, year, price); // Call parent constructor
        this.numberOfDoors = doors;
        this.fuelType = fuelType;
        this.hasAirConditioning = hasAC;
    }
    
    // Method overriding
    @Override
    public void start() {
        System.out.println("Car " + brand + " " + model + " engine started!");
        if (hasAirConditioning) {
            System.out.println("Air conditioning activated.");
        }
    }
    
    // Additional methods specific to Car
    public void honk() {
        System.out.println("Beep! Beep!");
    }
    
    public void openTrunk() {
        System.out.println("Trunk opened.");
    }
    
    // Overriding parent method with additional functionality
    @Override
    public void displayInfo() {
        super.displayInfo(); // Call parent method
        System.out.println("Doors: " + numberOfDoors);
        System.out.println("Fuel Type: " + fuelType);
        System.out.println("Air Conditioning: " + (hasAirConditioning ? "Yes" : "No"));
    }
    
    // Car-specific depreciation calculation
    @Override
    public double calculateDepreciation(int years) {
        // Cars depreciate faster
        return price * Math.pow(0.80, years); // 20% per year
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Runtime polymorphism
        Vehicle[] vehicles = {
            new Car("Toyota", "Camry", 2023, 25000, 4, "Hybrid", true),
            new Motorcycle("Honda", "CBR600", 2023, 12000, "Sport"),
            new Truck("Ford", "F-150", 2023, 35000, 2.5)
        };
        
        // Same method call, different behavior
        for (Vehicle vehicle : vehicles) {
            vehicle.start();        // Polymorphic call
            vehicle.displayInfo();  // Different implementations
            
            // Type checking and casting
            if (vehicle instanceof Car) {
                Car car = (Car) vehicle;
                car.honk(); // Car-specific method
            } else if (vehicle instanceof Motorcycle) {
                Motorcycle bike = (Motorcycle) vehicle;
                bike.wheelie(); // Motorcycle-specific method
            }
            
            System.out.println("Depreciation after 3 years: $" + 
                             vehicle.calculateDepreciation(3));
            System.out.println("-".repeat(40));
        }
    }
}

public class Motorcycle extends Vehicle {
    private String bikeType; // Sport, Cruiser, Touring
    
    public Motorcycle(String brand, String model, int year, 
                     double price, String bikeType) {
        super(brand, model, year, price);
        this.bikeType = bikeType;
    }
    
    @Override
    public void start() {
        System.out.println("Motorcycle " + brand + " " + model + 
                          " roars to life!");
    }
    
    public void wheelie() {
        System.out.println("Performing a wheelie! 🏍️");
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Bike Type: " + bikeType);
    }
}

public class Truck extends Vehicle {
    private double cargoCapacity; // in tons
    
    public Truck(String brand, String model, int year, 
                double price, double capacity) {
        super(brand, model, year, price);
        this.cargoCapacity = capacity;
    }
    
    @Override
    public void start() {
        System.out.println("Truck " + brand + " " + model + 
                          " diesel engine started!");
    }
    
    public void loadCargo(double weight) {
        if (weight <= cargoCapacity) {
            System.out.println("Loaded " + weight + " tons of cargo.");
        } else {
            System.out.println("Cannot load " + weight + 
                             " tons. Max capacity: " + cargoCapacity);
        }
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Cargo Capacity: " + cargoCapacity + " tons");
    }
    
    // Trucks hold value better
    @Override
    public double calculateDepreciation(int years) {
        return price * Math.pow(0.88, years); // 12% per year
    }
}

public class Calculator {
    // Compile-time polymorphism
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
}

public class BankAccount {
    // Private data - cannot be accessed directly
    private String accountNumber;
    private String accountHolderName;
    private double balance;
    private String accountType;
    private java.util.Date lastTransactionDate;
    private java.util.List<String> transactionHistory;
    
    // Constructor
    public BankAccount(String accountNumber, String holderName, 
                      String accountType, double initialBalance) {
        this.accountNumber = accountNumber;
        this.accountHolderName = holderName;
        this.accountType = accountType;
        this.balance = Math.max(0, initialBalance);
        this.lastTransactionDate = new java.util.Date();
        this.transactionHistory = new java.util.ArrayList<>();
        
        addTransaction("Account opened with balance: $" + initialBalance);
    }
    
    // Public methods for controlled access
    public boolean deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Invalid deposit amount!");
            return false;
        }
        
        balance += amount;
        lastTransactionDate = new java.util.Date();
        addTransaction("Deposited: $" + amount + ". New balance: $" + balance);
        System.out.println("Successfully deposited $" + amount);
        return true;
    }
    
    public boolean withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Invalid withdrawal amount!");
            return false;
        }
        
        if (amount > balance) {
            System.out.println("Insufficient funds! Available balance: $" + balance);
            return false;
        }
        
        balance -= amount;
        lastTransactionDate = new java.util.Date();
        addTransaction("Withdrawn: $" + amount + ". New balance: $" + balance);
        System.out.println("Successfully withdrawn $" + amount);
        return true;
    }
    
    // Private helper method
    private void addTransaction(String transaction) {
        String timestamp = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                              .format(new java.util.Date());
        transactionHistory.add(timestamp + " - " + transaction);
    }
    
    // Getters (public read access)
    public double getBalance() { return balance; }
    public String getAccountNumber() { return accountNumber; }
    public String getAccountHolderName() { return accountHolderName; }
    public String getAccountType() { return accountType; }
    
    // No setters for critical data like balance (controlled modification only)
    
    public void printTransactionHistory() {
        System.out.println("\n=== Transaction History for " + accountHolderName + " ===");
        for (String transaction : transactionHistory) {
            System.out.println(transaction);
        }
    }
}

// Demonstration of encapsulation benefits
public class EncapsulationDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(
            "ACC001", "Alice Johnson", "Savings", 1000.0
        );
        
        // Controlled access through methods
        System.out.println("Initial Balance: $" + account.getBalance());
        
        // Valid operations
        account.deposit(500.0);
        account.withdraw(200.0);
        
        // Invalid operations (will be rejected)
        account.deposit(-100.0);  // Negative amount
        account.withdraw(2000.0); // Insufficient funds
        
        // Direct access to balance is not possible
        // account.balance = 1000000; // Compilation error!
        
        account.printTransactionHistory();
        
        System.out.println("\nFinal Balance: $" + account.getBalance());
    }
}

public class SecureBankAccount extends BankAccount {
    private String pin;
    private boolean isLocked;
    private int failedAttempts;
    private static final int MAX_FAILED_ATTEMPTS = 3;
    
    public SecureBankAccount(String accountNumber, String holderName,
                           String accountType, double initialBalance, String pin) {
        super(accountNumber, holderName, accountType, initialBalance);
        this.pin = pin;
        this.isLocked = false;
        this.failedAttempts = 0;
    }
    
    public boolean authenticate(String enteredPin) {
        if (isLocked) {
            System.out.println("Account is locked due to multiple failed attempts!");
            return false;
        }
        
        if (pin.equals(enteredPin)) {
            failedAttempts = 0; // Reset on successful authentication
            return true;
        } else {
            failedAttempts++;
            if (failedAttempts >= MAX_FAILED_ATTEMPTS) {
                isLocked = true;
                System.out.println("Account locked after " + MAX_FAILED_ATTEMPTS + 
                                 " failed attempts!");
            } else {
                System.out.println("Incorrect PIN. Attempts remaining: " + 
                                 (MAX_FAILED_ATTEMPTS - failedAttempts));
            }
            return false;
        }
    }
    
    // Override withdraw to require authentication
    @Override
    public boolean withdraw(double amount) {
        System.out.print("Enter PIN for withdrawal: ");
        // In real application, use secure input method
        String enteredPin = "1234"; // Simulated input
        
        if (authenticate(enteredPin)) {
            return super.withdraw(amount);
        } else {
            System.out.println("Withdrawal failed due to authentication failure!");
            return false;
        }
    }
    
    public void unlockAccount(String masterPin) {
        if ("MASTER123".equals(masterPin)) {
            isLocked = false;
            failedAttempts = 0;
            System.out.println("Account unlocked successfully!");
        } else {
            System.out.println("Invalid master PIN!");
        }
    }
}

public abstract class Shape {
    protected String color;
    protected double x, y; // Position
    
    // Constructor in abstract class
    public Shape(String color, double x, double y) {
        this.color = color;
        this.x = x;
        this.y = y;
    }
    
    // Abstract methods - must be implemented by subclasses
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
    public abstract void draw();
    
    // Concrete methods - shared implementation
    public void move(double newX, double newY) {
        System.out.println("Moving " + this.getClass().getSimpleName() + 
                          " from (" + x + ", " + y + ") to (" + newX + ", " + newY + ")");
        this.x = newX;
        this.y = newY;
    }
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
        System.out.println("Color changed to: " + color);
    }
    
    // Template method pattern
    public final void displayInfo() {
        System.out.println("\n=== " + this.getClass().getSimpleName() + " Information ===");
        System.out.println("Color: " + color);
        System.out.println("Position: (" + x + ", " + y + ")");
        System.out.println("Area: " + calculateArea());
        System.out.println("Perimeter: " + calculatePerimeter());
        draw();
    }
}

// Concrete implementations
public class Circle extends Shape {
    private double radius;
    
    public Circle(String color, double x, double y, double radius) {
        super(color, x, y);
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle with radius " + radius);
        // ASCII art representation
        System.out.println("    ***    ");
        System.out.println("  *     *  ");
        System.out.println(" *       * ");
        System.out.println("  *     *  ");
        System.out.println("    ***    ");
    }
    
    // Additional methods specific to Circle
    public double getDiameter() {
        return 2 * radius;
    }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(String color, double x, double y, double width, double height) {
        super(color, x, y);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " rectangle (" + width + "x" + height + ")");
        // ASCII art representation
        System.out.println("*********");
        System.out.println("*       *");
        System.out.println("*       *");
        System.out.println("*********");
    }
    
    public boolean isSquare() {
        return Math.abs(width - height) < 0.001; // Account for floating point precision
    }
}

// Basic interface
public interface Drawable {
    void draw();
    void resize(double scale);
    
    // Default method (Java 8+)
    default void highlight() {
        System.out.println("Highlighting the drawable object");
    }
    
    // Static method (Java 8+)
    static void printDrawingInstructions() {
        System.out.println("1. Set position\n2. Set properties\n3. Call draw()");
    }
}

public interface Movable {
    void moveUp(double distance);
    void moveDown(double distance);
    void moveLeft(double distance);
    void moveRight(double distance);
    
    // Default implementation
    default void moveToOrigin() {
        System.out.println("Moving to origin (0, 0)");
    }
}

// Multiple inheritance through interfaces
public class Triangle extends Shape implements Drawable, Movable {
    private double side1, side2, side3;
    
    public Triangle(String color, double x, double y, 
                   double side1, double side2, double side3) {
        super(color, x, y);
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }
    
    @Override
    public double calculateArea() {
        // Using Heron's formula
        double s = (side1 + side2 + side3) / 2;
        return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
    }
    
    @Override
    public double calculatePerimeter() {
        return side1 + side2 + side3;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " triangle");
        System.out.println("   /\\   ");
        System.out.println("  /  \\  ");
        System.out.println(" /____\\ ");
    }
    
    @Override
    public void resize(double scale) {
        side1 *= scale;
        side2 *= scale;
        side3 *= scale;
        System.out.println("Triangle resized by factor: " + scale);
    }
    
    @Override
    public void moveUp(double distance) {
        y += distance;
        System.out.println("Moved up by " + distance);
    }
    
    @Override
    public void moveDown(double distance) {
        y -= distance;
        System.out.println("Moved down by " + distance);
    }
    
    @Override
    public void moveLeft(double distance) {
        x -= distance;
        System.out.println("Moved left by " + distance);
    }
    
    @Override
    public void moveRight(double distance) {
        x += distance;
        System.out.println("Moved right by " + distance);
    }
    
    public String getTriangleType() {
        if (side1 == side2 && side2 == side3) {
            return "Equilateral";
        } else if (side1 == side2 || side2 == side3 || side1 == side3) {
            return "Isosceles";
        } else {
            return "Scalene";
        }
    }
}