Java Inheritance - Complete Tutorial

// Superclass (Parent Class)
class Vehicle {
    // Instance variables
    protected String brand;
    protected String model;
    protected int year;
    protected double price;
    
    // Constructor
    public Vehicle(String brand, String model, int year, double price) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.price = price;
        System.out.println("Vehicle constructor called");
    }
    
    // Methods
    public void start() {
        System.out.println(brand + " " + model + " is starting...");
    }
    
    public void stop() {
        System.out.println(brand + " " + model + " is stopping...");
    }
    
    public void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
        System.out.println("Price: $" + price);
    }
    
    // Getters
    public String getBrand() { return brand; }
    public String getModel() { return model; }
    public int getYear() { return year; }
    public double getPrice() { return price; }
}

// Subclass (Child Class) - Car inherits from Vehicle
class Car extends Vehicle {
    // Additional instance variables specific to Car
    private int numberOfDoors;
    private String fuelType;
    private boolean hasSunroof;
    
    // Constructor
    public Car(String brand, String model, int year, double price,
               int numberOfDoors, String fuelType, boolean hasSunroof) {
        // Call superclass constructor using super()
        super(brand, model, year, price);
        
        // Initialize Car-specific properties
        this.numberOfDoors = numberOfDoors;
        this.fuelType = fuelType;
        this.hasSunroof = hasSunroof;
        System.out.println("Car constructor called");
    }
    
    // Additional methods specific to Car
    public void honk() {
        System.out.println(brand + " " + model + " is honking: Beep Beep!");
    }
    
    public void openSunroof() {
        if (hasSunroof) {
            System.out.println(brand + " " + model + " sunroof is opening...");
        } else {
            System.out.println(brand + " " + model + " doesn't have a sunroof");
        }
    }
    
    // Override displayInfo() method from Vehicle
    @Override
    public void displayInfo() {
        // Call parent class method using super
        super.displayInfo();
        
        // Add Car-specific information
        System.out.println("Number of Doors: " + numberOfDoors);
        System.out.println("Fuel Type: " + fuelType);
        System.out.println("Has Sunroof: " + (hasSunroof ? "Yes" : "No"));
    }
    
    // Getters for Car-specific properties
    public int getNumberOfDoors() { return numberOfDoors; }
    public String getFuelType() { return fuelType; }
    public boolean hasSunroof() { return hasSunroof; }
}

// Another Subclass - Motorcycle inherits from Vehicle
class Motorcycle extends Vehicle {
    // Additional instance variables
    private boolean hasSidecar;
    private String motorcycleType;
    
    // Constructor
    public Motorcycle(String brand, String model, int year, double price,
                      boolean hasSidecar, String motorcycleType) {
        super(brand, model, year, price);
        this.hasSidecar = hasSidecar;
        this.motorcycleType = motorcycleType;
        System.out.println("Motorcycle constructor called");
    }
    
    // Additional methods
    public void wheelie() {
        System.out.println(brand + " " + model + " is doing a wheelie!");
    }
    
    // Override start() method
    @Override
    public void start() {
        System.out.println(brand + " " + model + " motorcycle engine is roaring to life!");
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Has Sidecar: " + (hasSidecar ? "Yes" : "No"));
        System.out.println("Type: " + motorcycleType);
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        System.out.println("=== Inheritance Demonstration ===\n");
        
        // Create a Car object
        System.out.println("=== Creating Car Object ===");
        Car myCar = new Car("Toyota", "Camry", 2023, 25000.0, 4, "Gasoline", true);
        
        System.out.println("\n=== Car Methods ===");
        myCar.start();          // Inherited from Vehicle
        myCar.honk();           // Car-specific method
        myCar.openSunroof();    // Car-specific method
        myCar.stop();           // Inherited from Vehicle
        
        System.out.println("\n=== Car Information ===");
        myCar.displayInfo();    // Overridden method
        
        System.out.println("\n=== Creating Motorcycle Object ===");
        Motorcycle myBike = new Motorcycle("Harley-Davidson", "Sportster", 2022, 15000.0, false, "Cruiser");
        
        System.out.println("\n=== Motorcycle Methods ===");
        myBike.start();         // Overridden method
        myBike.wheelie();       // Motorcycle-specific method
        myBike.stop();          // Inherited from Vehicle
        
        System.out.println("\n=== Motorcycle Information ===");
        myBike.displayInfo();   // Overridden method
        
        System.out.println("\n=== Benefits of Inheritance ===");
        System.out.println("1. Code Reusability: Common code in Vehicle class");
        System.out.println("2. Extensibility: Easy to add new vehicle types");
        System.out.println("3. Maintainability: Changes in Vehicle affect all subclasses");
        System.out.println("4. Polymorphism: Vehicles can be treated uniformly");
        
        System.out.println("\n=== IS-A Relationship ===");
        System.out.println("Car IS-A Vehicle: " + (myCar instanceof Vehicle));
        System.out.println("Motorcycle IS-A Vehicle: " + (myBike instanceof Vehicle));
        System.out.println("Car IS-A Car: " + (myCar instanceof Car));
        System.out.println("Vehicle IS-A Car: " + (new Vehicle("Generic", "Model", 2020, 10000) instanceof Car));
    }
}

