Confusion for Java Beginners: The Magical Uses of Inheritance and Polymorphism

Inheritance allows new classes to be created, inheriting fields and methods from existing classes, and polymorphism allows objects to be processed in different ways depending on their type. Inheritance creates a hierarchy of classes, and polymorphism enables code to work with multiple types of objects. In an animal shelter management system, inheritance can be used to create animal classes, and polymorphism can be used to handle common characteristics and differences between different types of animals, such as by making sounds.

Confusion for Java Beginners: The Magical Uses of Inheritance and Polymorphism

Inheritance and polymorphism are the basic concepts of object-oriented programming , it can sometimes be difficult for beginners to understand them. This article aims to elaborate on these two concepts through a practical case.

Inheritance

Inheritance is a mechanism for creating a new class that inherits fields and methods from an existing class. It enables us to reuse code and create a hierarchy of classes.

// 父类
class Shape {
    protected double length, width;

    public Shape(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getArea() {
        return length * width;
    }
}

// 子类
class Rectangle extends Shape {
    public Rectangle(double length, double width) {
        super(length, width);
    }

    @Override
    public double getArea() {
        return length * width;
    }
}

In this example, the Rectangle class inherits from the Shape class. The Rectangle class reuses the fields and getArea() method from the Shape class and defines a constructor of its own.

Polymorphism

Polymorphism means that objects can be processed in different ways, depending on their type. It allows us to write code that works with multiple types of objects without having to explicitly check the object type.

Shape shape = new Rectangle(4, 5);
System.out.println(shape.getArea()); // 输出：20.0

Shape shape2 = new Circle(3.14);
System.out.println(shape2.getArea()); // 输出：30.159265358979323

In this case, both the shape and shape2 variables refer to objects of type Shape, but they actually point to different sub- Class objects (Rectangle and Circle). Due to polymorphism, we are able to call the getArea() method without knowing the specific type of the object.

Practical Case

Inheritance and polymorphism are particularly suitable for creating scalable and reusable code. For example, consider an animal shelter management system:

// Animal 类包含动物的共同特征
abstract class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void speak();
}

// Dog 类继承 Animal 类
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

// Cat 类继承 Animal 类
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

Each animal can make a sound through the speak() method. Due to the polymorphic nature, we can easily put different animal objects into a list, then iterate through the list and make each animal make a sound.

List<Animal> animals = new ArrayList<>();
animals.add(new Dog("Rex", 5));
animals.add(new Cat("Fluffy", 2));

for (Animal animal : animals) {
    animal.speak();
}

Output:

Woof!
Meow!

Through inheritance and polymorphism, we can create flexible and extensible code that can handle common characteristics between different types of objects and difference.

The above is the detailed content of Confusion for Java Beginners: The Magical Uses of Inheritance and Polymorphism. For more information, please follow other related articles on the PHP Chinese website!