De las noventa y nueve y ochenta y una dificultades de aprender de Occidente, observe el patrón de diseño de Java: el patrón de método de plantilla

Ejemplo

Cuando diseñamos una clase, podemos aclarar los pasos de ejecución internos de un determinado método que proporciona externamente,
pero en algunos pasos, diferentes subclases tienen diferentes comportamientos, ¿cómo debemos diseñar la clase?
Tomemos el ejemplo de jugar King of Glory para comenzar a aprender: para
jugar un juego, primero debes inicializar el juego, luego cargar el mapa, cargar el personaje, luego iniciar el juego y finalmente finalizar el juego.
Definir una clase de juego :

public abstract class Game {
    
    

    public final void play () {
    
    
        initialize();
        loadMap();
        loadRole();
        startPlay();
        endPlay();
    }

    /** 初始化游戏 */
    protected abstract void initialize();


    /** 加载地图 */
    protected abstract void loadMap();

    /** 加载角色 */
    protected abstract void loadRole();


    /** 开始游戏 */
    protected abstract void startPlay();

    /** 结束游戏 */
    protected abstract void endPlay();
}

Clase de implementación de la clase anterior:

public class KingGlory extends Game {
    
    

    @Override
    protected void initialize() {
    
    
        System.out.println("王者荣耀正在初始化，请稍后。。。");
    }

    @Override
    protected void loadMap() {
    
    
        System.out.println("正在加载王者峡谷地图。。。");
    }

    @Override
    protected void loadRole() {
    
    
        System.out.println("正在加载角色鲁班七号。。。");
    }

    @Override
    protected void startPlay() {
    
    
        System.out.println("开始玩王者荣耀。。。");
    }

    @Override
    protected void endPlay() {
    
    
        System.out.println("结束王者荣耀游戏，保存数据。。。");
    }
}

Categoría de prueba:

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Game game = new KingGlory();
        game.play();
    }
}

Patrón de método de plantilla

definición

Una clase abstracta define públicamente la forma / plantilla para ejecutar sus métodos. Sus subclases se pueden implementar anulando métodos según sea necesario, pero la llamada se realizará de la forma definida en la clase abstracta.

intención

Defina el esqueleto de un algoritmo en funcionamiento y retrase algunos pasos hacia las subclases. El método de plantilla permite que las subclases redefinan ciertos pasos específicos de un algoritmo sin cambiar la estructura del algoritmo.

Principalmente resuelve el problema

Algunos métodos son comunes, pero este método se reescribe en cada subclase.

Escena aplicable

1. Hay métodos compartidos por múltiples subclases y la lógica es la misma.
2. Los métodos importantes y complejos pueden considerarse métodos modelo

Pros y contras

Ventajas:
1. Encapsular la parte constante y expandir la parte variable.
2. Extraiga códigos públicos para facilitar el mantenimiento.
3. El comportamiento está controlado por la clase padre y es implementado por la subclase.

Desventajas:
cada implementación diferente requiere una subclase para implementar, lo que resulta en un aumento en el número de clases, lo que hace que el sistema sea más complejo

Diagrama de clases:

roles involucrados:

1. Rol de plantilla abstracta (AbstractTemplate): define una o más operaciones abstractas para que las subclases puedan implementarlas. Estas operaciones abstractas se denominan operaciones básicas. Son los componentes de la lógica de nivel superior. Se define e implementa un método de plantilla. Este método de plantilla es generalmente un método concreto, que proporciona el esqueleto de una lógica de nivel superior, y los pasos de composición lógica se difieren a la implementación de la subclase en la operación abstracta correspondiente
2. Roles de plantilla concreta (ContrateTemplate): implemente uno o más métodos abstractos definidos por la clase principal, que son un paso de composición lógica de nivel superior; cada rol de plantilla abstracta puede tener cualquier número de roles de plantilla concretos correspondientes, y cada rol de plantilla específico puede dar diferentes implementaciones de estos métodos abstractos, lo que hace que la implementación de la lógica de nivel superior sea diferente

Código fuente correspondiente:

public abstract class AbstractTemplate {
    
    

    public void templateMethod() {
    
    
        doOperation1();

        doOperation2();

        doOperation3();
    }

    /** 基本方法，由子类实现 */
    protected abstract void doOperation1();

    /** 基本方法，由子类实现 */
    protected abstract void doOperation2();

    /** 基本方法，已经实现 */
    private final void doOperation3(){
    
    
        //do something......
    }
}

public class ContrateTemplate extends AbstractTemplate {
    
    
    @Override
    protected void doOperation1() {
    
    
        System.out.println("doOperation1......");
    }

    @Override
    protected void doOperation2() {
    
    
        System.out.println("doOperation2......");
    }
}

Las nueve-nueve-ocho-una dificultades de aprender de Occidente

En "Journey to the West", las ochenta y una dificultades que experimentó el monje Tang en su camino hacia el oeste para aprender las escrituras son, en el análisis final, un proyecto controlado por el Bodhisattva Guanyin. El siguiente es un ejemplo del arriba de la escena y escribe un pequeño ejemplo:

Cada paso de la calamidad que experimentan las personas que aprenden de las escrituras está controlado por el Bodhisattva:

public abstract class LearnFromPeople {
    
    

    public final void westernCountry() {
    
    
        firstHard();
        secondHard();
        thirdHard();
    }

    /** 第一难 */
    protected abstract void firstHard();

    /** 第二难 */
    protected abstract void secondHard();

    /** 第三难 */
    protected abstract void thirdHard();
}

Tang Seng fue a Xitian para aprender las escrituras, heredó la clase abstracta del buscador de escrituras y luego tuvo que atravesar 81 dificultades:

public class TangMonk extends LearnFromPeople {
    
    
    @Override
    protected void firstHard() {
    
    
        System.out.println("金蝉遭贬第一难");

    }

    @Override
    protected void secondHard() {
    
    
        System.out.println("出胎几杀第二难");
    }

    @Override
    protected void thirdHard() {
    
    
        System.out.println("满月抛江第三难");
    }
}

Tang Seng comenzó en el camino:

public class Test {
    
    

    public static void main(String[] args) {
    
    
        LearnFromPeople people = new TangMonk();
        people.westernCountry();
    }
}

Cabe señalar que para evitar operaciones maliciosas, la palabra clave final se agregará al método de la plantilla.