public class InheritanceTypes {
    
    // === SINGLE INHERITANCE ===
    static class Employee {
        private String name;
        private int id;
        private double salary;
        
        public Employee(String name, int id, double salary) {
            this.name = name;
            this.id = id;
            this.salary = salary;
        }
        
        public void work() {
            System.out.println(name + " is working");
        }
        
        public double calculateBonus() {
            return salary * 0.10;
        }
    }
    
    // Single Inheritance: Manager extends Employee
    static class Manager extends Employee {
        private int teamSize;
        
        public Manager(String name, int id, double salary, int teamSize) {
            super(name, id, salary);
            this.teamSize = teamSize;
        }
        
        public void conductMeeting() {
            System.out.println(getName() + " is conducting a meeting with " + teamSize + " team members");
        }
        
        @Override
        public double calculateBonus() {
            return super.calculateBonus() + (teamSize * 500);
        }
        
        public String getName() {
            // Accessing parent's private field through getter (not shown)
            return "Manager: Access needed";
        }
    }
    
    // === MULTILEVEL INHERITANCE ===
    static class Animal {
        protected String species;
        
        public Animal(String species) {
            this.species = species;
        }
        
        public void eat() {
            System.out.println(species + " is eating");
        }
        
        public void sleep() {
            System.out.println(species + " is sleeping");
        }
    }
    
    static class Mammal extends Animal {
        protected boolean hasFur;
        
        public Mammal(String species, boolean hasFur) {
            super(species);
            this.hasFur = hasFur;
        }
        
        public void giveBirth() {
            System.out.println(species + " is giving birth to live young");
        }
    }
    
    // Multilevel Inheritance: Dog extends Mammal which extends Animal
    static class Dog extends Mammal {
        private String breed;
        
        public Dog(String breed, boolean hasFur) {
            super("Dog", hasFur);
            this.breed = breed;
        }
        
        public void bark() {
            System.out.println(breed + " dog is barking: Woof! Woof!");
        }
        
        @Override
        public void eat() {
            System.out.println(breed + " dog is eating dog food");
        }
        
        // Can access grandparent methods
        public void animalBehavior() {
            super.eat();  // Calls Mammal's eat() which might call Animal's eat()
            sleep();      // From Animal class
        }
    }
    
    // === HIERARCHICAL INHERITANCE ===
    static class Shape {
        protected String color;
        
        public Shape(String color) {
            this.color = color;
        }
        
        public double calculateArea() {
            return 0.0;
        }
        
        public double calculatePerimeter() {
            return 0.0;
        }
        
        public void display() {
            System.out.println("Shape color: " + color);
        }
    }
    
    // Multiple classes extending the same parent (Hierarchical)
    static class Circle extends Shape {
        private double radius;
        
        public Circle(String color, double radius) {
            super(color);
            this.radius = radius;
        }
        
        @Override
        public double calculateArea() {
            return Math.PI * radius * radius;
        }
        
        @Override
        public double calculatePerimeter() {
            return 2 * Math.PI * radius;
        }
        
        @Override
        public void display() {
            super.display();
            System.out.println("Shape: Circle, Radius: " + radius);
        }
    }
    
    static class Rectangle extends Shape {
        private double width;
        private double height;
        
        public Rectangle(String color, double width, double height) {
            super(color);
            this.width = width;
            this.height = height;
        }
        
        @Override
        public double calculateArea() {
            return width * height;
        }
        
        @Override
        public double calculatePerimeter() {
            return 2 * (width + height);
        }
        
        @Override
        public void display() {
            super.display();
            System.out.println("Shape: Rectangle, Width: " + width + ", Height: " + height);
        }
    }
    
