Java面试：面相对象三大特性

面相对象三大特性（封装、继承、多态）

面向对象编程（OOP）有三大基本特性：封装、继承和多态。这三大特性共同构成了面向对象编程的基础，使得程序设计更加模块化、可维护和可扩展。

封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）结合在一起，形成一个独立的单元，也就是类。通过封装，我们可以隐藏对象的内部细节，只暴露必要的接口，这样可以防止外部代码随意修改对象的状态，确保代码的安全性和稳定性。

通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

public class BankAccount {
    private double balance; // 通过private修饰符隐藏余额属性

    public void deposit(double amount) { // 提供存款方法
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) { // 提供取款方法
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() { // 提供查询余额的方法
        return balance;
    }
}

在上述例子中，BankAccount 类封装了账户余额 balance 和操作余额的方法 deposit() 和 withdraw()。外部代码只能通过这些方法来修改余额，而不能直接访问 balance 属性。

在示例中，我们可以看出，实现封装其实主要是控制对象状态（属性）的可见性，Java 中我们靠权限修饰符（关键字）来进行访问控制，权限修饰符共有 4 种，作用范围从小到大依次是：private < 缺省值（空着不写） < protected < public。

具体访问权限信息如下：

修饰符	本类内部	本包内	其他包的子类	其他包非子类
private	✅	❌	❌	❌
缺省值	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

继承（Inheritance）

继承就像是给我们的类找了一个“父母”。子类可以继承父类的属性和方法，这样可以避免重复编写相同的代码，同时也能够扩展或修改父类的功能。继承帮助我们构建层次化的类结构，使代码更加清晰和模块化。

Java 中继承使用关键字 extends，比如：A extends B，A 称作 B 的子类，B 称作 A 的父类，继承后子类不是父类的子集，而是对父类的扩展。

Java 中只支持单继承，也就是 A extends B 与 A extends C 不能同时存在；但是支持多层继承，而且继承具有传递性，比如 A extends B extends C，A 中就同时具有了 B 和 C 的内容。

public class Animal {
    public void eat() {
        System.out.println("干饭...");
    }

    public void sleep() {
        System.out.println("倒头就睡...");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("汪~汪~汪~");
    }
}

public class Cat extends Animal {
    public void meow() {
        System.out.println("喵~喵~喵~");
    }
}

如上，Dog 和 Cat 类都继承自 Animal 类，通过继承它们自动获得了 eat() 和 sleep() 方法，并且可以添加自己的特征方法 bark() 和 meow()。

多态（Polymorphism）

“龙生九子，各有不同”，这句话形象地描述了多态的特性。即使是同一个类的子类，各个子类的行为也可以各不相同。多态，也是面向对象中的一个重要特性，在 Java 中体现为：父类的引用指向子类的对象。

多态的前提： 1. 类的继承关系 2. 子类重写父类方法。多态在使用中有句口诀叫：编译时看左边，运行时看右边。这里的左右是以创建对象语句中的 = 为分割的，意思就是编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋值给该变量的对象决定。

为了方便理解，请看如下示例：

public class Animal {
    public void eat() {
        System.out.println("干饭...");
    }

    public void sleep() {
        System.out.println("倒头就睡...");
    }

    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        // 调用继承父类的方法
        animal1.eat(); // 输出 "吃肉..."
        animal2.eat(); // 输出 "吃鱼..."
        animal1.sleep(); // 输出 "倒头就睡..."
        animal2.sleep(); // 输出 "倒头就睡..."

        // 调用子类特征方法（需要向下转型）
        ((Dog) animal1).bark(); // 输出 "汪~汪~汪~"
        ((Cat) animal2).meow(); // 输出 "喵~喵~喵~"
    }
}

class Dog extends Animal {

    public void eat() {
        System.out.println("吃肉...");
    }

    public void bark() {
        System.out.println("汪~汪~汪~");
    }
}

class Cat extends Animal {

    public void eat() {
        System.out.println("吃鱼...");
    }

    public void meow() {
        System.out.println("喵~喵~喵~");
    }
}

该示例中 Dog 与 Cat 类都继承自 Animal，并且重写了父类的 eat() 方法。在编译时期，对象类型是基于变量声明的类型，所以dog 与 cat 的类型都是 Animal，而在程序运行时期，对象的实际类型分别被指定为Dog 与 Cat，所以在 eat() 方法被调用时输出的是子类重写后的数据。

从示例中我们也可以看出，当父类引用指向子类对象的时候，我们就不能调用子类拥有而父类没有的方法了，调用的时候必须做类型转换，才能使编译通过。在做类型转换时，为了避免 ClassCastException 的发生，Java 提供了 instanceof 关键字，给引用变量做类型的校验。用法如下：

public static void main(String[] args) {
    Animal animal1 = new Dog();

    if (animal1 instanceof Dog) {
        Dog dog = (Dog) animal1;
        dog.bark();
    }
}

重载与重写

• 重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或者参数顺序不同即可，只看参数列表，与返回值无关。

《Java 核心技术》书中提到：

如果多个方法(比如 StringBuilder 的构造方法)有相同的名字、不同的参数， 便产生了重载。

StringBuilder sb = new StringBuilder();
StringBuilder sb2 = new StringBuilder("Hello World");

编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。如果编译器找不到匹配的参数，就会产生编译时错误，因为根本不存在匹配，或者没有一个比其他的更好（这个过程被称为重载解析（overloading resolution））。Java 允许重载任何方法，而不只是构造器方法。

• 重写：也叫覆写，方法重写是指子类重新定义父类中已经存在的方法。重写方法的名称、参数列表和返回类型必须与父类中的方法完全相同。这有助于实现多态性，允许子类提供特定的行为。子类重写父类方法后，方法调用时默认调用自身重写后的方法，也就是 this.method(); ，当需要调用父类方法时需显示使用 super.method()进行调用。

重写产生的原因

当父类的某个方法不适合于子类本身的特征行为时，就需要重写父类中应当改变的方法。

方法重写时应该遵循的原则

方法重写时遵循两同两小一大的原则。

• 两同：

  • 与父类方法签名相同；
  • 形参列表相同；

• 两小：

  • 子类方法的返回值类型比父类方法的返回值类型更小或相等；
  • 子类方法声明抛出的异常应比父类方法声明抛出的异常更小或相等；
• 一大：子类方法的访问权限应比父类的访问权限更大或相等。

---

更多精彩内容，请微信搜索并关注【Java驿站】公众号。