💻AP Computer Science A Unit 9 – Inheritance in Object-Oriented Programming

What's the Big Idea?

• Inheritance is a fundamental concept in object-oriented programming (OOP) that allows classes to inherit properties and methods from other classes
• Enables code reuse by creating a hierarchy of classes where subclasses inherit from superclasses
• Supports the creation of specialized classes that share common attributes and behaviors with their parent classes
• Facilitates the implementation of polymorphism, allowing objects of different classes to be treated as instances of a common superclass
• Helps organize code into a logical structure, making it easier to understand, maintain, and extend

Key Concepts to Know

• Superclass (base class or parent class) contains common attributes and methods that are inherited by subclasses
• Subclass (derived class or child class) inherits properties and methods from its superclass and can add its own unique attributes and methods

• extends

  keyword is used in Java to establish an inheritance relationship between classes
• Method overriding allows subclasses to provide their own implementation of methods inherited from the superclass
  • Overridden methods must have the same name, return type, and parameter list as the method in the superclass

• super

  keyword is used to call the superclass constructor or methods from within the subclass

• final

  keyword can be used to prevent a class from being subclassed or a method from being overridden

How It Works in Java

• To create an inheritance relationship, the subclass is defined using the

  extends

  keyword followed by the name of the superclass
• Subclasses automatically inherit all non-private members (fields and methods) of the superclass
• Constructors are not inherited, but subclasses can call the superclass constructor using the

  super

  keyword
• Subclasses can add their own unique fields and methods in addition to the inherited ones
• If a subclass defines a method with the same signature as a method in the superclass, it overrides the superclass method
  • The

    @Override

    annotation can be used to indicate that a method is intended to override a superclass method
• Subclasses can use the

  super

  keyword to call the overridden method from the superclass

Coding Examples

// Superclass
class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// Subclass
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }
    
    @Override
    public void eat() {
        super.eat();
        System.out.println(name + " is a " + breed + " and is chewing its food.");
    }
    
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

Common Pitfalls

• Forgetting to use the

  extends

  keyword when creating a subclass
• Attempting to inherit from a

  final

  class, which is not allowed
• Overriding methods with incompatible return types or parameter lists
• Forgetting to call the superclass constructor using

  super

  when the superclass doesn't have a default constructor
• Accessing private members of the superclass directly from the subclass, which is not allowed
• Overusing inheritance, leading to complex and tightly coupled class hierarchies
  • Favor composition over inheritance when appropriate

Practice Problems

1. Create a

   Shape

   superclass with methods to calculate area and perimeter, and subclasses

   Rectangle

   and

   Circle

   that inherit from

   Shape

   and provide their own implementations of these methods.
2. Design a class hierarchy for a simple banking system with

   Account

   as the superclass and

   CheckingAccount

   and

   SavingsAccount

   as subclasses. Implement methods for depositing, withdrawing, and checking the account balance.
3. Develop an inheritance hierarchy for a game with

   Character

   as the superclass and

   Player

   and

   Enemy

   as subclasses. Add unique attributes and methods to each subclass.

Real-World Applications

• Graphical user interface (GUI) frameworks often use inheritance to create a hierarchy of UI components (e.g.,

  JComponent

  and its subclasses in Java Swing)
• Game engines use inheritance to define a hierarchy of game objects with shared properties and behaviors (e.g.,

  GameObject

  and its subclasses)
• Database object-relational mapping (ORM) libraries use inheritance to map class hierarchies to database tables (e.g., Hibernate in Java)
• Programming languages themselves use inheritance to define a hierarchy of exception classes (e.g.,

  Exception

  and its subclasses in Java)

Going Beyond Basics

• Multiple inheritance is not supported in Java, but interfaces can be used to achieve a form of multiple inheritance
  • A class can implement multiple interfaces, inheriting the abstract methods defined in each interface
• Abstract classes can be used to define a base class that cannot be instantiated and may contain abstract methods that subclasses must implement
  • Useful for creating a common base class for a group of related subclasses
• Inheritance can be combined with other OOP concepts like encapsulation and polymorphism to create more flexible and maintainable code
• Design patterns, such as the template method pattern and the strategy pattern, rely on inheritance to provide a structure for code reuse and customization