    static class Triangle extends Shape {
        private double base;
        private double height;
        
        public Triangle(String color, double base, double height) {
            super(color);
            this.base = base;
            this.height = height;
        }
        
        @Override
        public double calculateArea() {
            return 0.5 * base * height;
        }
        
        @Override
        public double calculatePerimeter() {
            // For simplicity, assuming right triangle
            double hypotenuse = Math.sqrt(base * base + height * height);
            return base + height + hypotenuse;
        }
        
        @Override
        public void display() {
            super.display();
            System.out.println("Shape: Triangle, Base: " + base + ", Height: " + height);
        }
    }
    
    // === WHY NO MULTIPLE INHERITANCE? ===
    /*
    // This would cause the Diamond Problem
    class A {
        void display() { System.out.println("A"); }
    }
    
    class B extends A {
        @Override
        void display() { System.out.println("B"); }
    }
    
    class C extends A {
        @Override
        void display() { System.out.println("C"); }
    }
    
    // Which display() should D inherit? B's or C's?
    // class D extends B, C { } // NOT ALLOWED in Java
    
    // Solution: Use interfaces
    interface BInterface {
        default void display() { System.out.println("B Interface"); }
    }
    
    interface CInterface {
        default void display() { System.out.println("C Interface"); }
    }
    
    class D implements BInterface, CInterface {
        // Must override to resolve conflict
        @Override
        public void display() {
            BInterface.super.display(); // Choose which to call
        }
    }
    */
    
    public static void main(String[] args) {
        System.out.println("=== Types of Inheritance Demonstration ===\n");
        
        System.out.println("=== SINGLE INHERITANCE ===");
        Manager mgr = new Manager("Alice", 101, 80000, 5);
        mgr.work();                   // Inherited from Employee
        mgr.conductMeeting();         // Manager-specific
        System.out.println("Bonus: $" + mgr.calculateBonus()); // Overridden method
        
        System.out.println("\n=== MULTILEVEL INHERITANCE ===");
        Dog myDog = new Dog("Golden Retriever", true);
        myDog.eat();                  // Overridden in Dog
        myDog.sleep();                // From Animal (grandparent)
        myDog.giveBirth();            // From Mammal (parent)
        myDog.bark();                 // Dog-specific
        myDog.animalBehavior();       // Demonstrates multi-level access
        
        System.out.println("\n=== HIERARCHICAL INHERITANCE ===");
        Shape[] shapes = {
            new Circle("Red", 5.0),
            new Rectangle("Blue", 4.0, 6.0),
            new Triangle("Green", 3.0, 4.0)
        };
        
        for (Shape shape : shapes) {
            shape.display();
            System.out.println("Area: " + shape.calculateArea());
            System.out.println("Perimeter: " + shape.calculatePerimeter());
            System.out.println();
        }
        
        System.out.println("=== Inheritance Chain Analysis ===");
        System.out.println("Dog instance of Dog: " + (myDog instanceof Dog));
        System.out.println("Dog instance of Mammal: " + (myDog instanceof Mammal));
        System.out.println("Dog instance of Animal: " + (myDog instanceof Animal));
        System.out.println("Dog instance of Object: " + (myDog instanceof Object));
        
        System.out.println("\n=== Java's Inheritance Limitations ===");
        System.out.println("1. Single Class Inheritance: A class can extend only ONE class");
        System.out.println("2. Multiple Interface Inheritance: A class can implement MULTIPLE interfaces");
        System.out.println("3. All classes implicitly extend Object class");
        System.out.println("4. Final classes cannot be extended");
        
        System.out.println("\n=== Best Practices ===");
        System.out.println("1. Use inheritance for IS-A relationships");
        System.out.println("2. Keep inheritance hierarchies shallow (2-3 levels)");
        System.out.println("3. Favor composition over inheritance when appropriate");
        System.out.println("4. Use abstract classes for partial implementations");
        System.out.println("5. Use interfaces for defining contracts");
    }
}

public class SuperKeywordDemo {
    
    // === PARENT CLASS ===
    static class Person {
        protected String name;
        protected int age;
        protected String gender;
        protected String nationality;
        
        // Constructor 1: Default
        public Person() {
            this("Unknown", 0, "Unknown", "Unknown");
            System.out.println("Person() constructor called");
        }
        
        // Constructor 2: With parameters
        public Person(String name, int age, String gender, String nationality) {
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.nationality = nationality;
            System.out.println("Person(String, int, String, String) constructor called");
        }
        
