Java函数中多态和继承的应用案例

Java中的多态和继承是面向对象编程中非常重要的概念，通过它们可以大幅度提高代码的可维护性和可扩展性。下面就介绍几个Java函数中多态和继承的应用案例。

1. 多态：实现不同对象的同一操作

一个经典的例子是计算机科学领域中的图形处理。假设我们有不同类型的图形，比如正方形、长方形、圆形，这些图形都有面积这个属性，我们可以定义一个Shape类，让它作为这些图形的父类，同时定义一个计算面积的方法：

class Shape {
    public double getArea() {
        return 0;
    }
}

class Square extends Shape {
    private double length;

    public Square(double length) {
        this.length = length;
    }

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

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

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

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

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

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

接着我们可以定义一个计算所有图形面积的函数：

public double getTotalArea(Shape[] shapes) {
    double totalArea = 0;
    for (Shape shape : shapes) {
        totalArea += shape.getArea();
    }
    return totalArea;
}

这样，我们可以用该函数计算所有图形的面积，不同类型的图形都可以调用Shape类中的方法，形成统一的调用方式。这就是多态的应用。

2. 继承：提高代码复用性

另一个例子是Web开发中常见的表单验证。假设我们要写一个登录表单，需要验证用户输入的用户名和密码是否合法。我们可以定义一个基础的表单验证规则类BaseRule：

class BaseRule {
    public boolean validate(String value) {
        return true;
    }
}

然后，我们可以定义各种具体的验证规则类，比如限制长度、不能包含空格、必须包含数字等等，它们都继承自BaseRule类，并覆盖了validate方法：

class LengthLimitRule extends BaseRule {
    private int maxLength;

    public LengthLimitRule(int maxLength) {
        this.maxLength = maxLength;
    }

    @Override
    public boolean validate(String value) {
        return value != null && value.length() <= maxLength;
    }
}

class NoSpaceRule extends BaseRule {
    @Override
    public boolean validate(String value) {
        return value != null && !value.contains(" ");
    }
}

class NumberRequiredRule extends BaseRule {
    @Override
    public boolean validate(String value) {
        return value != null && value.matches(".*\\d.*");
    }
}

最后，我们可以将这些验证规则组装成一条完整的验证链，并在登录表单中使用：

class ValidationChain {
    private List<BaseRule> rules = new ArrayList<>();

    public void addRule(BaseRule rule) {
        rules.add(rule);
    }

    public boolean validate(String value) {
        for (BaseRule rule : rules) {
            if (!rule.validate(value)) {
                return false;
            }
        }
        return true;
    }
}

class LoginForm {
    private ValidationChain validationChain = new ValidationChain();

    public LoginForm() {
        validationChain.addRule(new LengthLimitRule(20));
        validationChain.addRule(new NoSpaceRule());
        validationChain.addRule(new NumberRequiredRule());
    }

    public boolean isValid(String username, String password) {
        return validationChain.validate(username) && validationChain.validate(password);
    }
}

这样，我们可以通过组装不同的验证规则，快速实现不同的表单验证，并且提高了代码的复用性。

综上，Java函数中多态和继承的应用非常广泛，可以帮助我们构建灵活、可复用、可扩展的代码。对于从事Java开发的程序员来说，理解和掌握这两个概念是非常重要的。