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

朱雀 2023-09-27 17:21 36阅读 0赞

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 方法，输出每个形状的名称和面积。

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