        // Constructor 3: Copy constructor
        public Person(Person other) {
            this(other.name, other.age, other.gender, other.nationality);
            System.out.println("Person(Person) copy constructor called");
        }
        
        // Methods
        public void introduce() {
            System.out.println("Hello, I'm " + name + ", " + age + " years old from " + nationality);
        }
        
        public void work() {
            System.out.println(name + " is working as a person");
        }
        
        public void celebrateBirthday() {
            age++;
            System.out.println(name + " is now " + age + " years old!");
        }
        
        // Getters
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getGender() { return gender; }
        public String getNationality() { return nationality; }
    }
    
    // === CHILD CLASS 1: Student ===
    static class Student extends Person {
        private String studentId;
        private String major;
        private double gpa;
        
        // Constructor 1: Using super() to call specific parent constructor
        public Student(String name, int age, String gender, String nationality,
                      String studentId, String major, double gpa) {
            // Call parent constructor with super()
            super(name, age, gender, nationality);
            
            this.studentId = studentId;
            this.major = major;
            this.gpa = gpa;
            System.out.println("Student constructor called");
        }
        
        // Constructor 2: Using default parent constructor
        public Student(String studentId, String major) {
            // super() is called implicitly (calls Person() default constructor)
            this.studentId = studentId;
            this.major = major;
            this.gpa = 0.0;
            System.out.println("Student(String, String) constructor called");
        }
        
        // Constructor 3: Copy another student
        public Student(Student other) {
            // Call parent copy constructor
            super(other);
            
            this.studentId = other.studentId;
            this.major = other.major;
            this.gpa = other.gpa;
            System.out.println("Student(Student) copy constructor called");
        }
        
        // Override introduce() method
        @Override
        public void introduce() {
            // Call parent's introduce() using super
            super.introduce();
            
            // Add Student-specific information
            System.out.println("I'm a student studying " + major + " with GPA: " + gpa);
        }
        
        // Override work() method
        @Override
        public void work() {
            // Extend parent behavior instead of replacing
            super.work();  // Person's work() method
            System.out.println(name + " is also studying for exams");
        }
        
        // Student-specific method
        public void takeExam(String course) {
            System.out.println(name + " (ID: " + studentId + ") is taking " + course + " exam");
        }
        
        // Method that uses super to access parent's private field through getter
        public void displayFullInfo() {
            System.out.println("=== Student Information ===");
            System.out.println("Name: " + super.getName());  // Using parent's getter
            System.out.println("Age: " + super.getAge());
            System.out.println("Student ID: " + studentId);
            System.out.println("Major: " + major);
            System.out.println("GPA: " + gpa);
        }
        
        // Getters
        public String getStudentId() { return studentId; }
        public String getMajor() { return major; }
        public double getGpa() { return gpa; }
    }
    
    // === CHILD CLASS 2: Employee (demonstrating different super usage) ===
    static class Employee extends Person {
        private String employeeId;
        private String department;
        private double salary;
        private String position;
        
        // Constructor with super() call
        public Employee(String name, int age, String gender, String nationality,
                       String employeeId, String department, double salary, String position) {
            super(name, age, gender, nationality);  // Must be first statement
            this.employeeId = employeeId;
            this.department = department;
            this.salary = salary;
            this.position = position;
            System.out.println("Employee constructor called");
        }
        
        // Constructor chaining with this() and super()
        public Employee(String name, String employeeId, String department) {
            this(name, 25, "Unknown", "Unknown", employeeId, department, 50000.0, "Junior");
            System.out.println("Employee(String, String, String) constructor called");
        }
        
        // Override introduce() without calling super (completely new behavior)
        @Override
        public void introduce() {
            System.out.println("Professional introduction:");
            System.out.println("Hello, I'm " + name + ", " + position + " in " + department);
            System.out.println("Employee ID: " + employeeId);
        }
        
        // Override work() calling super and adding new behavior
        @Override
        public void work() {
            System.out.println(name + " is working as a " + position);
            super.work();  // Still calls Person's work() method
            System.out.println("Department: " + department + ", Salary: $" + salary);
        }
        
        // Employee-specific method that uses super for parent method
        public void requestVacation(int days) {
            System.out.println(name + " is requesting " + days + " days vacation");
            super.celebrateBirthday();  // Using parent's method
        }
        
