OOP 的 4 个基础是什么

在面向对象编程 (Object-Oriented Programming，OOP) 中，有 4 个基础概念：封装 (Encapsulation)、继承 (Inheritance)、多态 (Polymorphism) 和抽象 (Abstraction)。

封装 (Encapsulation)

封装是指将数据和方法封装到一个类中，同时对外部隐藏数据的实现细节，只暴露接口供外部使用。

封装有以下好处：

• 减少了对外部的依赖性，使得修改实现更加容易。
• 隐藏了数据的实现细节，保证了数据的安全性。
• 提高了代码的可重用性和可维护性。

代码示例：

public class Person {
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // getter 和 setter 方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

继承 (Inheritance)

继承是指通过一个已有的类创建新的类，并且新的类会继承已有类的属性和方法。已有类称为父类（超类，基类），新的类称为子类（派生类）。

继承有以下好处：

• 可以减少代码的重复。
• 可以创建更加具体的类。
• 可以将变化隔离，使得修改实现更加容易。

代码示例：

public class Student extends Person {
    private String schoolName;
    
    // 构造方法
    public Student(String name, int age, String schoolName) {
        super(name, age);
        this.schoolName = schoolName;
    }
    
    // getter 和 setter 方法
    public String getSchoolName() {
        return schoolName;
    }
    
    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
    
    // 方法
    public void study() {
        System.out.println("I am studying at " + schoolName);
    }
}

多态 (Polymorphism)

多态是指同一个方法（或者操作符）在不同的对象上表现出不同的行为，常常使用继承和接口实现。

多态有以下好处：

• 可以减少代码的重复。
• 可以处理不同类型对象的集合。
• 可以让程序更加灵活。

代码示例：

public class Animal {
    public void sound() {
        System.out.println("I am an animal");
    }
}

public class Cat extends Animal {
    public void sound() {
        System.out.println("I am a cat");
    }
}

public class Dog extends Animal {
    public void sound() {
        System.out.println("I am a dog");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = new Animal[2];
        animals[0] = new Cat();
        animals[1] = new Dog();
        
        for (Animal animal : animals) {
            animal.sound();
        }
    }
}

抽象 (Abstraction)

抽象是指隐藏复杂的细节，只关注重要的部分。

抽象有以下好处：

• 可以减少代码的复杂度。
• 可以隐藏具体实现，使得程序更加灵活。
• 可以提高代码的可读性和可维护性。

代码示例：

public abstract class Shape {
    public abstract double getArea(); // 计算面积
}

public class Rectangle extends Shape {
    private double length;
    private double width;
    
    // 构造方法
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    
    // 实现抽象方法
    public double getArea() {
        return length * width;
    }
}

public class Circle extends Shape {
    private double radius;
    
    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }
    
    // 实现抽象方法
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Rectangle(3.0, 4.0);
        shapes[1] = new Circle(2.0);
        
        for (Shape shape : shapes) {
            System.out.println(shape.getArea());
        }
    }
}

以上就是 OOP 的 4 个基础：封装、继承、多态和抽象。这些概念可以帮助我们更好地理解和应用面向对象编程。