Java 继承与多态超详细梳理

Java 继承与多态超详细梳理攻略

一、继承的概念和实现

1.1 什么是继承？

继承是一种创建新类的方式，通过继承已经存在的类来创建新的类。被继承的类成为父类（或超类、基类），新创建的类称为子类（或派生类、衍生类）。

1.2 继承的实现

Java中继承使用 extends 关键字实现，子类可以继承父类的属性和方法。

// Animal 类作为父类
public class Animal {
    private String name;

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

    // 实例方法
    public void eat(){
        System.out.println(name + " 正在吃东西。");
    }
}

// Dog 类作为子类，继承了 Animal 类
public class Dog extends Animal {
    public Dog(String name){
        super(name);
    }

    // 重写了Animal类的方法eat()
    @Override
    public void eat(){
        System.out.println("狗狗" + name + " 在吃狗粮。");
    }
}

1.3 方法重写

子类可以重写其父类的方法，实现多态。当将子类对象赋值给父类引用时，会根据其运行时的实际类型调用相应的方法。这就是动态方法分派（也称运行时绑定、动态绑定）。

Animal animal = new Dog("小黄");
animal.eat();   // 狗狗小黄 在吃狗粮。

二、多态的概念和实现

2.1 什么是多态？

多态是面向对象编程中的一个基本概念，描述的是不同对象通过相同的方法调用产生不同的结果。多态可以提高代码的灵活性和可扩展性。

2.2 多态的实现

多态可以通过继承和方法重写实现，也可以通过接口实现，即接口多态。

// 接口定义
public interface Jumping {
    void jump();
}

// Cat 类实现 Jumping 接口
public class Cat implements Jumping {
    @Override
    public void jump() {
        System.out.println("猫猫跳了起来。");
    }
}

// Person 类也实现 Jumping 接口
public class Person implements Jumping {
    @Override
    public void jump() {
        System.out.println("小明跳了起来。");
    }
}

2.3 方法重载和方法重写

方法重载指的是同一类中可以有多个方法名相同但参数列表不同的方法；

方法重写指的是子类重写父类的方法，方法名相同、参数列表相同或兼容。需要注意的是，被重写的方法必须是父类中的实例方法，不能是静态方法和final方法。

三、示例说明

3.1 示例1

定义一个 Animal 类，包含 name 属性和 eat() 方法。

public class Animal {
    private String name;

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

    public void eat(){
        System.out.println(name + " 正在吃东西。");
    }
}

定义一个 Dog 类，继承 Animal 类，重写 eat() 方法。

public class Dog extends Animal {
    public Dog(String name){
        super(name);
    }

    @Override
    public void eat(){
        System.out.println("狗狗" + name + " 在吃狗粮。");
    }
}

在 Main 方法中使用多态，将 Dog 类的对象用 Animal 类型的引用 a 进行接收，然后调用 eat() 方法。

Animal a = new Dog("小黄");
a.eat();    // 狗狗小黄 在吃狗粮。

3.2 示例2

定义一个 Jumping 接口，包含 jump() 方法。

public interface Jumping {
    void jump();
}

定义一个 Cat 类和一个 Person 类，实现 Jumping 接口，然后重写 jump() 方法。

public class Cat implements Jumping {
    @Override
    public void jump() {
        System.out.println("猫猫跳了起来。");
    }
}

public class Person implements Jumping {
    @Override
    public void jump() {
        System.out.println("小明跳了起来。");
    }
}

在 Main 方法中使用多态，将 Cat 和 Person 类的对象用 Jumping 类型的引用 j 进行接收，然后调用 jump() 方法。

Jumping j = new Cat();
j.jump();    // 猫猫跳了起来。

j = new Person();
j.jump();    // 小明跳了起来。

以上是 Java 继承与多态的超详细梳理攻略，希望能对大家有所启发。