Java设计模式之模板方法详解

什么是模板方法

模板方法模式是一种行为设计模式，它在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得可以在不改变算法结构的情况下重定义算法的某些步骤。

模板方法的实现

在Java中实现模板方法，需要按照以下步骤：

1. 创建一个抽象类，定义一个模板方法（如templateMethod()）作为算法的骨架，并包含其他的具体方法（如methodA()、methodB()等）；
2. 在模板方法中调用具体方法，这些具体方法需要在子类中实现；
3. 创建子类，实现抽象类中定义的抽象方法（如methodA()、methodB()等）。

示例说明

下面通过两个简单的示例来演示模板方法的应用。

示例一

假设我们要编写一个能计算一个数列的和的程序。首先我们定义一个抽象类Sequence，并在其中实现一个模板方法sum()。

public abstract class Sequence {
    private List<Integer> data = new ArrayList<>();

    public Sequence(int... nums) {
        for (int num : nums) {
            this.data.add(num);
        }
    }

    protected List<Integer> getData() {
        return this.data;
    }

    public final int sum() {
        int sum = 0;
        for (int num : getData()) {
            sum += num;
        }
        return sum;
    }

    public abstract int length();
}

在Sequence类中，我们定义了一个List<Integer>类型的数据成员data，并将它的值作为构造函数的参数初始化。同时，我们定义了一个sum()方法作为模板方法，用于计算数列中所有数字的总和。在模板方法中，我们调用了一个需要在子类中实现的方法getData()，用于获取数列数据。另外，在抽象类中，我们还定义了一个抽象方法length()，该方法需要在子类中实现。接下来，我们创建一些子类，如IntSequence、DoubleSequence，并实现抽象方法length()，并构造对应的数列。如下：

public class IntSequence extends Sequence {
    public IntSequence(int... nums) {
        super(nums);
    }

    @Override
    public int length() {
        return getData().size();
    }
}

public class DoubleSequence extends Sequence {
    public DoubleSequence(double... nums) {
        super();
        for (double num : nums) {
            this.getData().add((int) num);
        }
    }

    @Override
    public int length() {
        return getData().size();
    }
}

在子类中，我们实现了抽象方法length()，并且分别使用数组初始化了IntSequence和DoubleSequence，并将它们传递给抽象类的父类构造函数。最后，我们可以如下方式调用数列中所有数字的总和：

IntSequence nums1 = new IntSequence(1, 2, 3, 4, 5);
DoubleSequence nums2 = new DoubleSequence(1.1, 2.2, 3.3, 4.4, 5.5);
System.out.println("IntSequence sum = " + nums1.sum());
System.out.println("DoubleSequence sum = " + nums2.sum());

示例二

假设我们要编写一个银行利息计算器。首先我们定义一个抽象类BankAccount，并在其中实现一个模板方法calculateInterest()。

public abstract class BankAccount {
    private double balance;

    public BankAccount(double balance) {
        this.balance = balance;
    }

    public final double calculateInterest() {
        double rate = getRate();
        double interest = balance * rate;
        interest = ((int) (interest * 100)) / 100.0;
        return interest;
    }

    public abstract double getRate();
}

在BankAccount类中，我们定义了一个double类型的数据成员balance，并将它的值作为构造函数的参数初始化。同时，我们定义了一个calculateInterest()方法作为模板方法，用于计算银行利息。在模板方法中，我们调用了一个需要在子类中实现的方法getRate()，用于获取银行利率。接下来，我们创建一些子类，并分别实现抽象方法getRate()：

public class SavingsAccount extends BankAccount {
    public SavingsAccount(double balance) {
        super(balance);
    }

    @Override
    public double getRate() {
        return 0.05;
    }
}

public class CheckingAccount extends BankAccount {
    public CheckingAccount(double balance) {
        super(balance);
    }

    @Override
    public double getRate() {
        return 0.01;
    }
}

在子类中，我们实现了抽象方法getRate()，并且分别使用余额初始化了SavingsAccount和CheckingAccount。最后，我们可以如下方式调用银行利息计算器：

SavingsAccount savings = new SavingsAccount(10000);
CheckingAccount checking = new CheckingAccount(10000);
System.out.println("savings interest = " + savings.calculateInterest());
System.out.println("checking interest = " + checking.calculateInterest());

总结

模板方法模式是一种很好的设计模式，它使得能够在不改变算法结构的情况下重定义算法的某些步骤。我们可以通过继承自定义具体实现，从而实现了程序的扩展性。