一、抽象类 (Abstract Class)

1.1 核心特性

• 不能被实例化：只能通过子类继承使用
• 可包含抽象方法：用abstract声明，无方法体
• 可包含具体方法：已实现的方法
• 可包含成员变量：可以是常量或变量

1.2 使用场景

• 定义多个子类的共同模板
• 需要部分方法实现，部分方法延迟到子类实现

1.3 代码示例

// 抽象类定义
abstract class Animal {
    // 抽象方法（无实现）
    public abstract void makeSound();
    
    // 具体方法（有实现）
    public void breathe() {
        System.out.println("呼吸空气");
    }
}

// 子类继承
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪！");
    }
}

// 使用示例
Animal myDog = new Dog();
myDog.makeSound(); // 输出：汪汪！
myDog.breathe();   // 输出：呼吸空气

1.4 注意事项

• 抽象类可以有构造方法（供子类调用）
• 包含抽象方法的类必须是抽象类
• 子类必须实现所有抽象方法，否则子类也需声明为abstract

二、接口 (Interface)

2.1 核心特性

• 完全抽象（Java 8前）：所有方法默认public abstract
• 可包含默认方法（Java 8+）：用default关键字
• 可包含静态方法（Java 8+）：直接通过接口调用
• 成员变量默认public static final：即常量

2.2 使用场景

• 定义多个类需要遵守的行为契约
• 实现多重继承（java只能单继承，但是可以一个类可实现多个接口，间接多继承）

2.3 代码示例

// 接口定义
interface Flyable {
    // 抽象方法（默认public abstract）
    void fly();
    
    // 默认方法（Java 8+）
    default void emergencyLanding() {
        System.out.println("紧急降落！");
    }
    
    // 静态方法（Java 8+）
    static int maxSpeed() {
        return 2000;
    }
}

// 实现接口
class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("飞机引擎启动");
    }
}

// 使用示例
Airplane a380 = new Airplane();
a380.fly();                // 输出：飞机引擎启动
a380.emergencyLanding();   // 输出：紧急降落！
System.out.println(Flyable.maxSpeed()); // 输出：2000

2.4 接口 vs 抽象类

三、内部类 (Inner Class)

3.1 四种类型

① 成员内部类 (Member Inner Class)

class Outer {
    private int x = 10;
    
    class Inner {
        void display() {
            System.out.println("访问外部类x：" + x); // 直接访问私有成员
        }
    }
}

// 使用示例
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();

② 静态嵌套类 (Static Nested Class)

class Outer {
    static class StaticNested {
        void show() {
            System.out.println("静态嵌套类");
        }
    }
}

// 使用示例
Outer.StaticNested nested = new Outer.StaticNested();
nested.show();

③ 局部内部类 (Local Inner Class)

class Outer {
    void method() {
        class Local {
            void print() {
                System.out.println("局部内部类");
            }
        }
        Local local = new Local();
        local.print();
    }
}

④ 匿名内部类 (Anonymous Inner Class)

interface Greeting {
    void greet();
}

class Demo {
    void sayHello() {
        // 匿名内部类实现接口
        Greeting g = new Greeting() {
            @Override
            public void greet() {
                System.out.println("你好，世界！");
            }
        };
        g.greet();
    }
}

3.2 使用场景

• 成员内部类：需要访问外部类私有成员时
• 静态嵌套类：与外部类关联但不需要访问实例变量
• 局部内部类：仅在某个方法内使用的类
• 匿名内部类：一次性使用的简单实现（如事件监听）

四、综合对比

抽象类 vs 接口 vs 内部类

五、实战案例

5.1 抽象类与接口结合使用

// 抽象类
abstract class ElectronicDevice {
    abstract void startup();
    abstract void shutdown();
}

// 接口
interface Rechargeable {
    void charge();
}

// 子类实现
class Laptop extends ElectronicDevice implements Rechargeable {
    @Override
    void startup() {
        System.out.println("笔记本开机");
    }

    @Override
    void shutdown() {
        System.out.println("笔记本关机");
    }

    @Override
    public void charge() {
        System.out.println("Type-C充电中");
    }
}

5.2 复杂内部类应用

// 外部类
class Computer {
    private String model = "Alienware";
    
    // 成员内部类
    class CPU {
        void process() {
            System.out.println(model + "的CPU运行中"); // 访问外部类私有属性
        }
    }
    
    // 静态嵌套类
    static class RAM {
        void show() {
            System.out.println("内存容量16GB");
        }
    }
}

// 使用示例
Computer pc = new Computer();
Computer.CPU cpu = pc.new CPU(); 
cpu.process(); // 输出：Alienware的CPU运行中

Computer.RAM ram = new Computer.RAM();
ram.show();     // 输出：内存容量16GB

六、常见问题解答

Q1：什么时候用抽象类？什么时候用接口？

• 用抽象类：多个相关类共享代码，需要定义非public修饰的成员
• 用接口：定义不相关类的共同行为，需要多继承特性

Q2：内部类会生成独立的.class文件吗？

• 成员内部类：Outer$Inner.class
• 匿名内部类：Outer$1.class（数字递增）

Q3：Java 8接口的默认方法有什么作用？

• 允许接口添加新方法而不破坏现有实现类
• 例如：List接口添加的sort()方法

通过以下练习巩固知识：

1. 创建抽象类Shape，子类Circle和Rectangle实现calculateArea()
2. 设计接口Drawable包含draw()方法，让多个类实现
3. 在Library类中创建Book成员内部类，管理书籍信息