Java面向对象编程三大特性：封装，继承，多态

1.封装：     

        封装是指将数据和方法封装在一个类中，通过访问控制修饰符来控制对数据的访问权限。通过封装，可以隐藏实现细节，提高代码的安全性和可维护性。

1.1 封装的实现：

在 Java 中，实现封装的步骤主要包括：

        1.1.1  使用访问修饰符控制访问修饰符： 

               (1) 使用 private 关键字将类的属性设为私有，防止外部直接访问这些属性。

                (2) 通过 public 或 protected 的方法（通常是 getter 和 setter）来提供对私有属性的访问。

        1.1.2 提供公开的方法操作数据:

                (1)getter 方法用于获取属性的值。

                (2)setter 方法用于修改属性的值，同时可以在 setter 方法中加入逻辑以控制数据的合法性。

1.3 示例：

        

public class Person {
    // 私有属性
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        setAge(age); // 使用setter方法以便进行数据验证
    }

    // Getter 方法
    public String getName() {
        return name;
    }

    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }

    // Getter 方法
    public int getAge() {
        return age;
    }

    // Setter 方法
    public void setAge(int age) {
        // 数据验证：确保年龄为正数
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

2.继承：

        继承是指一个类可以继承另一个类的属性和方法。被继承的类称为父类或超类，继承的类称为子类或派生类。子类可以重写父类的方法，实现自己的逻辑。通过继承，可以实现代码的重用和扩展。

2.1 继承的实现：

        (1)使用 extends 关键字来继承父类。

        (2)Java 不支持多重继承，即一个类只能有一个直接父类，但可以通过接口实现类似的效果

        (3)子类可以重用父类的代码，并可以扩展或修改父类的行为。

2.2 示例：

        

// 父类 Animal
public class Animal {
    // 属性
    private String name;

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

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

    // Getter 方法
    public String getName() {
        return name;
    }

    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }
}

// 子类 Dog 继承自 Animal
public class Dog extends Animal {
    // 子类特有的属性
    private String breed;

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

    // 子类特有的方法
    public void bark() {
        System.out.println(getName() + " is barking.");
    }

    // 重写父类的方法
    @Override
    public void eat() {
        System.out.println(getName() + " the dog is eating dog food.");
    }
}

3.多态

        多态是指同一个方法在不同的对象上可以有不同的行为。多态通过继承和重写实现。父类的引用可以指向子类的对象，通过父类的引用调用同名的方法时，根据实际的对象类型确定调用哪个类的方法。多态可以提高代码的灵活性和可扩展性。

3.1 多态的实现

        (1).方法重载：在同一个类中，方法名称相同但参数列表不同。

        (2).方法重写：子类通过 @Override 注解重写父类的方法。

        (3).使用父类或接口的引用指向子类对象：这使得程序可以在不修改代码的情况下替换或增加新的子类。

示例：

// 父类 Animal
public class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// 子类 Dog 继承自 Animal
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

// 子类 Cat 继承自 Animal
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 调用时，实际执行子类的 makeSound 方法
        myDog.makeSound(); // 输出：Bark
        myCat.makeSound(); // 输出：Meow

        // 可以通过数组或集合来使用多态
        Animal[] animals = {new Dog(), new Cat(), new Animal()};
        for (Animal animal : animals) {
            animal.makeSound(); // 依次输出：Bark, Meow, Some generic animal sound
        }
    }
}