JAVA之三大基本思想

Java中的封装、继承和多态是三大基本思想，也是面向对象编程的重要概念。

    含义：

1. 封装（Encapsulation）：封装是将数据和操作数据的方法绑定在一起，形成一个整体，从而隐藏数据的实现细节，提供对外的接口。通过封装，我们可以控制对数据的访问，保证数据的安全性和一致性。在Java中，可以通过使用访问修饰符（如 private、public、protected）和提供对外的访问方法（getter和setter）来实现封装。

2. 继承（Inheritance）：继承是指一个类可以继承另一个类的属性和方法，从而形成类之间的继承关系。继承可以实现代码的重用，子类可以继承父类的字段和方法，并在此基础上进行扩展或重写。通过继承，可以建立类之间的层次关系，提高代码的可维护性和可扩展性。

3. 多态（Polymorphism）：多态是指同一个方法在不同的对象上具有多种不同的实现方式。多态通过方法的重写（Override）和方法的重载（Overload）来实现。在运行时，对象的实际类型决定了调用哪个具体的方法。多态可以增加代码的灵活性和可扩展性，提高代码的复用性。

// 封装
class Person {
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
 }
}

// 继承
class Student extends Person {
    private String school;
    
    public void setSchool(String school) {
        this.school = school;
    }
    
    public String getSchool() {
        return school;
    }
}

// 多态
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪叫");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵叫");
    }
}

public class Main {
    public static void main(String[] args) {
        // 封装示例
        Person person = new Person();
        person.setName("Alice");
        person.setAge(25);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        
        // 继承示例
        Student student = new Student();
        student.setName("Bob");
        student.setAge(18);
        student.setSchool("ABC School");
        System.out.println("Name: " + student.getName());
        System.out.println("Age: " + student.getAge());
        System.out.println("School: " + student.getSchool());
        
        // 多态示例
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound();  // 输出："狗发出汪汪叫"
        animal2.makeSound();  // 输出："猫发出喵喵叫"
    }
}

封装、继承和多态是面向对象编程的基本思想，在实际的应用中有许多场景可以应用它们。以下是一些常见的应用场景示例：

1. 封装：

   • 在一个类中封装数据和相关的方法，隐藏实现细节，并提供公共的接口供其他类使用。
   • 封装可以用于创建具有良好封装性的类库，从而保护数据不被其他代码直接访问和修改。
   • 封装也可以用于创建类的属性的访问控制，通过提供getter和setter方法来控制对属性的访问。

2. 继承：

   • 继承可以用于创建类的层次结构，通过子类继承父类的属性和方法，实现代码的重用和扩展。
   • 继承可以用于实现特定类型的对象，在父类定义通用的属性和方法，子类根据实际需求添加或重写方法。

3. 多态：

   • 多态可以使代码更加灵活和可扩展，允许在运行时根据实际的对象类型调用相应的方法。
   • 多态可以用于实现参数多态，一个方法接受不同类型的参数，根据实际的参数类型执行不同的操作。
   • 多态可以用于实现方法的重写，子类可以重写父类的方法并实现自己特定的行为。

        具体的应用场景会因项目需求和设计的具体情况而有所不同。封装、继承和多态是面向对象编程的核心概念，它们相互配合，可以提高代码的可维护性、可扩展性和可重用性，使代码更加清晰、灵活和易于理解。