【面试】面向对象编程的三大概念（实例辅助记忆）

虑面向对象编程的三大特性，它们是：

1. 封装（Encapsulation）： 将对象的状态和行为封装在一起，对外部隐藏对象的内部实现细节。这样可以防止外部直接访问对象的内部数据，通过对象的方法来控制和操作数据。

2. 继承（Inheritance）： 允许一个类（子类）继承另一个类（父类）的属性和方法。这样可以通过在子类中重用父类的代码，减少代码的重复性，并实现代码的扩展和维护。

3. 多态（Polymorphism）： 允许使用同一操作符或方法调用来操作不同的数据类型，提高代码的灵活性。多态包括编译时多态（方法重载）和运行时多态（方法重写）。

封装

封装是面向对象编程中的一个概念，它指的是将一个对象的状态（数据）和行为（方法）捆绑在一起，形成一个独立的、封闭的单元。这样，对象的内部实现细节对外部是隐藏的，只有通过对象提供的公共接口（方法）才能访问和操作对象的状态。

封装有助于保护对象的内部状态，防止外部直接访问和修改，从而提高了代码的安全性和可维护性。同时，封装还提供了一个清晰的接口，使得对象的使用者无需了解对象的具体实现细节，只需通过公共接口进行操作。

下面是一个简单的Java示例，展示了封装的概念：

public class Person {
    // 封装的状态（私有属性）
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 封装的行为（公共方法）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        // 在设置姓名时可以加入一些验证逻辑
        if (name != null && !name.isEmpty()) {
            this.name = name;
        } else {
            System.out.println("姓名不能为空");
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 在设置年龄时可以加入一些验证逻辑
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            System.out.println("年龄无效");
        }
    }
}

在这个例子中，Person 类封装了两个私有属性 name 和 age，并提供了公共的访问和修改方法 getName()、setName()、getAge()、setAge()。外部代码不能直接访问 name 和 age，而是通过这些公共方法来操作对象的状态。这样，Person 类就实现了封装。

继承

继承是面向对象编程的三大特性之一，它允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法。子类可以重用父类的代码，同时可以根据需要添加新的属性和方法，实现代码的重用和扩展。

下面是一个简单的Java示例，演示了继承的基本概念：

// 父类 Animal
class Animal {
    // 父类属性
    protected String name;

    // 父类构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 父类方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类 Dog 继承自 Animal
class Dog extends Animal {
    // 子类新增属性
    private String breed;

    // 子类构造方法，通过 super 调用父类的构造方法
    public Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }

    // 子类重写父类方法
    @Override
    public void eat() {
        System.out.println(name + " the " + breed + " is eating.");
    }

    // 子类新增方法
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        // 创建子类对象
        Dog myDog = new Dog("Buddy", "Golden Retriever");

        // 调用继承自父类的方法
        myDog.eat(); // 输出：Buddy the Golden Retriever is eating.

        // 调用子类新增的方法
        myDog.bark(); // 输出：Buddy is barking.
    }
}

在这个例子中，Animal 是父类，Dog 是子类。子类通过 extends 关键字继承了父类的属性和方法。子类还可以新增属性和方法。在TestInheritance 类中，创建了一个 Dog 对象，通过该对象可以调用继承自父类的 eat 方法，以及子类新增的 bark 方法。

继承提供了代码的重用性和扩展性，使得我们可以更好地组织和管理代码。但需要注意，过度的继承可能导致代码的复杂性和耦合性增加，因此需要谨慎使用。

多态

多态是面向对象编程的三大特性之一，它允许不同类的对象对相同的消息做出不同的响应。多态提高了代码的灵活性和可扩展性。

在Java中，多态通过方法的重写（Override）和接口（Interface）的实现来实现。下面是一个简单的例子，通过继承和方法重写演示多态：

// 基类 Animal
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 派生类 Dog
class Dog extends Animal {
    // 重写基类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

// 派生类 Cat
class Cat extends Animal {
    // 重写基类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        // 使用基类的引用指向派生类的对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 调用 makeSound 方法，实际调用的是派生类中的重写方法
        myDog.makeSound(); // 输出：Dog barks
        myCat.makeSound(); // 输出：Cat meows
    }
}

在这个例子中，Animal 是基类，Dog 和 Cat 是派生类。基类中有一个 makeSound 方法，而派生类分别重写了这个方法。在 TestPolymorphism 类的 main 方法中，使用基类的引用分别指向 Dog 和 Cat 对象。尽管引用类型是 Animal，但在运行时，实际调用的是派生类中的重写方法，产生了多态的效果。

这样，通过多态，我们可以使用基类的引用来引用不同派生类的对象，并且在运行时动态地选择调用哪个类的方法。这提高了代码的灵活性，使得我们能够轻松地扩展和修改代码。