泛型、接口、抽象类

• 掌握抽象类与抽象方法的定义

• 理解接口的定义与实现

• 掌握泛型的基本使用

核心讲解

（1）抽象类

用abstract修饰的类，不能实例化，用来当父类模板。

• 可以有抽象方法（只有声明，没有实现）

• 也可以有普通方法和属性

• 子类继承抽象类，必须实现所有抽象方法，不然子类也是抽象类

（2）接口

比抽象类更抽象，只有行为规范，没有属性和实现。

• 关键字：interface

• 里面都是 public abstract 方法（默认）

• 类用implements实现接口，必须实现所有方法

• 一个类可以实现多个接口，弥补单继承的不足

• Java 8 + 可以有默认方法 default

（3）泛型

参数化类型，把类型当参数传，一套代码支持多种类型，安全又复用。

• 类泛型：class 类名<T>

• 方法泛型：public <T> T 方法名()

• 常用标识：E 元素、T 类型、K 键、V 值

代码示例

// ===== 抽象类 =====
abstract class Shape {
    String name;

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

    // 抽象方法：求面积
    public abstract double getArea();

    // 普通方法
    public void printName() {
        System.out.println("图形：" + name);
    }
}

// 实现类：圆形
class Circle extends Shape {
    double radius;

    public Circle(double radius) {
        super("圆形");
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

// ===== 接口 =====
interface Flyable {
    void fly(); // 默认public abstract
}

interface Swimmable {
    void swim();
}

// 实现多个接口
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子飞");
    }

    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }
}

// ===== 泛型 =====
// 泛型类
class Box<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

public class AdvancedDemo {
    public static void main(String[] args) {
        // 抽象类多态
        Shape s = new Circle(5);
        s.printName();
        System.out.println("面积：" + s.getArea());

        // 接口
        Duck duck = new Duck();
        duck.fly();
        duck.swim();

        // 泛型
        Box<String> strBox = new Box<>();
        strBox.setData("hello");
        System.out.println("泛型字符串：" + strBox.getData());

        Box<Integer> intBox = new Box<>();
        intBox.setData(123);
        System.out.println("泛型整数：" + intBox.getData());
    }
}

常见误区

1. 抽象类能 new：抽象类不能实例化，只能 new 它的实现子类

2. 接口方法写 private：接口方法默认都是 public，实现的时候也必须是 public

3. 泛型用基本类型：泛型只能用引用类型，不能用 int，要用 Integer

4. 接口里定义属性：接口只能定义常量，不能定义普通属性

课后练习

1. 定义一个动物抽象类，有吃、睡抽象方法

2. 定义跑、跳两个接口

3. 写一个兔子类，继承动物，实现跑、跳接口

4. 写一个泛型工具类，实现两个元素的交换