java的继承

在 Java 中，多态、抽象类和继承是面向对象编程的核心概念。让我们分别来看它们的作用和相互关系：

1. 继承 (Inheritance)

继承允许一个类从另一个类获取属性和方法，从而实现代码复用和功能扩展。继承是“is-a”关系，例如，“猫是动物”。

• 父类 (Super Class): 提供被继承的通用功能。
• 子类 (Sub Class): 继承父类的属性和方法，且可以添加自己的特有功能，也可以重写父类的方法。

class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

2. 多态 (Polymorphism)

多态是指在父类引用中调用子类的对象方法。它可以让一个对象在不同情况下表现出不同的行为。

• 编译时多态 (Compile-time Polymorphism): 通过方法重载实现（同名方法，参数不同）。
• 运行时多态 (Runtime Polymorphism): 通过方法重写实现（父类和子类有相同方法签名，但子类有不同实现）。

例如：

Animal animal = new Dog();
animal.makeSound(); // 输出: Bark

这里的 animal 是 Animal 类型，但实际引用的是 Dog 对象，因此调用的是 Dog 类的 makeSound 方法。

3. 抽象类 (Abstract Class)

抽象类是不能直接实例化的类，它定义了子类必须实现的一些抽象方法，但也可以包含具体的方法实现。抽象类用于定义一组通用的行为，具体实现则由子类来完成。

• 抽象方法: 仅声明，不提供具体实现，由子类去实现。
• 普通方法: 在抽象类中可以有普通方法的实现。

abstract class Animal {
    // 抽象方法，没有实现
    public abstract void makeSound();

    // 普通方法
    public void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

关键点：

• 抽象类可以包含抽象方法和具体方法，而接口只能有抽象方法（Java 8+ 接口支持默认方法和静态方法）。
• 继承支持代码复用，多态提供了灵活性，抽象类提供了模板式设计。

下表展示了 继承、多态 和 抽象类 在 Java 中的关系及其区别：

关系总结：

1. 继承 是多态和抽象类的基础，子类通过继承父类获得属性和方法。
2. 多态 依赖于继承，父类引用可以指向子类对象，调用子类重写的方法。
3. 抽象类 利用继承，提供了一个模板，子类必须实现抽象类的抽象方法，且可以复用抽象类的具体方法。

通过继承，Java 实现了多态和抽象类的设计思想，增强了代码的灵活性和可维护性。

好的！我会更简化一点，直接用简单的比喻和代码例子来帮助你理解 接口实现、继承、抽象类 和 多态。

1. 继承 —— 父母和孩子

继承就像“父母和孩子”之间的关系，孩子从父母那里继承一些特点。

class Parent {  // 父类
    void speak() {
        System.out.println("I am a parent.");
    }
}

class Child extends Parent {  // 子类继承父类
    @Override
    void speak() {
        System.out.println("I am a child.");
    }
}

Parent p = new Child();  // 父类引用指向子类
p.speak();  // 输出: I am a child

解释：Child 类继承了 Parent 类，可以重写父类的 speak 方法，表示孩子有自己的方式表达自己。

2. 接口 —— 规则

接口就像“大家必须遵守的规则”，但每个人可以用自己的方式去实现规则。

interface Animal {  // 定义一个规则
    void makeSound();  // 每个动物都必须有叫声
}

class Dog implements Animal {  // 狗实现这个规则
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {  // 猫也实现这个规则
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

Animal a = new Dog();  // 接口引用指向狗
a.makeSound();  // 输出: Bark

解释：Dog 和 Cat 都遵守 Animal 接口的规则，它们必须实现 makeSound，但它们可以用自己的方式发出声音。

3. 抽象类 —— 设计蓝图

抽象类就像“设计蓝图”，它规定了一些功能，但具体的细节需要由子类去完成。

abstract class Vehicle {  // 车辆的抽象类
    abstract void move();  // 抽象方法，具体怎么移动由子类决定

    void stop() {  // 普通方法
        System.out.println("The vehicle stops.");
    }
}

class Car extends Vehicle {  // 汽车类继承了车辆
    @Override
    void move() {
        System.out.println("The car is moving.");
    }
}

Vehicle v = new Car();
v.move();  // 输出: The car is moving
v.stop();  // 输出: The vehicle stops

解释：Vehicle 是一个抽象类，定义了车辆的基本行为。Car 作为具体的车辆实现了移动的方式，但抽象类也提供了共通的 stop 功能。

4. 多态 —— 同一指令，表现不同

多态就像给不同的动物同样的指令（叫声），但它们会用自己的方式来表现。

class Parent {
    void speak() {
        System.out.println("Parent is speaking.");
    }
}

class Child extends Parent {
    @Override
    void speak() {
        System.out.println("Child is speaking.");
    }
}

Parent p = new Child();  // 父类引用指向子类
p.speak();  // 输出: Child is speaking

解释：虽然我们用 Parent 类型的变量 p，但它指向的是 Child 对象，因此调用的是 Child 的 speak 方法。这就是 多态，同一个方法名 speak()，不同的表现。

总结：

• 继承：子类从父类继承属性和方法，像孩子从父母继承特点。
• 接口：定义规则，每个类用自己的方式实现，像不同动物有不同叫声。
• 抽象类：提供蓝图，具体细节由子类去实现，像设计出一种类型的车辆，具体怎么移动由具体车辆决定。
• 多态：同样的指令，表现不同，像让不同的动物发出声音，它们发出的声音各不相同。

在 Java 中，接口和类的继承、多态、抽象类都是面向对象编程的核心概念，但它们各自有不同的作用和特点。下面通过对比表格的方式来展示它们之间的关系和区别：

详细对比与区别

1. 接口 vs. 抽象类:

   • 接口：

     • 只能声明方法，没有具体实现（除非使用 Java 8+ 的默认方法）。
       - 支持多实现，一个类可以实现多个接口。
     • 主要是定义行为，不能包含实例字段（Java 8+ 支持默认方法和静态方法）。

   • 抽象类：

     • 可以有抽象方法（不提供实现）和具体方法（带有实现）。
     • 只能单继承，一个类只能继承一个抽象类。
     • 可以包含字段、构造方法和一些通用的实现。

2. 继承 vs. 接口:

   • 继承是为了复用代码。子类继承父类的属性和方法，可以重写父类的方法来实现多态。
   • 接口是一种行为契约，它规定了实现类必须提供的方法，但接口不提供实现细节。一个类可以实现多个接口，适合多重继承场景。

3. 继承 vs. 多态:

   • 继承是多态的前提。多态依赖于类继承或接口实现。
   • 多态提供了灵活性，允许父类或接口的引用指向子类或实现类对象，并调用子类或实现类的重写方法，从而表现不同的行为。

示例代码

接口：

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

抽象类：

abstract class Animal {
    public abstract void makeSound();  // 抽象方法

    public void sleep() {  // 具体方法
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

继承和多态：

Animal animal = new Dog();  // 父类引用指向子类对象
animal.makeSound();  // 输出: Bark (运行时多态)

总结

• 接口 用于定义类必须实现的行为，它更关注“做什么”，适合多重继承的场景。
• 继承 是复用代码的基础，提供了is-a关系，关注“是什么”。
• 抽象类 结合了接口的行为契约和继承的代码复用，允许部分实现和子类扩展。
• 多态 提供了灵活性，允许父类或接口的引用指向不同的子类或实现类，调用不同的实现方法。