全称为:面向对象程序设计(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类定义了形状的颜色和面积,并且提供了一个通用的展示方法,而具体的形状类则根据自身特点实现了具体的面积计算方法。