什么是OOP

全称为：面向对象程序设计(Object Oriented Programming)

它包含了类、对象、封装、继承、多态、抽象，

对象是现实事物或抽象事务的表示，类是对象的抽象是对具相同属性和方法的对象的描述，封装是将属性和方法放到同一个类中的过程，继承是一个类继承另一个类的方法和属性（也就是子类继承父类），多态是不同方法的不同表现形式（两个子类继承同一个父类的同一个方法，当分别调用该方法时进行了不同的实现），抽像是将现实生活中事物本质特征和行为进行概括提取，转化成类、接口、方法、等代码。

封装：

public class Circle {
    private double radius;
    
    public Circle(double radius) {
        setRadius(radius);
    }
    
    public double getRadius() {
        return radius;
    }
    
    public void setRadius(double radius) {
        if (radius > 0) {
            this.radius = radius;
        } else {
            System.out.println("半径必须大于0");
        }
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    public double getCircumference() {
        return 2 * Math.PI * radius;
    }
}

在这个示例中，我们创建了一个名为Circle的封装类。它有一个私有属性radius表示圆的半径。

通过公有的构造函数和setter方法，我们可以为Circle对象设置合法的半径值。在setRadius方法中，我们添加了一个条件判断，确保半径大于0。

通过公有的getter方法，我们可以获取Circle对象的半径值。

此外，我们还定义了两个计算圆的面积和周长的方法getArea和getCircumference。

通过封装，我们隐藏了radius的实现细节，并提供了公有的方法来访问和操作它。这样做的好处是，外部代码无法直接修改radius的值，从而保证了数据的安全性。同时，我们可以通过提供适当的方法来控制对radius的访问，例如在setRadius方法中添加了条件判断。

通过封装类，我们可以将数据和相关的操作封装在一起，提高了代码的可维护性和可重用性。

继承：

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat(); // 调用父类的eat方法
        dog.bark(); // 调用子类的bark方法
    }
}

在这个案例中，我们定义了一个Animal类作为父类，它有一个受保护的属性name表示动物的名字，以及一个eat方法表示动物的吃饭行为。

然后我们定义了一个Dog类作为Animal类的子类，它通过关键字extends继承了Animal类。Dog类新增了一个bark方法表示狗的叫声行为。

在Main类的main方法中，我们创建了一个Dog对象，并调用了它继承自Animal类的eat方法和自己新增的bark方法。

通过继承，子类可以继承父类的属性和方法，并且可以新增自己特有的属性和方法。在这个案例中，Dog类继承了Animal类的name属性和eat方法，并新增了自己的bark方法。

继承可以使代码具有层次结构，提高代码的可维护性和可扩展性。它还可以实现多态，即不同类型的对象可以以相同的方式进行处理。在这个案例中，我们可以将Dog对象看作是Animal对象的一种特殊类型，因此可以调用Animal类的方法，同时还可以调用Dog类自己的方法。

多态：

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void makeSound() {
        System.out.println(name + " is making sound.");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " is meowing.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Cat("Fluffy");
        Animal animal2 = new Dog("Buddy");
        
        animal1.makeSound(); // 调用Cat类的makeSound方法
        animal2.makeSound(); // 调用Dog类的makeSound方法
    }
}

在这个案例中，我们定义了一个Animal类作为父类，它有一个受保护的属性name表示动物的名字，以及一个makeSound方法表示动物发出声音的行为。然后我们定义了两个子类Cat和Dog，它们分别继承了Animal类，并覆盖了makeSound方法，实现了各自特有的声音行为。

在Main类的main方法中，我们创建了一个Cat对象和一个Dog对象，并将它们赋值给Animal类型的变量。由于子类的实例可以看作是父类的实例，因此我们可以用Animal类型的变量来引用不同类型的对象。

然后我们调用了这两个Animal对象的makeSound方法，由于Cat和Dog类都重写了makeSound方法，因此调用时会根据对象的实际类型来决定具体调用哪个类的makeSound方法。这就是多态的体现，相同的方法名称，在不同的子类中实现不同的行为。

通过多态，我们可以使代码更加灵活和可扩展。当需要增加新的子类时，只需要继承父类并重写相关方法即可，无需修改原有代码。同时，多态还可以实现对不同类型对象的统一处理，提高了代码的复用性和可维护性。

抽象：

abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();

    public void display() {
        System.out.println("This shape is " + color + ".");
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double getArea() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5.0);
        Shape rectangle = new Rectangle("Blue", 3.0, 4.0);

        circle.display();
        System.out.println("The area of the circle is: " + circle.getArea());

        rectangle.display();
        System.out.println("The area of the rectangle is: " + rectangle.getArea());
    }
}

在这个案例中，我们定义了一个抽象类Shape，它具有一个受保护的属性color表示形状的颜色。抽象类中包含了一个抽象方法getArea()，用于获取形状的面积，并且还有一个普通方法display()，用于展示形状的颜色。

然后我们定义了两个子类Circle和Rectangle，它们分别继承了Shape类，并实现了抽象方法getArea()。Circle类表示圆形，包含一个半径属性，而Rectangle类表示矩形，包含长度和宽度属性。

在Main类的main方法中，我们创建了一个Circle对象和一个Rectangle对象，并使用抽象类Shape来引用这两个对象。通过调用抽象类的display方法和具体实现的getArea方法，分别展示了圆形和矩形的颜色和面积。

抽象类是一种不能被实例化的类，它用于定义通用的属性和方法，而具体的实现由子类来完成。通过抽象类，我们可以将共同的行为抽象出来，提高代码的复用性和可扩展性。在这个案例中，Shape类定义了形状的颜色和面积，并且提供了一个通用的展示方法，而具体的形状类则根据自身特点实现了具体的面积计算方法。