        // Method showing when super is NOT needed
        public void displayInfo() {
            // Can directly access protected fields from parent
            System.out.println("Employee: " + name);
            System.out.println("Age: " + age);  // age is protected in Person
            
            // Using super is only needed when there's name conflict
            // System.out.println("Name from parent: " + super.name); // Same as name
        }
    }
    
    // === GRANDCHILD CLASS: Demonstrating multilevel super ===
    static class WorkingStudent extends Student {
        private String jobTitle;
        private double hourlyRate;
        
        public WorkingStudent(String name, int age, String gender, String nationality,
                             String studentId, String major, double gpa,
                             String jobTitle, double hourlyRate) {
            // Call Student constructor
            super(name, age, gender, nationality, studentId, major, gpa);
            this.jobTitle = jobTitle;
            this.hourlyRate = hourlyRate;
            System.out.println("WorkingStudent constructor called");
        }
        
        @Override
        public void introduce() {
            // Call Student's introduce() which calls Person's introduce()
            super.introduce();
            
            // Add WorkingStudent-specific info
            System.out.println("I also work as a " + jobTitle + " ($" + hourlyRate + "/hr)");
        }
        
        @Override
        public void work() {
            // Can only call immediate parent's method with super
            super.work();  // Calls Student's work()
            
            // To call Person's work() directly, need to go through Student
            System.out.println("And working part-time as " + jobTitle);
        }
        
        public void calculateWeeklyPay(int hours) {
            double pay = hours * hourlyRate;
            System.out.println(name + " will earn $" + pay + " this week");
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== super Keyword Demonstration ===\n");
        
        System.out.println("=== Creating Student Object ===");
        Student student = new Student("John Doe", 20, "Male", "USA", 
                                     "S12345", "Computer Science", 3.8);
        
        System.out.println("\n=== Student Methods ===");
        student.introduce();      // Calls overridden method (which calls super.introduce())
        student.work();           // Calls overridden method (which calls super.work())
        student.takeExam("Java Programming");
        student.displayFullInfo();
        student.celebrateBirthday();  // Inherited from Person
        
        System.out.println("\n=== Creating Employee Object ===");
        Employee employee = new Employee("Alice Smith", 30, "Female", "Canada",
                                        "E67890", "Engineering", 85000.0, "Senior Developer");
        
        System.out.println("\n=== Employee Methods ===");
        employee.introduce();     // Completely overridden (no super call)
        employee.work();          // Extends parent behavior
        employee.requestVacation(10);
        
        System.out.println("\n=== Creating WorkingStudent (Multilevel) ===");
        WorkingStudent workingStudent = new WorkingStudent("Bob Johnson", 22, "Male", "UK",
                                                          "S54321", "Business", 3.5,
                                                          "Teaching Assistant", 25.0);
        
        System.out.println("\n=== WorkingStudent Methods ===");
        workingStudent.introduce();  // Calls Student.introduce() → Person.introduce()
        workingStudent.work();       // Calls Student.work() → Person.work()
        workingStudent.calculateWeeklyPay(20);
        
        System.out.println("\n=== Important Rules for super ===");
        System.out.println("1. super() must be the first statement in constructor");
        System.out.println("2. super can be used to call parent constructors");
        System.out.println("3. super can be used to call parent methods");
        System.out.println("4. super cannot be used in static methods");
        System.out.println("5. Each constructor can have only one super() call");
        System.out.println("6. If no super() is written, compiler adds super()");
        
        System.out.println("\n=== When to Use super ===");
        System.out.println("1. When overriding methods but want parent behavior too");
        System.out.println("2. When parent has multiple constructors");
        System.out.println("3. When child has field with same name as parent");
        System.out.println("4. When implementing constructor chaining");
        System.out.println("5. When extending abstract class implementations");
        
        System.out.println("\n=== Common Mistakes ===");
        System.out.println("1. Forgetting super() call when parent has no default constructor");
        System.out.println("2. Calling super() after other statements (compile error)");
        System.out.println("3. Using super in static context (not allowed)");
        System.out.println("4. Overusing super when not needed");
    }
}

public class ConstructorInheritance {
    
    // === BASE CLASS WITH DIFFERENT CONSTRUCTORS ===
    static class A {
        private String name;
        private int value;
        
        // Constructor 1: Default
        public A() {
            this("Default", 0);  // Call another constructor in same class
            System.out.println("A() default constructor");
        }
        
