Android面试-Java 的三大特性：封装、继承与多态

一、为什么是这三大特性

面向对象编程（OOP）的核心思想是把现实世界中的事物抽象成对象，再通过对象之间的协作完成业务逻辑。Java 作为一门典型的面向对象语言，把这一思想落地为三大基本特性：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）。

这三大特性并不是孤立存在的，而是层层递进的关系：封装负责“藏”，把数据和实现细节保护起来；继承负责“复用”，让子类在父类基础上扩展；多态负责“灵活”，让同一套调用接口在不同对象上表现出不同行为。理解它们之间的关系，比单独记住定义更重要。

二、封装：把细节藏起来，只暴露必要的接口

2.1 什么是封装

封装是指把对象的属性（数据）和行为（方法）组合在一起，并通过访问修饰符控制外部对内部细节的访问权限。外部只能通过类提供的公开方法操作数据，而不能直接修改内部字段。

封装带来的好处主要有三点：

• 数据安全：避免外部随意修改字段，导致对象处于非法状态。
• 降低耦合：外部只依赖公开接口，内部实现可以自由调整。
• 便于维护：校验逻辑集中在类内部，修改时只需改一处。

2.2 代码示例

public class Account {
    private String owner;
    private double balance;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    public String getOwner() {
        return owner;
    }

    public double getBalance() {
        return balance;
    }

    // 通过方法控制修改逻辑，保证余额不会变成负数
    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("取款金额必须大于 0");
        }
        if (amount > balance) {
            throw new IllegalStateException("余额不足");
        }
        balance -= amount;
    }

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("存款金额必须大于 0");
        }
        balance += amount;
    }
}

上面的例子中，balance 被声明为 private，外部无法直接赋值，只能通过 withdraw 和 deposit 修改。这样即使业务规则变化，也只需要调整类内部逻辑，调用方无需改动。

2.3 访问修饰符速查

修饰符	本类	同包	子类	任意位置
private	是	否	否	否
default（不写）	是	是	否	否
protected	是	是	是	否
public	是	是	是	是

三、继承：复用父类能力，扩展子类特性

3.1 什么是继承

继承允许一个类（子类）基于另一个类（父类）进行扩展，子类自动 自动获得父类的非私有成员，并可以新增自己的属性和方法，或重写父类的方法。Java 使用 extends 关键字实现继承，且只支持单继承，即一个类只能有一个直接父类。

继承的核心价值在于代码复用和建立类型层次。例如所有动物都有名字和“叫”的行为，就可以抽象出一个父类。

3.2 代码示例

public class Animal {
    protected String name;

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

    public void eat() {
        System.out.println(name + " 正在进食");
    }

    public void speak() {
        System.out.println(name + " 发出了声音");
    }
}

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

    @Override
    public void speak() {
        System.out.println(name + " 汪汪叫");
    }

    public void fetch() {
        System.out.println(name + " 正在捡球");
    }
}

这里 Dog 继承了 Animal，直接复用了 eat 方法，同时重写了 speak，并新增了 fetch 方法。注意 super(name) 用于调用父类构造方法，这是子类初始化父类状态的必要步骤。

3.3 继承的注意事项

• 构造方法不能被继承：子类需要通过 super() 显式或隐式调用父类构造方法。
• private 成员不可直接访问：子类只能通过父类提供的公开或受保护方法访问。
• 优先组合而非继承：继承会带来强耦合，如果只是“拥有”关系，用组合更合适。
• final 类不可被继承：如 String 就是 final 类。

四、多态：同一接口，不同实现

4.1 什么是多态

多态是指同一个方法调用，在不同对象上表现出不同的行为。Java 中的多态主要体现为编译时多态（方法重载）和运行时多态（方法重写 + 父类引用指向子类对象）。

运行时多态需要满足三个条件：

1. 存在继承关系；
2. 子类重写父类方法；
3. 父类引用指向子类对象。

4.2 代码示例

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

    @Override
    public void speak() {
        System.out.println(name + " 喵喵叫");
    }
}

public class Demo {
    public static void main(String[] args) {
        Animal a1 = new Dog("旺财");
        Animal a2 = new Cat("咪咪");

        // 同一个方法调用，表现出不同行为
        a1.speak(); // 旺财 汪汪叫
        a2.speak(); // 咪咪 喵喵叫
    }
}

变量 a1 和 a2 的编译类型都是 Animal，但运行时实际指向的对象不同，因此调用 speak() 时执行的是各自子类重写后的版本。这就是运行时多态的本质：方法调用在运行时才确定具体实现。

4.3 向上转型与向下转型

Animal animal = new Dog("旺财"); // 向上转型，自动完成
animal.speak();

if (animal instanceof Dog) {
    Dog dog = (Dog) animal; // 向下转型，需要强制转换
    dog.fetch();
}

向上转型是安全的，因为子类一定具备父类的接口；向下转型需要先用 instanceof 判断，否则可能抛出 ClassCastException。

五、三大特性的协作关系

把三者放在一起看，会发现它们共同构成了一套完整的面向对象设计思路：

• 封装是基础，它让对象内部状态可控，为继承和多态提供稳定的边界。
• 继承是手段，它复用父类能力并建立类型层次，为多态提供前提。
• 多态是目标，它让程序面向抽象编程，从而具备良好的扩展性。

举个实际场景：定义一个 Payment 接口，AlipayPayment 和 WechatPayment 分别实现它。业务代码只依赖 Payment，新增支付方式时无需修改原有逻辑，这正是封装、继承（接口实现）与多态共同作用的结果。

六、常见误区与小结

• 封装不等于只写 getter/setter：真正的封装是把业务规则收敛到类内部，而不是把字段无脑暴露。
• 继承不是越多越好：过深的继承链会让代码难以理解和维护，优先考虑组合。
• 多态依赖重写而非重载：重载是编译期决定的，重写才是运行时多态的基础。
• 接口也是一种多态：面向接口编程是 Java 中最常用的多态实践。

总结来说，封装解决“数据怎么保护”，继承解决“代码怎么复用”，多态解决“调用怎么灵活”。掌握这三点，就掌握了 Java 面向对象编程的骨架。

使用小程序，查看更多面试题目，随时随地刷题，刷题更方便！