什么是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类定义了形状的颜色和面积,并且提供了一个通用的展示方法,而具体的形状类则根据自身特点实现了具体的面积计算方法。

你可能感兴趣的:(入门,java,java)