Java 面向对象核心：继承、多态与抽象类接口

访问权限修饰符

多态

1. Fu.java (父类)

package com.itheima.test2;
public class Fu {
    String name = "Fu";
    public void fuShow() {
        System.out.println("父类的 fuShow 方法被调用了~");
    }
    public void show() {
        System.out.println("父类的 show 方法被调用了~");
    }
}

2. Zi.java (子类)

package com.itheima.test2;
public class Zi extends Fu {
    String name = "Zi";
    // 子类独有的方法
    public void ziShow() {
        System.out.println("子类的 ziShow 方法被调用了~");
    }
    // 子类重写父类的方法
    @Override
    public void show() {
        System.out.println("子类重写的 show 方法被调用了~");
    }
}

3. Test.java (测试类)

package com.itheima.test2;
public class Test {
    public static void main(String[] args) {
        // 多态：父类引用指向子类对象
        Fu f = new Zi();
        // 1. 访问成员变量
        // 编译看左边 (Fu)，运行也看左边 (Fu) -> 输出 Fu
        System.out.println(f.name);
        // 2. 访问成员方法
        // 编译看左边 (Fu)，运行看右边 (Zi) -> 输出 子类重写的 show 方法被调用了~
        f.show();
        // 3. 访问子类特有方法
        // f.ziShow(); // ❌ 报错！因为编译时看左边 (Fu)，Fu 类里没有 ziShow 方法
    }
}

代码运行结果：

Fu 子类重写的 show 方法被调用了~

核心知识点总结（看图中的注释）：

1. 成员变量：编译看左边，运行也看左边（编译期绑定）。
   • f是 Fu 类型，所以 f.name 永远取 Fu 里的值。
2. 成员方法：编译看左边，运行看右边（运行期绑定/动态绑定）。
   • f 是 Fu 类型，编译器允许调用 Fu 里的方法。
   • 但运行时发现 f 实际上是 Zi 对象，所以执行的是 Zi 里重写的方法。
3. 子类特有方法：不能通过父类引用直接调用。
   • f.ziShow() 会报错，因为父类 Fu 不知道子类有这个方法。

因此多态是有弊端的，为了解决这个弊端可以使用类型转换。

类型转换

抽象类和抽象方法

• 抽象方法：只有方法声明，没有方法体的方法
• 抽象类：包含抽象方法的类

（1）简单代码示例

Animal.java（抽象类）

// 抽象类：有抽象方法的类必须是抽象类
public abstract class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    // 抽象方法：没有方法体，以分号结束
    public abstract void makeSound();
    // 普通方法：可以有具体实现
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

Dog.java（具体子类）

// 具体子类：必须实现父类的所有抽象方法
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    // 必须实现抽象方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫！");
    }
}

Cat.java（具体子类）

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    @Override
    public void makeSound() {
        System.out.println(name + "喵喵叫！");
    }
}

Test.java（测试类）

public class Test {
    public static void main(String[] args) {
        // ❌ 错误：抽象类不能直接创建对象
        // Animal animal = new Animal("动物");
        // ✅ 正确：创建具体子类的对象
        Animal dog = new Dog("小狗");
        Animal cat = new Cat("小猫");
        dog.eat(); // ✅ 调用普通方法
        dog.makeSound(); // ✅ 调用具体实现的抽象方法
        // 输出：小狗正在吃东西
        // 输出：小狗汪汪叫！
        cat.eat();
        cat.makeSound(); // 输出：小猫正在吃东西
        // 输出：小猫喵喵叫！
    }
}

（2）核心规则总结

抽象方法：使用 abstract 关键字没有方法体（没有 {}）以分号结束 抽象类：使用 abstract 关键字可以有抽象方法（必须用 abstract）也可以有普通方法（可以有方法体），可以有属性，可以有构造方法 子类的责任：如果一个类继承了抽象类必须实现父类的所有抽象方法或者自己也声明为抽象类 不能创建对象：抽象类不能直接 new，只能通过子类来创建对象

（3）和普通类的区别

（4）为什么要用抽象类？

• 强制规范：要求子类必须实现某些方法
• 代码复用：抽象类中的普通方法可以被所有子类共享
• 设计约束：比如'动物'都要会叫，但'狗'和'猫'叫的方式不同

（5）一句话理解抽象类：

'半成品' 或 '模板'，它定义了一部分功能，剩下的让子类去完成。

接口

（1）接口 vs 抽象类主要区别总结

（2）使用场景简单例子

一句话记住接口：接口就是'约定'或'协议'，它说：'只要你实现了我的方法，你就具备了某种能力'

比如：USB 接口约定好'连接'和'传输'两个方法，鼠标和键盘只要实现这两个方法，就能当 USB 设备用。

内部类

内部类：一个类定义在另一个类的内部

（1）例子

Outer.java（外部类）

public class Outer {
    private String outerField = "我是外部类";
    // 成员内部类：像外部类的成员一样
    class Inner {
        private String innerField = "我是内部类";
        public void show() {
            // 内部类可以直接访问外部类的私有成员
            System.out.println("访问外部类：" + outerField);
            System.out.println("访问内部类：" + innerField);
        }
    }
    public void test() {
        // 外部类创建内部类对象
        Inner inner = new Inner();
        inner.show();
    }
}

