Detailed explanation of Java inheritance mechanism: the cornerstone of building object-oriented programs

The inheritance mechanism in Java allows an object to inherit all properties and behaviors of the parent object, which is the core concept of object-oriented programming (OOPs). Through inheritance, we can create a new class based on an existing class, reuse the methods and fields of the parent class, and add new methods and fields on this basis.

What is inheritance?

The Java inheritance mechanism allows one class (subclass or derived class) to inherit the properties and methods of another class (superclass or parent class). Subclasses can access members (fields and methods) of the superclass, enforcing reuse rules, and promoting class hierarchy. Inheritance embodies the "IS-A" relationship, also known as the parent-child relationship.

Why use Java inheritance?

• Code reuse: Inheritance significantly improves code reusability and avoids writing the same functional code repeatedly.
• Method rewriting (implementing runtime polymorphism): (to be added)

Terms related to inheritance

• Class: A collection of objects with common properties that is a template or blueprint for creating objects.
• Subclass/Subclass: A class that inherits from other classes, also known as a derived class, extended class or subclass.
• Super class/parent class: A class whose subclasses inherit characteristics, also called a base class or parent class.
• Reusability: A mechanism for reusing existing class fields and methods when creating new classes.

Java inheritance syntax

class 子類名稱 extends 超類名稱 {
    // 方法和字段
}

extends keyword means creating a new class derived from an existing class. "extends" means extended functionality. In Java terminology, the inherited class is called a parent class or superclass, and the new class is called a subclass or child class.

The above figure shows that Programmer is a subclass and Employee is a superclass. The relationship between the two is Programmer IS-A Employee, which means that the programmer is a kind of employee.

Example: Programmer.java

class Employee {
    float salary = 40000;
}

class Programmer extends Employee {
    int bonus = 10000;

    public static void main(String args[]) {
        Programmer p = new Programmer();
        System.out.println("程序員薪資：" + p.salary);
        System.out.println("程序員獎(jiǎng)金：" + p.bonus);
    }
}

Java inherited types

According to the inheritance relationship of classes, Java inheritance is mainly divided into three types: single inheritance, multi-layer inheritance and hierarchical inheritance.

Note: Java does not support multiple inheritance through classes.

When a class inherits from multiple classes, it is called multiple inheritance. For example: Multiple inheritance in Java

Single inheritance example

When one class inherits another class, it is called single inheritance. In the example below, the Dog class inherits from the Animal class, hence single inheritance.

TestInheritance.java

class Animal {
    void eat() {
        System.out.println("正在吃...");
    }
}

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

class TestInheritance {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.bark();
        d.eat();
    }
}

Multi-level inheritance example

When there is an inheritance chain, it is called multi-level inheritance. In the example below, the BabyDog class inherits from the Dog class, which in turn inherits from the Dog class, hence multi-level inheritance. Animal

class 子類名稱 extends 超類名稱 {
    // 方法和字段
}

Hierarchical inheritance example

When two or more classes inherit from a single class, it is called hierarchical inheritance. In the example below, both the Dog and Cat classes inherit from the Animal class, hence the hierarchical inheritance.

TestInheritance3.java

class Employee {
    float salary = 40000;
}

class Programmer extends Employee {
    int bonus = 10000;

    public static void main(String args[]) {
        Programmer p = new Programmer();
        System.out.println("程序員薪資：" + p.salary);
        System.out.println("程序員獎(jiǎng)金：" + p.bonus);
    }
}

Why doesn’t Java support multiple inheritance? (To be added)

To reduce complexity and simplify the language, Java does not support multiple inheritance through classes.

Method rewriting and method overloading

• Method overriding: A subclass provides a specific implementation of a method declared in the parent class.
• Method overloading: In the same class, the method name is the same, but the number or type of parameters are different.

final Function of keywords

final keyword is used to prevent method overriding and class extension:

• final Field: cannot be reassigned.
• final Method: Cannot be overridden.
• final Class: cannot be inherited.

Reference link: http://miracleart.cn/link/9b4192ee086949047cfc64d86d895c2e

The above is the detailed content of Inheritance. For more information, please follow other related articles on the PHP Chinese website!