O método template, como um padrão comportamental , define o esqueleto do algoritmo de uma operação em uma classe abstrata ou interface, e atrasa a execução específica de alguns passos para a subclasse, de modo que a execução do método da classe pai pode ser diferente. Assim, os objetivos de projeto de reutilização de código, boa escalabilidade e alta flexibilidade são alcançados.
Quando usar
Quando o método de modelo é usado, é principalmente o caso em que os mesmos métodos e métodos semelhantes são mais usados. Usando o método de modelo, esses métodos semelhantes podem ser extraídos e um modelo relativamente universal pode ser formulado, reduzindo assim a escrita repetitiva de código e melhorando a taxa de reutilização de código. Os cenários de uso abstratos e a lógica de implementação são mostrados na figura a seguir.
definição básica
Antes de entender como escrever métodos de modelo, é necessário entender alguns termos-chave e termos relacionados aos métodos de modelo.
método básico:
Os métodos básicos podem ser divididos em três categorias:
1. Método Concreto
O método específico refere-se ao método implementado pela classe/interface pai, e a subclasse não pode alterar o método.
2. Método abstrato
O método abstrato significa que as etapas específicas não são implementadas pela classe/interface pai, mas as etapas de operação específicas são adiadas para a implementação da subclasse, de modo a obter diferentes operações para diferentes situações.
3. Método de Gancho
Um método de gancho é declarado e implementado por uma classe abstrata e as subclasses o estendem. É um método que as subclasses podem implementar seletivamente ou não implementar . Normalmente, uma classe abstrata recebe uma implementação vazia como a implementação padrão do método.
Essa implementação padrão é chamada de método de gancho padrão . Este método de gancho vazio também é chamado de "Do Nothing Hook". O método de gancho padrão também é usado no modo de adaptação padrão. O padrão de adaptação padrão é que uma classe fornece uma implementação padrão vazia da interface, para que as subclasses não precisem fornecer implementações de todos os métodos, porque geralmente uma classe concreta não precisa de todos os métodos. Essa ideia coincide com o método de gancho padrão.
钩子方法常见的用途为，将两个存在不同调用关系的pipeLine流程，通过钩子方法联系到同一个模版中，从而屏蔽不同内容的差异性。但是，需要注意的一点是，**钩子方法的名字应当以do开始，这是熟悉设计模式的Java开发人员的标准做法。**如doScan、doGet等。
模版方法：
模版方法是模版模式的核心点，其是定义在抽象类中的，是把基本操作方法组合在一起形成总的算法或行为的方法。一个抽象类可以有任意多个模板方法，而不限于一个。每一个模板方法都可以调用任意多个具体方法。原则上，子类不可以、也不应该对模版方法进行覆盖或者重写。
上述定义中各类方法的对应模块大致如下图所示：
代码实践
模版方法的实现，在java中有两种方式，一种是基于抽象类的实现方式，另外一种则是基于接口的实现方式。
这里我们以抽象类的实现方法为例子介绍相应的模版方法的实现。
public abstract class Template {
public void concreteMethod() {
System.out.println("concreteMethod:");
}
public abstract void abstractMethod();
public void hookMethod(){
System.out.println("hookMethod:");
System.out.println("实现默认hookMethod!");
}
public final void execute() {
concreteMethod();
abstractMethod();
hookMethod();
}
}
复制代码首先，定义出我们的模版接口，其中包含三个方法concreteMethod、abstractMethod、hookMethod。就分别对应于我们上述提到的具体方法、抽象方法及钩子方法。
然后在execute（）方法内，定义好三个方法的基本执行方法，同时采用final修饰符，使得子类无法修改execute方法中的执行顺序。
然后在我们的子类HerFuction中，首先必须要对抽象方法进行相应的实现。这里我们简单的输出类名。
而在钩子方法hookMethod中，我们则对原方法进行增强，多输出一句话：“我还要执行自己的hookMethod方法!”。
public class HerFunction implements Template {
@Override
public void abstractMethod() {
System.out.println("HerFunciton !");
}
@Override
public void hookMethod() {
Template.super.hookMethod();
System.out.println("我还要执行自己的hookMethod方法!");
}
}
复制代码Da mesma forma, na segunda subclasse MyFunction, também precisamos implementar o método de classe abstrata correspondente. Mas para o método de gancho, o método na classe abstrata padrão pode ser usado.
public class MyFunction extends Template {
@Override
public void abstractMethod() {
System.out.println("My Function!");
}
}
复制代码Finalmente, crie objetos correspondentes a MyFunction e HerFunction respectivamente no método de inicialização e chame o método execute da classe pai.
public static void main(String[] args) {
Template myFunction = new MyFunction();
myFunction.execute();
System.out.println("================我是分割线=========================");
Template herFunction = new HerFunction();
herFunction.execute();
}
复制代码O resultado final é o seguinte:
Pode-se observar que as subclasses reutilizaram com sucesso o método concretoMethod, enquanto para o abstractMethod, diferentes lógicas foram implementadas de acordo com diferentes subclasses, refletindo as diferenças. Ao mesmo tempo, a implementação padrão e a implementação de subclasse do método de gancho também refletem a flexibilidade do modelo.
Análise de vantagens e desvantagens
vantagem:
1. Usar o método template para colocar o código da mesma lógica de processamento na classe pai abstrata pode melhorar a reutilização do código.
2. Coloque os códigos de processamento do mesmo significado comercial em diferentes subclasses e adicione novos comportamentos estendendo as subclasses, melhorando assim a expansibilidade do código.
3. Escreva o comportamento inalterado na classe pai, remova o código duplicado da subclasse e forneça uma boa plataforma de reutilização de código, que esteja de acordo com o princípio aberto-fechado.
deficiência:
1. A implementação do método template depende da construção de subclasses, portanto o número de classes aumentará significativamente, aumentando a complexidade da classe.
2. No caso de classes abstratas, o próprio relacionamento de herança tem algumas deficiências.Se a classe pai adiciona um novo método abstrato, todas as subclasses devem implementar o método abstrato. A linguagem JAVA pode usar a palavra- chave interface + default para evitar essa modificação até certo ponto. (Mas o efeito colateral é que você não pode usar final para limitar o método)
referências
Modo de modelo (Modelo) de "Padrões de design JAVA"
Explicar as razões essenciais para introduzir a palavra-chave padrão na interface Java8