Test.java（测试类）

public class Test {
    public static void main(String[] args) {
        // 1. 先创建外部类对象
        Outer outer = new Outer();
        // 2. 通过外部类对象创建内部类对象
        Outer.Inner inner = outer.new Inner();
        inner.show(); // 或者直接调用外部类的方法
        outer.test();
    }
}

（2）四种内部类

public class FourTypes {
    private String name = "外部类";
    // 1. 成员内部类（最常用）：普通类中的普通类
    class MemberInner {
        void show() {
            System.out.println("成员内部类：" + name);
        }
    }
    // 2. 静态内部类：普通类中的静态类
    static class StaticInner {
        void show() {
            // System.out.println(name); // ❌ 不能访问外部非静态成员
            System.out.println("静态内部类");
        }
    }
    public void test() {
        // 3. 局部内部类：方法里的类
        class LocalInner {
            void show() {
                System.out.println("局部内部类：" + name);
            }
        }
        LocalInner li = new LocalInner();
        li.show();
        // 4. 匿名内部类：没有名字的类（常用）
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类：" + name);
            }
        };
        r.run();
    }
}

（3）常用场景示例

情况 1：成员内部类（标准写法）

// 外部类：汽车
class Car {
    private String brand = "奔驰";
    // 内部类：发动机
    class Engine {
        private String type = "V8";
        public void start() {
            // 可以访问外部类的私有属性
            System.out.println(brand + "汽车的" + type + "发动机启动了！");
        }
    }
}
// 使用
public class Test1 {
    public static void main(String[] args) {
        Car car = new Car();
        Car.Engine engine = car.new Engine();
        engine.start(); // 奔驰汽车的 V8 发动机启动了！
    }
}

情况 2：静态内部类（独立性强）

// 外部类：学校
class School {
    private static String schoolName = "清华";
    // 静态内部类：学生
    static class Student {
        private String name;
        public Student(String name) {
            this.name = name;
        }
        public void study() {
            System.out.println(name + "在" + schoolName + "学习"); // 只能访问外部类的静态成员
        }
    }
}
// 使用：不需要外部类对象
public class Test2 {
    public static void main(String[] args) {
        School.Student student = new School.Student("小明");
        student.study(); // 小明在清华学习
    }
}

情况 3：匿名内部类（最常用）

public class Test3 {
    public static void main(String[] args) {
        // 场景 1：实现接口（比如按钮点击）
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类：执行任务");
            }
        };
        task.run();
        // 场景 2：继承抽象类
        Animal cat = new Animal() {
            @Override
            void sound() {
                System.out.println("喵喵叫");
            }
        };
        cat.sound();
    }
}
abstract class Animal {
    abstract void sound();
}

情况 4：局部内部类（方法里使用）

public class Test4 {
    public void outerMethod() {
        final int localVar = 100; // 局部变量需要是 final 或事实上 final
        // 局部内部类
        class LocalClass {
            void show() {
                System.out.println("局部内部类，访问局部变量：" + localVar);
            }
        }
        LocalClass lc = new LocalClass();
        lc.show();
    }
    public static void main(String[] args) {
        Test4 test = new Test4();
        test.outerMethod(); // 局部内部类，访问局部变量：100
    }
}

（4）实际应用场景

场景 1：简化代码（事件监听器）

// 按钮类
class Button {
    // 内部接口
    interface OnClickListener {
        void onClick();
    }
    private OnClickListener listener;
    public void setOnClickListener(OnClickListener listener) {
        this.listener = listener;
    }
    public void click() {
        if (listener != null) {
            listener.onClick();
        }
    }
}
// 使用（最常见）
public class App {
    public static void main(String[] args) {
        Button button = new Button();
        // 用匿名内部类设置点击监听器
        button.setOnClickListener(new Button.OnClickListener() {
            @Override
            public void onClick() {
                System.out.println("按钮被点击了！");
            }
        });
        button.click(); // 按钮被点击了！
    }
}

场景 2：私有内部类（隐藏实现细节）

// 电脑类：对外只提供 USB 接口
class Computer {
    // 私有内部类：对外隐藏 USB 实现
    private class USBImpl implements USB {
        @Override
        public void connect() {
            System.out.println("USB 已连接");
        }
        @Override
        public void transfer() {
            System.out.println("数据传输中...");
        }
    }
    // 对外提供 USB 接口
    public USB getUSB() {
        return new USBImpl();
    }
}
interface USB {
    void connect();
    void transfer();
}
// 外部只能使用 USB 接口，看不到内部实现
public class User {
    public static void main(String[] args) {
        Computer computer = new Computer();
        USB usb = computer.getUSB(); // 只能获得 USB 接口
        usb.connect(); // USB 已连接
        usb.transfer(); // 数据传输中...
    }
}

注意事项

1. 成员内部类：需要外部类对象才能创建
2. 静态内部类：可以直接创建，不需要外部类对象
3. 匿名内部类：必须继承一个类或实现一个接口
4. 局部内部类：只能在方法内部使用

内部类就是'包在里面的小助手'，可以直接访问主人的私有东西，但对外界是隐藏的。