**Course Title:** Comprehensive Java Programming: From Basics to Advanced Concepts **Section Title:** Inheritance and Polymorphism in Java **Topic:** Understanding inheritance and the 'extends' keyword. **Table of Contents:** 1. Introduction to inheritance 2. Defining inheritance in Java 3. Understanding the 'extends' keyword 4. Inheritance hierarchy 5. Types of inheritance 6. Examples and uses of inheritance 7. Accessing inherited members 8. Constructor chaining 9. Best practices for using inheritance **Introduction to Inheritance** Inheritance is a fundamental concept in object-oriented programming (OOP) that allows one class to inherit the properties and behavior of another class. It is a way of creating a new class from an existing class, inheriting all the fields and methods of the existing class. Inheritance helps to promote code reuse, facilitate the creation of a hierarchy of related classes, and improve the modularity and maintainability of software systems. **Defining Inheritance in Java** In Java, inheritance is defined using the 'extends' keyword. The class that is inherited is called the parent class or superclass, and the class that inherits is called the child class or subclass. The subclass inherits all the fields and methods of the superclass and can also add new fields and methods or override the ones inherited from the superclass. **Understanding the 'extends' keyword** The 'extends' keyword is used to define an inheritance relationship between two classes. It is used in the subclass declaration to specify the parent class that is being inherited. For example: ```java public class Animal { // fields and methods } public class Dog extends Animal { // fields and methods } ``` In this example, the `Dog` class is inheriting the properties and behavior of the `Animal` class using the `extends` keyword. **Inheritance Hierarchy** An inheritance hierarchy is a tree-like structure that represents the relationships between classes in an inheritance hierarchy. It shows the superclass-subclass relationships between classes, with the superclass at the top and the subclass at the bottom. For example: ```java Animal | |- Mammal | | | |- Dog | |- Cat | |- Bird ``` In this example, `Animal` is the superclass, and `Mammal` and `Bird` are subclasses that inherit from `Animal`. `Dog` and `Cat` are subclasses that inherit from `Mammal`. **Types of Inheritance** There are several types of inheritance, including: * **Single inheritance**: A subclass inherits from only one superclass. * **Multiple inheritance**: A subclass inherits from multiple superclasses. (Java does not support multiple inheritance, but it can be achieved using interfaces.) * **Multilevel inheritance**: A subclass inherits from a superclass that itself inherits from another superclass. * **Hierarchical inheritance**: A superclass has multiple subclasses that inherit from it. **Examples and Uses of Inheritance** Inheritance is used in many real-world applications, such as: * Modeling a hierarchy of classes to represent a family of objects * Creating a base class for a group of related classes * Providing a way to override inherited behavior * Promoting code reuse and modularity For example, in a banking system, you could define a `BankAccount` class as the superclass, with subclasses `CheckingAccount` and `SavingsAccount` that inherit from it. ```java public class BankAccount { private double balance; public void deposit(double amount) { balance += amount; } public void withdraw(double amount) { balance -= amount; } } public class CheckingAccount extends BankAccount { private double overdraftLimit; public void setOverdraftLimit(double limit) { overdraftLimit = limit; } } public class SavingsAccount extends BankAccount { private double interestRate; public void setInterestRate(double rate) { interestRate = rate; } } ``` **Accessing Inherited Members** Inherited members can be accessed using the same syntax as in the superclass. For example: ```java public class Dog extends Animal { public void bark() { System.out.println("Woof!"); } public void eat() { super.eat(); // calls the eat() method in the Animal class } } ``` **Constructor Chaining** Constructor chaining is the process of calling one constructor from another. In inheritance, the subclass constructor calls the superclass constructor using the `super()` method. For example: ```java public class Animal { public Animal() { System.out.println("Animal constructor called"); } } public class Dog extends Animal { public Dog() { super(); // calls the Animal constructor System.out.println("Dog constructor called"); } } ``` **Best Practices for Using Inheritance** * Use inheritance to model a hierarchy of classes that share common attributes and behavior. * Avoid deep inheritance hierarchies, as they can be difficult to maintain and understand. * Use abstract classes and interfaces to define abstract concepts and relationships between classes. * Use the `super()` method to call the superclass constructor and access inherited members. By following these best practices and understanding the concepts of inheritance, you can effective use inheritance in your Java programming to promote code reuse, modularity, and maintainability. **Links to Additional Resources** * **Oracle Java Tutorials:** Inheritance [https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) * **GeeksforGeeks:** Inheritance in Java [https://www.geeksforgeeks.org/inheritance-in-java/](https://www.geeksforgeeks.org/inheritance-in-java/) **Leave a Comment/Ask for Help** We encourage you to leave a comment or ask for help if you have any questions or need further clarification on any of the concepts covered in this topic. Your feedback is greatly appreciated and will help us improve the course materials. Please use the comment section below to ask questions or provide feedback.

public class Animal {
    // fields and methods
}

public class Dog extends Animal {
    // fields and methods
}

Animal
  |
  |- Mammal
  |     |
  |     |- Dog
  |     |- Cat
  |
  |- Bird

public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        balance -= amount;
    }
}

public class CheckingAccount extends BankAccount {
    private double overdraftLimit;

    public void setOverdraftLimit(double limit) {
        overdraftLimit = limit;
    }
}

public class SavingsAccount extends BankAccount {
    private double interestRate;

    public void setInterestRate(double rate) {
        interestRate = rate;
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Woof!");
    }

    public void eat() {
        super.eat(); // calls the eat() method in the Animal class
    }
}

public class Animal {
    public Animal() {
        System.out.println("Animal constructor called");
    }
}

public class Dog extends Animal {
    public Dog() {
        super(); // calls the Animal constructor
        System.out.println("Dog constructor called");
    }
}