        // Constructor 2: With parameters
        public A(String name, int value) {
            // Implicit call to Object() constructor happens here
            this.name = name;
            this.value = value;
            System.out.println("A(String, int) constructor: " + name + ", " + value);
        }
        
        // Constructor 3: Copy constructor
        public A(A other) {
            this(other.name, other.value);
            System.out.println("A(A) copy constructor");
        }
        
        // No default constructor if we comment out A() - try it!
        // Only parameterized constructor exists
    }
    
    // === SUBCLASS B ===
    static class B extends A {
        private double data;
        
        // Constructor 1: Default - will cause error if A has no default constructor
        public B() {
            // super() is implicitly called here
            // If A has no default constructor, this will cause compile error
            this.data = 0.0;
            System.out.println("B() default constructor");
        }
        
        // Constructor 2: With parameters - explicitly calls parent constructor
        public B(String name, int value, double data) {
            // Must call parent constructor explicitly
            super(name, value);  // Calls A(String, int)
            this.data = data;
            System.out.println("B(String, int, double) constructor: data=" + data);
        }
        
        // Constructor 3: Using this() for constructor chaining
        public B(double data) {
            this("B-default", 100, data);  // Calls B(String, int, double)
            System.out.println("B(double) constructor");
        }
    }
    
    // === SUBCLASS C (extends B) ===
    static class C extends B {
        private boolean flag;
        
        // Constructor 1
        public C(String name, int value, double data, boolean flag) {
            // Must call B constructor (which calls A constructor)
            super(name, value, data);
            this.flag = flag;
            System.out.println("C(...) constructor: flag=" + flag);
        }
        
        // Constructor 2: Demonstrating full constructor chain
        public C() {
            // Implicit super() calls B() which calls A()
            // This only works if all parents have default constructors
            this.flag = false;
            System.out.println("C() default constructor");
        }
    }
    
    // === CLASS WITH NO DEFAULT CONSTRUCTOR ===
    static class ParentNoDefault {
        private int x;
        
        // Only parameterized constructor - NO default constructor
        public ParentNoDefault(int x) {
            this.x = x;
            System.out.println("ParentNoDefault(int) constructor: x=" + x);
        }
        
        // If we don't provide default constructor, compiler won't add one
        // because we have a parameterized constructor
    }
    
    static class ChildMustCallSuper extends ParentNoDefault {
        private int y;
        
        public ChildMustCallSuper(int x, int y) {
            // MUST call super() explicitly because parent has no default constructor
            super(x);  // This is required!
            this.y = y;
            System.out.println("ChildMustCallSuper(int, int) constructor: y=" + y);
        }
        
        /*
        // This would cause COMPILE ERROR because no super() call
        public ChildMustCallSuper(int y) {
            this.y = y;  // ERROR: constructor ParentNoDefault() is undefined
        }
        */
    }
    
    // === FINAL CLASS EXAMPLE ===
    static final class FinalClass {
        // Final class cannot be extended
        public FinalClass() {
            System.out.println("FinalClass constructor");
        }
    }
    
    /*
    // This would cause COMPILE ERROR
    static class TryToExtendFinal extends FinalClass {
        // Cannot extend final class
    }
    */
    
    // === CLASS WITH PRIVATE CONSTRUCTOR ===
    static class PrivateConstructor {
        private static int instanceCount = 0;
        
        // Private constructor - cannot be instantiated or extended
        private PrivateConstructor() {
            instanceCount++;
            System.out.println("PrivateConstructor created, total: " + instanceCount);
        }
        
        // Factory method pattern
        public static PrivateConstructor createInstance() {
            return new PrivateConstructor();
        }
    }
    
    /*
    // This would cause COMPILE ERROR
    static class TryToExtendPrivate extends PrivateConstructor {
        // Cannot extend class with private constructor
    }
    */
    
    // === ABSTRACT CLASS CONSTRUCTORS ===
    abstract class AbstractBase {
        protected String type;
        
        // Abstract classes CAN have constructors
        public AbstractBase(String type) {
            this.type = type;
            System.out.println("AbstractBase constructor: " + type);
        }
        
        // Abstract method
        public abstract void performAction();
        
        // Concrete method
        public void displayType() {
            System.out.println("Type: " + type);
        }
    }
    
    static class ConcreteChild extends AbstractBase {
        private int value;
        
        public ConcreteChild(String type, int value) {
            // Must call parent constructor
            super(type);
            this.value = value;
            System.out.println("ConcreteChild constructor: value=" + value);
        }
        
