¿Cómo utilizar Prototype?

Los patrones de diseño son un requisito previo para leer el código fuente.

El prototipo describe un escenario para generar instancias: generar instancias copiando.

Demo específica

https://mp.weixin.qq.com/s/cnRXW5-rA195sCkgiaWsnw

Rol 1:
Se puede entender que el cliente es responsable de llamar

public class Manager {
    private HashMap<String,Product> showCase = new HashMap<>();
    public void register(String name,Product product){
        showCase.put(name,product);
    }

    public Product createProduct(String name){
        Product product = showCase.get(name);
        Product clone = product.createClone();
        return clone;
    }
}

 

Rol 2:

El rol de prototipo es responsable de definir métodos. ¿Qué método es copiar una instancia existente y generar una nueva instancia?

Aunque Cloneable es una interfaz marcada, debe implementarse. De lo contrario, informará un error

public interface Product extends Cloneable {

    public abstract void use();

    public abstract Product createClone();
}

 

Rol 3: La clase de realización concreta del prototipo

public class Spark implements Product {
    @Override
    public void use() {
        System.out.println("我是会发光的 Spark");
    }

    @Override
    public Product createClone() {
        try {
            return (Product) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Para acercarnos al escenario de uso real, aquí asumimos que hay 2 subcategorías

public class Slash implements Product {
    @Override
    public void use() {
        System.out.println("我是不一样的光 Slash  ");
    }

    @Override
    public Product createClone() {
        Product clone;
        try {
            clone = (Product) clone();
            return clone;
        } catch (CloneNotSupportedException ex) {
            ex.printStackTrace();

        }
        return null;
    }
}

verificación. Generar una instancia no es el objetivo final, pero en última instancia, para su uso

public static void main(String[] args) {
        Manager manager = new Manager();

        Slash slash = new Slash();
        manager.register("slash", slash);
        Spark spark = new Spark();
        manager.register("spark",spark);

        Product slash = manager.createProduct("slash");
        slash.use();
        Product spark1 = manager.createProduct("spark");
        spark1.use();

    }

 

¿Por qué utilizar este modo?

 

Razón 1: Cuando la generación de la clase es muy complicada, es muy laborioso generar una instancia, y es necesario usarla en otros escenarios, puedes considerar

Razón 2: desacoplar el marco y la instancia generada

Si el marco no depende de una clase específica, no puede especificar el nombre de la clase para generar una instancia, debe registrar un prototipo por adelantado y luego copiar para generar una nueva instancia

 

Optimice la demostración con el método de plantilla

¿Ha encontrado que en el caso anterior, la implementación de createClone en la subclase está duplicada? ¿Qué tengo que hacer?