面向对象编程三大特征 -Java

面向对象编程（OOP）的三大特征是封装、继承和多态。这三个特征是面向对象编程的核心，帮助开发人员创建结构清晰、可维护、可扩展的程序。

1. 封装（Encapsulation）

封装是将数据（属性）和操作数据的方法（函数）绑定在一起，通过类的结构进行封装。封装的主要目的是数据隐藏，即限制外部访问对象的内部细节，只提供必要的接口。封装提高了代码的安全性和可维护性，防止外部不正当的修改和访问。

特点：

• 访问控制：可以通过访问控制符（如 private、protected、public）来控制对对象属性和方法的访问。
• 数据隐藏：属性通常设置为 private，通过公共的 getter 和 setter 方法来提供访问权限。

代码示例：

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) {
        this.name = name;
    }

    // 公共方法：获取年龄
    public int getAge() {
        return age;
    }

    // 公共方法：设置年龄
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;  // 增加条件检查，确保年龄合法
        } else {
            System.out.println("年龄必须大于0");
        }
    }

    // 显示个人信息
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class EncapsulationExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.displayInfo();

        // 通过 setter 修改属性
        person.setName("Bob");
        person.setAge(30);
        person.displayInfo();
    }
}

说明：

• name 和 age 属性是私有的，不能直接访问。
• 通过公共方法 getName()、setName()、getAge() 和 setAge() 来访问和修改这些私有属性。
• 通过 setter 方法可以增加数据验证（如确保年龄大于0），从而确保数据的一致性和安全性。

2. 继承（Inheritance）

继承是面向对象的一个重要特性，它允许我们创建一个类（子类）继承另一个类（父类）的属性和方法。继承使得子类可以重用父类的代码，并能够对父类的行为进行扩展或修改。继承是代码复用的一种机制，能够提高代码的可扩展性和维护性。

特点：

• 代码复用：子类继承父类后，可以直接使用父类的属性和方法。
• 扩展和重写：子类可以扩展父类的功能，重写父类的方法。
• is-a 关系：子类是父类的一种类型。继承表示“is-a”关系。

代码示例：

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

// 子类（派生类）
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.sound();  // Animal makes a sound
        
        Dog dog = new Dog();
        dog.sound();  // Dog barks
    }
}

说明：

• Dog 类继承了 Animal 类，因此它可以直接使用 Animal 类的方法（sound()）。
• 子类 Dog 重写了父类的 sound() 方法，使其具有了不同的行为。
• 继承实现了代码的复用，并允许我们扩展父类的功能。

3. 多态（Polymorphism）

多态是面向对象编程的另一个重要特性，它允许同一操作作用于不同的对象上时，表现出不同的行为。简单来说，多态可以理解为“一个接口，多个实现”。多态主要通过方法重载（同一方法名，参数不同）和方法重写（子类重新定义父类的方法）来实现。

特点：

• 方法重载（Overloading）：同一个类中，方法名相同，但参数不同。
• 方法重写（Overriding）：子类重新实现父类的方法，通常用于父类方法的多态行为。
• 动态绑定：在程序运行时，确定调用哪个方法。

代码示例（方法重写实现多态）：

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

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        // 创建 Animal 类型的引用，指向 Dog 对象
        Animal myAnimal = new Dog();
        myAnimal.sound();  // 输出: Dog barks
        
        // 创建 Animal 类型的引用，指向 Cat 对象
        myAnimal = new Cat();
        myAnimal.sound();  // 输出: Cat meows
    }
}

说明：

• Animal 是父类，Dog 和 Cat 是其子类。
• 在 main 方法中，myAnimal 是 Animal 类型的引用，但它指向的是不同的子类对象（Dog 和 Cat）。
• 运行时，JVM 会根据对象的实际类型（而不是引用类型）调用正确的 sound() 方法，这就是多态的体现。

4. 总结

面向对象的三大特性—封装、继承和多态，通过将数据和操作绑定在一起、提高代码的复用性和扩展性，以及使得对象能够表现出不同的行为，极大地提高了程序的可维护性和灵活性。