        @Override
        public void performAction() {
            System.out.println("ConcreteChild performing action with value: " + value);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== Constructor Inheritance Demonstration ===\n");
        
        System.out.println("=== Simple Inheritance Chain ===");
        System.out.println("\nCreating C object with parameters:");
        C c1 = new C("Test", 42, 3.14, true);
        
        System.out.println("\nCreating C object with default constructor:");
        C c2 = new C();
        
        System.out.println("\n=== Constructor with No Default Parent ===");
        ChildMustCallSuper child = new ChildMustCallSuper(10, 20);
        
        System.out.println("\n=== Abstract Class Constructor ===");
        ConcreteChild concrete = new ConcreteChild("CustomType", 100);
        concrete.performAction();
        concrete.displayType();
        
        System.out.println("\n=== Factory Pattern (Private Constructor) ===");
        PrivateConstructor p1 = PrivateConstructor.createInstance();
        PrivateConstructor p2 = PrivateConstructor.createInstance();
        
        System.out.println("\n=== Constructor Execution Order ===");
        System.out.println("When creating new C(\"Test\", 42, 3.14, true):");
        System.out.println("1. Object() constructor (implicit)");
        System.out.println("2. A(String, int) constructor");
        System.out.println("3. B(String, int, double) constructor");
        System.out.println("4. C(...) constructor");
        
        System.out.println("\n=== Key Rules Demonstrated ===");
        System.out.println("1. Constructors execute from top to bottom (parent to child)");
        System.out.println("2. super() must be first statement in constructor");
        System.out.println("3. If no constructor is defined, compiler adds default");
        System.out.println("4. If parent has no default constructor, child MUST call super()");
        System.out.println("5. Cannot use both this() and super() in same constructor");
        System.out.println("6. Abstract classes can have constructors");
        System.out.println("7. Final classes cannot be extended");
        System.out.println("8. Private constructors prevent inheritance");
        
        System.out.println("\n=== Common Issues and Solutions ===");
        System.out.println("Problem: 'constructor X in class Y cannot be applied to given types'");
        System.out.println("Solution: Call correct parent constructor with super(...)");
        
        System.out.println("\nProblem: 'constructor call must be first statement'");
        System.out.println("Solution: Move super() or this() to beginning of constructor");
        
        System.out.println("\nProblem: 'class Z has private constructor'");
        System.out.println("Solution: Use factory method or change constructor visibility");
        
        System.out.println("\n=== Best Practices ===");
        System.out.println("1. Provide default constructors in base classes");
        System.out.println("2. Use super() explicitly for clarity");
        System.out.println("3. Document constructor requirements");
        System.out.println("4. Consider making classes final if not designed for extension");
        System.out.println("5. Use factory methods for complex object creation");
    }
}

public class InheritanceChecklist {
    
    public static void inheritanceChecklist() {
        System.out.println("=== Inheritance Implementation Checklist ===\n");
        
        System.out.println("✅ 1. IS-A Relationship Check");
        System.out.println("   - Does Subclass IS-A Superclass?");
        System.out.println("   - Example: Dog IS-A Animal (YES)");
        System.out.println("   - Example: Engine IS-A Car (NO - use composition)");
        
        System.out.println("\n✅ 2. Liskov Substitution Principle");
        System.out.println("   - Can subclass replace superclass without issues?");
        System.out.println("   - No strengthened preconditions");
        System.out.println("   - No weakened postconditions");
        System.out.println("   - Preserves invariants");
        
        System.out.println("\n✅ 3. Constructor Design");
        System.out.println("   - Does parent have appropriate constructors?");
        System.out.println("   - Are super() calls correct?");
        System.out.println("   - Consider making classes final if not for extension");
        
        System.out.println("\n✅ 4. Access Modifier Review");
        System.out.println("   - Use private for implementation details");
        System.out.println("   - Use protected only for intended extension points");
        System.out.println("   - Public methods define the API");
        
        System.out.println("\n✅ 5. Method Overriding");
        System.out.println("   - Use @Override annotation");
        System.out.println("   - Maintain method contracts");
        System.out.println("   - Call super.method() when extending behavior");
        
        System.out.println("\n✅ 6. Testing Considerations");
        System.out.println("   - Test subclasses independently");
        System.out.println("   - Test polymorphic behavior");
        System.out.println("   - Test edge cases in inheritance chain");
        
        System.out.println("\n✅ 7. Documentation");
        System.out.println("   - Document extension points");
        System.out.println("   - Note any restrictions or requirements");
        System.out.println("   - Provide examples of proper usage");
    }
    
