table des matières
théorie
1. Mode modèle : définissez un cadre dans l'algorithme d'opération et chargez paresseusement ces étapes dans des sous-classes.
Le modèle de méthode de modèle permet aux sous-classes de redéfinir certaines étapes spécifiques d' un algorithme sans changer la structure de l'algorithme;
2. Rôle : Rôle du
modèle de résumé :
- Une ou plusieurs opérations abstraites sont définies afin que les sous-classes puissent les implémenter. Ces opérations abstraites sont appelées opérations de base et sont les étapes constitutives d'une logique de niveau supérieur.
- Définition et implémentation d'une méthode de modèle . Cette méthode de modèle est généralement une méthode concrète , qui donne un squelette de la logique de niveau supérieur, et les étapes de composition logique sont reportées à l'implémentation de la sous-classe dans les opérations abstraites correspondantes. La logique de niveau supérieur peut également appeler certaines méthodes spécifiques.
Rôle du gabarit concret (gabarit concret) :
- Implémentez une ou plusieurs méthodes abstraites définies par la classe parente, qui sont les étapes constitutives d'une logique de niveau supérieur.
- Chaque rôle de modèle abstrait peut avoir n'importe quel nombre de rôles de modèle spécifiques qui lui correspondent, et chaque rôle de modèle spécifique peut donner différentes implémentations de ces méthodes abstraites (c'est-à-dire les étapes de composition de la logique de niveau supérieur), permettant ainsi la réalisation de la logique de niveau supérieur Chacun est différent.
3. Convient pour la scène:
- Implémentez la partie invariante d'un algorithme à la fois et laissez le comportement de la variable aux sous-classes à implémenter.
- Les comportements communs dans chaque sous-classe doivent être extraits et concentrés dans une classe parent commune pour éviter la duplication de code.
- Il est nécessaire de déterminer si une certaine étape de l'algorithme de la classe parente est exécutée via la sous-classe et de réaliser le contrôle inverse de la sous-classe vers la classe parente.
entraine toi
- Classe de modèle abstrait
package com.qxy.design.template;
/**
* @author qxy
* @date 2020/10/16 2:30 下午
*/
public abstract class FileAnalysisTemplate {
//定义模版方法，对外部访问
public final void analysisFile() {
//1.验证文件后缀
validateFileSuffix();
//2.解析文件内容
analysisFileLine();
//3.验证文件标题列
validateFileTitle();
//处理钩子方法
if (specialFileColumn()) {
handlerSpecialColumn();
}
//4.封装pojo
createPojo();
//5.交互数据库
operateDataSource();
}
protected void validateFileSuffix() {
System.out.println("验证文件后缀成功：文件后缀为.xls或者.xlsx");
}
protected void analysisFileLine() {
System.out.println("文件解析成功：共用一套解析文件方法或者工具类");
}
protected abstract void validateFileTitle();
protected abstract void createPojo();
protected void operateDataSource() {
System.out.println("数据入库成功");
}
/**
* 是否特殊处理列数据
* @return false
*/
protected boolean specialFileColumn() {
return false;
}
/**
* 钩子方法：交给子类具体实现处理
*/
protected void handlerSpecialColumn() {
}
}
- Rôle de modèle spécifique: ItemAFileAnalysis
package com.qxy.design.template;
/**
* @author qxy
* @date 2020/10/16 3:08 下午
*/
public class ItemAFileAnalysis extends FileAnalysisTemplate{
@Override
protected void validateFileTitle() {
System.out.println("验证项目A的标题列是否缺失");
}
@Override
protected void createPojo() {
System.out.println("创建项目A对象");
}
@Override
protected boolean specialFileColumn() {
return true;
}
@Override
protected void handlerSpecialColumn() {
System.out.println("特殊处理：处理项目名字");
}
}
- Rôle de modèle spécifique: ItemBFileAnalysis
package com.qxy.design.template;
/**
* @author qxy
* @date 2020/10/16 3:10 下午
*/
public class ItemBFileAnalysis extends FileAnalysisTemplate{
@Override
protected void validateFileTitle() {
System.out.println("验证项目B的标题列是否缺失");
}
@Override
protected void createPojo() {
System.out.println("创建项B对象");
}
}
- Client
package com.qxy.design.template;
/**
* @author qxy
* @date 2020/10/16 3:07 下午
*/
public class FileClient {
public static void main(String[] args) {
FileAnalysisTemplate aFileAnalysis = new ItemAFileAnalysis();
aFileAnalysis.analysisFile();
System.out.println("-----------");
FileAnalysisTemplate bFileAnalysis = new ItemBFileAnalysis();
bFileAnalysis.analysisFile();
}
}
Les résultats sont les suivants:
验证文件后缀成功：文件后缀为.xls或者.xlsx
文件解析成功：共用一套解析文件方法或者工具类
验证项目A的标题列是否缺失
特殊处理：处理项目名字
创建项目A对象
数据入库成功
-----------
验证文件后缀成功：文件后缀为.xls或者.xlsx
文件解析成功：共用一套解析文件方法或者工具类
验证项目B的标题列是否缺失
创建项B对象
数据入库成功
Process finished with exit code 0
Pour résumer
avantage:
- Encapsulez les parties inchangées et extrayez les parties inchangées;
- Étendez la partie variable, définissez la méthode abstraite variable et laissez la sous-classe concrète l'implémenter.
- Le code commun extrait est pratique pour une maintenance ultérieure.
- Les comportements sont contrôlés par des classes de base et des opérations spécifiques sont implémentées par des sous-classes.
Inconvénients:
Chaque implémentation différente nécessite une sous-classe à implémenter, ce qui entraînera une augmentation considérable du nombre de classes, ce qui rendra le système encore plus grand.
Attention particulière :
afin d'éviter que le squelette de l'algorithme ne soit détruit ou exploité de manière malveillante, généralement lors de l'utilisation du mode modèle, la méthode modèle ajoutera finalce mot-clé à limit.
La clé du modèle de modèle est que la sous - classe peut remplacer la partie variable de la classe parente, mais la sous-classe ne peut pas modifier la logique de niveau supérieur représentée par la méthode de modèle .
Chaque fois que vous définissez une nouvelle sous-catégorie, n'y pensez pas selon la pensée du flux de contrôle, mais selon la pensée de la «responsabilité». En d'autres termes, nous devons considérer quelles opérations doivent être remplacées, quelles opérations peuvent être remplacées et quelles opérations ne peuvent pas être remplacées. L'utilisation du modèle de modèle peut clarifier ces responsabilités.
Portail de code source: https://github.com/stream-source/stream-source
Matériel de référence: modèles de conception Java