Java的多态、抽象类、虚函数、封装示例

1. 多态
   多态是指同一种行为具有多种不同的表现形式或状态的能力。在 Java 中，多态性体现在以下两个方面：
   
   1.1子类可以继承父类的属性和方法，也可以重写父类的方法；
   
   1.2父类类型的变量可以引用子类对象。
   
   多态的优点是可以提高代码的灵活性和可扩展性，增强代码的重用性和可维护性。例如，我们可以定义一个 Shape 类型的数组，其中包含 Circle 和 Rectangle 对象，遍历数组，获取每个形状的面积。
2. 虚函数
   虚函数是一种在父类中声明的虚拟函数，它在运行时才确定其真正的实现方式。在 Java 中，虚函数体现在方法的重写（override）上。子类可以重写父类中的方法，当使用父类类型的变量引用子类对象时，实际调用的是子类中重写的方法。这就实现了多态。
3. 抽象类
   抽象类是一种不能被实例化的类，它的存在是为了让其子类来继承和实现其抽象方法。在 Java 中，使用 abstract 关键字来声明抽象类和抽象方法。抽象类可以包含抽象方法和非抽象方法，但是抽象方法必须在子类中被重写。
   抽象类的优点是可以提高代码的可扩展性和可维护性。例如，我们可以定义一个 Shape 抽象类，让 Circle 和 Rectangle 类都继承自 Shape 类，并实现其抽象方法 getArea。
4. 封装
   封装是一种将数据和方法进行隐藏的机制，只对外部提供必要的接口和方法。在 Java 中，封装体现在访问控制修饰符上。Java 中有三种访问控制修饰符：public、protected 和 private。使用这些修饰符可以控制类、方法、变量的可见性和访问权限。
   
   封装的优点是可以提高代码的安全性和稳定性。例如，我们可以定义一个 Person 类，并将其属性 name 和 age 声明为私有属性，在类的内部通过封装的方式访问属性，对外部程序提供 setter 和 getter 方法，控制对属性的访问。

abstract class Shape {
    private String name;

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

    public String getName() {
        return name;
    }

    public abstract double getArea();
}

class Circle extends Shape {
    private double radius;

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

    public double getRadius() {
        return radius;
    }

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

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

    public Rectangle(String name, double width, double height) {
        super(name);
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public double getHeight() {
        return height;
    }

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

public class Test {
    public static void main(String[] args) {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle("Circle", 5.0);
        shapes[1] = new Rectangle("Rectangle", 3.0, 4.0);

        for (Shape shape : shapes) {
            System.out.println(shape.getName() + " area is " + shape.getArea());
        }
    }
}

在这个例子中，我们定义了一个抽象类 Shape，其中包含一个私有属性 name 和一个抽象方法 getArea。我们又定义了两个子类 Circle 和 Rectangle，它们都继承自 Shape 类，分别实现了 getArea 方法。同时，我们在 Shape 类中将 name 属性声明为私有属性，通过提供 getter 方法实现了对属性的封装。

在主函数中，我们定义了一个 Shape 类型的数组，其中包含了 Circle 和 Rectangle 对象。在遍历数组时，我们使用多态的方式，通过调用 getName 和 getArea 方法，输出每个形状的名称和面积。

通过这个例子，我们可以看到多态、虚函数、抽象类、封装在代码中的应用，以及它们对代码的可扩展性、可维护性、安全性和稳定性所带来的好处。