Java继承机制「详解」

林上奇数

已于 2023-06-12 20:40:10 修改

阅读量957

点赞数 6

文章标签： java 学习开发语言

于 2023-06-12 20:33:10 首次发布

本文链接：https://blog.csdn.net/weixin_56433857/article/details/131176416

版权

前言:在生活中,我们常会羡慕身边的“高手”。比如羽毛球高手轻松接下别人的杀手锏，乒乓球高手胶着情况下“神来之笔”打出妙球。这都是因为高手具备我们没有的技能。那么，在Java世界，我们的类也可以通过“继承”这种手段来解锁新的能力，成为一个高手类。

继承的定义

首先，让我们从继承的定义开始吧。继承是一种能力，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。这意味着子类可以使用父类的方法和属性，同时还可以添加自己的方法和属性。这种 is-a 关系，帮助子类拥有父类的 “能力”。

那么，为什么要使用继承呢？这其实很简单，使用继承可以帮助我们减少代码的重复，提高代码的可复用性。如果我们需要创建一个新的类，它和现有的类有很多相同的属性和方法，那么我们可以继承现有的类，从而避免重复编写相同的代码。

接下来，让我们来看一下Java中的继承是如何工作的。在Java中，我们使用关键字“extends”来实现继承。

public class ChildClass extends ParentClass {
   // ...
}

下面是一个继承的例子：

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

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

在这个例子中，我们创建了一个Animal类和一个Dog类。Dog类继承了Animal类，因此它可以使用Animal类中的方法。在Dog类中，我们还添加了一个新的方法bark()。

现在，我们可以创建一个实例来测试一下这个例子：

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出 "Animal is eating"
        dog.bark(); // 输出 "Dog is barking"
    }
}

在这个例子中，我们创建了一个Dog对象，并调用了它的eat()和bark()方法。由于Dog类继承了Animal类，因此它可以使用Animal类中的eat()方法。

继承的特性

子类访问父类

首先，子类可以访问父类的所有非私有属性和方法。这包括父类的公有属性和方法、受保护的属性和方法以及默认属性和方法（即没有访问修饰符的属性和方法）。但是，子类不能访问父类的私有属性和方法。

举个例子，假设我们有一个父类叫做Vehicle，其中包含了一些属性和方法：

public class Vehicle {
    public String brand;
    protected int maxSpeed;
    private int price;

    public void run() {
        System.out.println("Vehicle is running");
    }

    protected void stop() {
        System.out.println("Vehicle is stopping");
    }

    private void startEngine() {
        System.out.println("Engine is starting");
    }
}

在这个例子中，Vehicle类包含了三个属性：brand、maxSpeed和price。它还包含了三个方法：run()、stop()和startEngine()。其中，run()和stop()方法是公有的，而startEngine()方法是私有的。

然后我们可以创建一个子类Car，它继承了Vehicle类：

public class Car extends Vehicle {
    public String color;

    public void drive() {
        System.out.println("Car is driving");
    }
}

在这个例子中，Car类继承了Vehicle类，并且添加了一个新的属性color和一个新的方法drive()。

由于Car类继承了Vehicle类，因此它可以访问Vehicle类中的所有非私有属性和方法。这包括brand、maxSpeed、run()和stop()方法。因此，我们可以在Car类中使用这些属性和方法：

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.brand = "Toyota";
        car.maxSpeed = 200;
        car.run();
        car.stop();
        car.drive();
    }
}

子类重写父类

此外，子类还可以重写父类的方法，也就是说，在子类中定义一个和父类中同名的方法。当子类调用这个方法时，它会覆盖父类中的方法。这种行为称为方法重写。
假设我们有一个父类叫做Animal，其中包含了一个方法eat()：

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

现在，我们可以创建一个子类Dog，它继承了Animal类，并且重写了eat()方法：

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

在这个例子中，Dog类继承了Animal类，并且使用@Override注解重写了eat()方法。这意味着，当我们在Dog类中调用eat()方法时，它会覆盖父类Animal中的eat()方法，并输出“Dog is eating”。

下面是一个测试代码：

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat(); // 输出 "Animal is eating"

        Dog dog = new Dog();
        dog.eat(); // 输出 "Dog is eating"
    }
}

在这个测试代码中，我们分别创建了一个Animal对象和一个Dog对象，并调用它们的eat()方法。由于Dog类重写了eat()方法，因此当我们调用Dog对象的eat()方法时，它会输出“Dog is eating”，而不是Animal类中的“Animal is eating”。

调用构造函数

最后，子类可以调用父类的构造函数。我们可以使用关键字“super”来调用父类的构造函数。这通常在子类中定义自己的构造函数时使用。

public class Animal {
    public Animal(int age) {
        this.age = age;
    }
}

public class Dog extends Animal {
    public Dog(int age) {
        super(age);
    }
}