    // Example: Proper inheritance design
    abstract class Notification {
        protected String recipient;
        protected String message;
        
        public Notification(String recipient, String message) {
            this.recipient = recipient;
            this.message = message;
        }
        
        // Template method pattern
        public final void send() {
            validate();
            prepare();
            deliver();
            log();
        }
        
        protected void validate() {
            if (recipient == null || recipient.isEmpty()) {
                throw new IllegalArgumentException("Recipient is required");
            }
            if (message == null || message.isEmpty()) {
                throw new IllegalArgumentException("Message is required");
            }
        }
        
        protected void prepare() {
            System.out.println("Preparing notification for: " + recipient);
        }
        
        // Abstract method - subclasses must implement
        protected abstract void deliver();
        
        protected void log() {
            System.out.println("Notification logged: " + getClass().getSimpleName());
        }
        
        // Factory method
        public static Notification createEmail(String recipient, String message) {
            return new EmailNotification(recipient, message);
        }
    }
    
    static class EmailNotification extends Notification {
        public EmailNotification(String recipient, String message) {
            super(recipient, message);
        }
        
        @Override
        protected void deliver() {
            System.out.println("Sending email to: " + recipient);
            System.out.println("Message: " + message);
        }
        
        @Override
        protected void prepare() {
            super.prepare();
            System.out.println("Setting up SMTP connection");
        }
    }
    
    static class SMSNotification extends Notification {
        public SMSNotification(String recipient, String message) {
            super(recipient, message);
        }
        
        @Override
        protected void deliver() {
            System.out.println("Sending SMS to: " + recipient);
            System.out.println("Message: " + (message.length() > 160 ? message.substring(0, 160) : message));
        }
    }
    
    static class PushNotification extends Notification {
        private String deviceId;
        
        public PushNotification(String recipient, String message, String deviceId) {
            super(recipient, message);
            this.deviceId = deviceId;
        }
        
        @Override
        protected void validate() {
            super.validate();
            if (deviceId == null || deviceId.isEmpty()) {
                throw new IllegalArgumentException("Device ID is required for push notifications");
            }
        }
        
        @Override
        protected void deliver() {
            System.out.println("Sending push to device: " + deviceId);
            System.out.println("Title: " + recipient);
            System.out.println("Body: " + message);
        }
    }
    
    public static void main(String[] args) {
        inheritanceChecklist();
        
        System.out.println("\n=== Example: Well-Designed Inheritance ===");
        
        Notification[] notifications = {
            Notification.createEmail("user@example.com", "Welcome to our service!"),
            new SMSNotification("+1234567890", "Your verification code is 123456"),
            new PushNotification("App Update", "New version available", "device-abc123")
        };
        
        System.out.println("\n=== Sending All Notifications ===");
        for (Notification notification : notifications) {
            try {
                notification.send();
                System.out.println();
            } catch (Exception e) {
                System.out.println("Failed to send: " + e.getMessage());
            }
        }
        
        System.out.println("=== Key Design Principles Demonstrated ===");
        System.out.println("1. Template Method: send() defines algorithm skeleton");
        System.out.println("2. Liskov Substitution: All notifications are substitutable");
        System.out.println("3. Open/Closed: Easy to add new notification types");
        System.out.println("4. Single Responsibility: Each class has one purpose");
        System.out.println("5. Factory Method: createEmail() for object creation");
        
        System.out.println("\n=== When to Use Inheritance ===");
        System.out.println("✅ Modeling IS-A relationships");
        System.out.println("✅ Framework extension points");
        System.out.println("✅ Template method pattern");
        System.out.println("✅ When polymorphism is needed");
        
        System.out.println("\n=== When to Avoid Inheritance ===");
        System.out.println("❌ Just for code reuse (use composition)");
        System.out.println("❌ When relationship is HAS-A, not IS-A");
        System.out.println("❌ When you need multiple inheritance (use interfaces)");
        System.out.println("❌ When classes might change independently");
        
        System.out.println("\n=== Final Recommendations ===");
        System.out.println("1. Start with interfaces for maximum flexibility");
        System.out.println("2. Use abstract classes for shared implementation");
        System.out.println("3. Keep inheritance hierarchies shallow");
        System.out.println("4. Document for extension, design for restriction");
        System.out.println("5. Test inheritance relationships thoroughly");
    }
}