Advanced Java · Week 4

Inheritance

Step 1 of 8

Java 2 Guided Tutorials - Week 4: Inheritance

What You'll Learn

Welcome to Week 4 of Java 2! This week, we'll explore inheritance, a fundamental concept in object-oriented programming. Inheritance allows us to create new classes based on existing classes, promoting code reuse and establishing a hierarchy among classes.

                    Lesson Overview:
                    Understanding Inheritance
Types of Inheritance in Java
The 'extends' Keyword
Method Overriding
The 'super' Keyword
Quiz to test your knowledge
Weekly project to apply what you've learned

                

By the end of this week, you'll have a solid understanding of inheritance and how to use it effectively in your Java programs. Let's get started!

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.

                    Key Points:
                    Inheritance promotes code reuse
It establishes an "is-a" relationship between classes
The class being inherited from is called the superclass or parent class
The class that inherits is called the subclass or child class

                

Here's a simple example of inheritance:

// 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
    }
}

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

Write your code here

Make it print This animal eats food The dog barks

Did it work?

Your program should print this:

This animal eats food
The dog barks

Paste what you got:

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.

                    Types of Inheritance in Java:
                    Single Inheritance: A class inherits from one superclass
Multilevel Inheritance: A class inherits from a class, which in turn inherits from another class
Hierarchical Inheritance: Multiple classes inherit from a single superclass
Multiple Inheritance: Not supported directly for classes, but can be achieved using interfaces

                

Here's an example demonstrating multilevel inheritance:

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
    }
}

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.

Write your code here

Make it print Vehicle started Car is driving Motorcycle is riding

Did it work?

Your program should print this:

Vehicle started
Car is driving
Motorcycle is riding

Paste what you got:

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.

                    Key Points:
                    The extends keyword is used in the class declaration
It indicates that the new class is inheriting from an existing class
A class can only extend one other class (single inheritance for classes)
The subclass inherits all non-private members of the superclass

                

Here's an example using the extends keyword:

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();
    }
}

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.

Write your code here

Make it print Drawing a shape Drawing a circle Drawing a square Drawing a triangle

Did it work?

Your program should print this:

Drawing a shape
Drawing a circle
Drawing a square
Drawing a triangle

Paste what you got:

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.

                    Key Points:
                    The method in the subclass must have the same name and signature as in the superclass
The @Override annotation is recommended (but not required) to indicate an overridden method
Overriding methods can't have a more restrictive access modifier
Static and final methods can't be overridden

                

Here's an example of method overriding:

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();
    }
}

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.

Write your code here

Make it print The animal makes a sound The dog barks The cat meows The cow moos

Did it work?

Your program should print this:

The animal makes a sound
The dog barks
The cat meows
The cow moos

Paste what you got:

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.

                    Uses of 'super' Keyword:
                    To call a superclass method
To access a superclass field
To invoke a superclass constructor

                

Here's an example demonstrating the use of super:

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();
    }
}

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.

Write your code here

Make it print Animal constructor called Dog constructor called Local name: Dog Superclass name: Animal Animal is eating Dog is eating

Did it work?

Your program should print this:

Animal constructor called
Dog constructor called
Local name: Dog
Superclass name: Animal
Animal is eating
Dog is eating

Paste what you got:

Quick check

1. What keyword is used to inherit from a class in Java?
2. What is the purpose of the 'super' keyword in Java?
3. Which of the following is true about method overriding?

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.

                    Requirements:
                    Create a base class called Shape with methods for calculating area and perimeter
Create subclasses for at least three different shapes (e.g., Circle, Rectangle, Triangle)
Override the area and perimeter calculation methods in each subclass
Use the super keyword to call the superclass constructor
Implement a method to display information about each shape
In the main method, create instances of different shapes and demonstrate polymorphism

                

Here's a template to get you started:

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
    }
}

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.

Write your code here

Make it print Shape: Circle Area: 78.54 Perimeter: 31.42 Shape: Rectangle Area: 24.00 Perimeter: 20.00 Shape: Triangle Area: 6.00 Perimeter: 12.00

Did it work?

Your program should print this:

Shape: Circle
Area: 78.54
Perimeter: 31.42
Shape: Rectangle
Area: 24.00
Perimeter: 20.00
Shape: Triangle
Area: 6.00
Perimeter: 12.00

Paste what you got:

PreviousEncapsulation NextPolymorphism