Inheritance

1. Understanding Inheritance

What is Inheritance?

Inheritance is a mechanism in which one class acquires the properties (methods and fields) of another. It's a way to establish a relationship between classes, where a new class is created based on an existing class.

Here's a simple example of inheritance:

<code>// Parent class
class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

// Child class
class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // Inherited method
        myDog.bark(); // Dog's own method
    }
}</code>

In this example, Dog inherits from Animal, so it can use the eat() method defined in Animal.

2. Types of Inheritance

Different Types of Inheritance

Java supports several types of inheritance, although some are achieved through interfaces rather than direct class inheritance.

Here's an example demonstrating multilevel inheritance:

<code>class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

class Mammal extends Animal {
    void breathe() {
        System.out.println("This mammal breathes air");
    }
}

class Dog extends Mammal {
    void bark() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();    // From Animal
        myDog.breathe(); // From Mammal
        myDog.bark();    // From Dog
    }
}</code>

Try creating a class hierarchy demonstrating hierarchical inheritance. Create a base class Vehicle and two subclasses Car and Motorcycle. Use the compiler to implement and test your code.

3. The 'extends' Keyword

Using 'extends' for Inheritance

In Java, we use the extends keyword to create a subclass that inherits from a superclass. This keyword establishes the inheritance relationship between two classes.

Here's an example using the extends keyword:

<code>class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square extends Shape {
    void draw() {
        System.out.println("Drawing a square");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Shape();
        Circle circle = new Circle();
        Square square = new Square();

        shape.draw();
        circle.draw();
        square.draw();
    }
}</code>

In this example, both Circle and Square extend Shape, inheriting its properties and methods. Try modifying this example by adding a new shape, like Triangle, and implement its draw() method. Use the compiler to test your code.

4. Method Overriding

Understanding Method Overriding

Method overriding is a feature that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This is a key aspect of runtime polymorphism in Java.

Here's an example of method overriding:

<code>class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal.makeSound();
        dog.makeSound();
        cat.makeSound();
    }
}</code>

In this example, both Dog and Cat override the makeSound() method from the Animal class. Try adding a new animal, like Cow, and override its makeSound() method. Use the compiler to implement and test your code.

5. The 'super' Keyword

Using the 'super' Keyword

The super keyword in Java is used to refer to the superclass (parent) of the current class. It can be used to call superclass methods, access superclass fields, and invoke superclass constructors.

Here's an example demonstrating the use of super:

<code>class Animal {
    String name = "Animal";

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

    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    String name = "Dog";

    Dog() {
        super(); // Call to superclass constructor
        System.out.println("Dog constructor called");
    }

    void printName() {
        System.out.println("Local name: " + name);
        System.out.println("Superclass name: " + super.name);
    }

    @Override
    void eat() {
        super.eat(); // Call to superclass method
        System.out.println("Dog is eating");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.printName();
        myDog.eat();
    }
}</code>

In this example, we use super to call the superclass constructor, access a superclass field, and call a superclass method. Try modifying this example by adding a new method in the Animal class and use super to call it from a method in the Dog class. Use the compiler to implement and test your code.

6. Inheritance Quiz

7. Weekly Project: Shape Hierarchy

Project Description

For this week's project, you'll create a shape hierarchy using inheritance. This will help reinforce the concepts of inheritance, method overriding, and the use of the super keyword.

Here's a template to get you started:

<code>abstract class Shape {
    String name;

    Shape(String name) {
        this.name = name;
    }

    abstract double calculateArea();
    abstract double calculatePerimeter();

    void displayInfo() {
        System.out.println("Shape: " + name);
        System.out.println("Area: " + calculateArea());
        System.out.println("Perimeter: " + calculatePerimeter());
    }
}

class Circle extends Shape {
    // Implement Circle class
}

class Rectangle extends Shape {
    // Implement Rectangle class
}

class Triangle extends Shape {
    // Implement Triangle class
}

public class Main {
    public static void main(String[] args) {
        // Create instances of different shapes
        // Call methods to demonstrate inheritance and polymorphism
    }
}</code>

Implement the missing parts of the Shape hierarchy. Create instances of different shapes, calculate their areas and perimeters, and display their information. Use the online compiler to write and test your code. Once you're satisfied with your program, paste a sample output showing the information for at least three different shapes in the autograder to check your work.