Prototipo modo de patrón de diseño (el prototipo) Comentarios y código de ejemplo

I. Definiciones y características de Modelo de Prototipo

　　Prototipo de modo definido (el prototipo) son como sigue: con una instancia ya creado como un prototipo para crear un prototipo de los mismos o similares nuevos objetos copiando este objeto prototipo. Pertenece a 创建型los patrones de diseño para la creación de objetos duplicados, garantizando al mismo tiempo el rendimiento (muy eficiente para crear un objeto de esta manera).

　　Este modelo se implementa una interfaz de prototipo del objeto corriente creada para la clonación de la interfaz. Cuando el coste directo de la creación de objetos de relativamente grande, utilizando este modelo. Por ejemplo, un objeto necesita ser creado después de la base de datos es una operación costosa. Podemos almacenar en caché el objeto y devuelve un clon de ella cuando una solicitud siguiente, para actualizar la base de datos cuando sea necesario, con el fin de reducir las llamadas bases de datos.

En segundo lugar, las ventajas del modelo de prototipo

Excelente rendimiento: el modo de prototipo es una copia en la memoria de la secuencia binaria, un nuevo objeto es mucho mejor que el rendimiento, especialmente cuando un gran número de clase de objeto de bucle producido más pronunciada.
Escape de restricción constructor: esta es la coexistencia de las ventajas y desventajas que copian directamente en la memoria, no se llevará a cabo el constructor.

En tercer lugar, el modelo prototipo de escenarios de uso

Recursos escenario de inicialización: Clase de inicialización necesidad de consumir una gran cantidad de recursos de tiempo.
requisitos de rendimiento y seguridad de la escena: Las nuevas necesidades de objetos para producir una preparación y de acceso a datos muy tediosos tiempos.
Una pluralidad de objetos de escena modificadores: que necesita un objeto de facilitar el acceso a otros objetos, y puede necesitar ser modificado para tener en cuenta su valor de cada persona que llama.

　　Los actuales modelos de prototipo proyecto rara vez se producen solos, y el patrón general de la fábrica aparecen juntos, crean un método clone objeto, y luego se proporcionan a la persona que llama por el método de fábrica.

En cuarto lugar, la estructura y la implementación de modelos de prototipo

　　Dado que los objetos Java proporciona método clone (), con una aplicación Java del modelo de prototipo es muy sencillo, simplemente implementar la interfaz Cloneable y método clon de anulación () , en segundo lugar solamente al modo sencillo y un único patrón de realización iterador.

　　modelo de prototipo consiste en lo siguiente papel importante.

Resumen de la clase prototipo: especifica la interfaz debe implementar objeto prototipo específico.
prototipo clase DETALLADA: Prototipo clase abstracta implementar el método clone (), que se copia objeto.
Clases de acceso: mediante el método del prototipo de la clase específica clone () para copiar el nuevo objeto.

　　La estructura mostrada en la Figura:

　　Código se implementa de la siguiente manera:

// específica clase de prototipo 
de clase Realizetype los implementos de la Cloneable 
{ 
    Realizetype () 
    { 
        System.out.println ( "prototipo específico creado con éxito!" ); 
    } 
    Pública Objeto clone () lanza CloneNotSupportedException 
    { 
        System.out.println ( "éxito específica prototipo de réplica! " );
         de retorno  (Realizetype) Súper .clone () ; 
    } 
} 

// prueba del prototipo de clase modo 
público  de clase PrototypeTest 
{ 
    pública  estática  vacíoprincipal (String [] args) lanza CloneNotSupportedException 
    { 
        Realizetype obj1 = nuevo Realizetype (); 
        Realizetype obj2 = (Realizetype) obj1.clone (); 
        System.out.println ( "obj1 == obj2?" + (Obj1 == obj2)); 
    } 
}

　　Los resultados son como sigue:

el éxito de prototipos específicos!　　　　// Este constructor no lleva a cabo en el momento clon, porque el objeto es una memoria para copiar la forma en que la secuencia binaria, por supuesto, no se ejecutará a partir de un 
éxito específica prototipo de réplica! 
obj1 == obj2? falsa　　　// no es el mismo objeto

V. suplemento

　　1, no se ejecutará cuando el clon constructor

　　El método de construcción no realiza en el clon de tiempo, porque el objeto se copia del flujo binario de memoria de la forma, por supuesto, no realiza, en el ejemplo mostrado anteriormente.

　　2, copia profunda, copia superficial

　　El siguiente código, es copia superficial:

clase Thing2 implementos Cloneable {
     privado ArrayList <String> list = nuevo ArrayList <String> (); 

    @ Override 
    pública clon Thing2 () { 
        Thing2 cosa = nula ;
        tratar { 
            cosa = (Thing2) súper .clone (); 
        } Catch (CloneNotSupportedException e) { 
            e.printStackTrace (); 
            System.out.println ( "克隆失败" ); 
        } 
        Devolver cosa; 
    } 

    Pública  nulasetValue (valor String) {
         este .list.add (valor); 
    } 

    Pública ArrayList getValue () {
         volver  este .list; 
    } 
} 

Pública  clase SimpleClone {
     públicas  estáticas  void main (String [] args) { 
        Thing2 cosa = nueva Thing2 (); 
        thing.setValue ( "张三" ); 
        Thing2 cloneThing = thing.clone (); 
        cloneThing.setValue ( "李四" ); 
        System.out.println (thing.getValue ()); 
    } 
}

　　Los resultados de prueba se emiten las siguientes:

objeto original: [John Doe] 
clon: [John Doe]

　　modo de prototipo objeto clonado debería ser independientes entre sí, entonces ¿por qué hay un acceso compartido entre el original y el clon de ella?

　　Esto es porque el método de clon únicamente copias de la clase de objeto objetos presentes, el objeto de matriz interna, objeto de referencia, etc. no se copian, o la dirección que apunta a los elementos internos de los objetos nativos, la copia superficial es una copia . Dos objetos comparten una variable privada. Esta es una manera muy inseguro.

　　Los tipos primitivos se copiarán (int, double, larga ...) , Cadena se copiará tipo; Tipo de referencia de matriz no se copiará .

　　Cuando se utiliza un tipo de prototipo, las variables miembro de referencia debe satisfacer dos condiciones no se copiarán:

Es una variables miembro de clase, en lugar de variables dentro del método
Debe ser un objeto de referencia variable, en lugar de un tipo primitivo o objetos inmutables (como final)

　　copia profunda es la siguiente:

clase thing1 implementos Cloneable {
     privado ArrayList <String> list = nuevo ArrayList <String> (); 

    @ Override 
    pública clon thing1 () { 
        thing1 cosa = nula ;
        tratar { 
            cosa = (thing1) súper .clone (); 
            thing.list = (ArrayList) esta .list.clone (); 
        } Catch (CloneNotSupportedException e) { 
            e.printStackTrace (); 
            System.out.println ( "克隆失败" ); 
        }
        volver cosa; 
    } 

    Pública  vacío setValue (Valor de la cadena) {
         este .list.add (valor); 
    } 

    Pública ArrayList getValue () {
         volver  este .list; 
    } 
} 

Pública  de clase DeepClone {
     públicas  estáticas  void main (String [] args) { 
        thing1 cosa = nueva thing1 (); 
        thing.setValue ( "张三" ); 
        Thing1 cloneThing = thing.clone (); 
        cloneThing.setValue ( "李四" ); 
        System.out.println ("Objeto Original:" + thing.getValue ()); 
        System.out.println ( "clon:" + cloneThing.getValue ()); 

    } 
}

　　La salida es:

objeto original: [Zhang] 
clon: [John Doe]

　　nota:

Profundo y copia copia superficial a ser implementados por separado, o harán que el programa para llegar a ser muy compleja
Variable con el tipo de copia final no es tan no puede lograrse copia profunda.

　　Esto se debe a las características de la palabra clave final

　　Para una variable final, si los tipos de datos básicos de las variables, entonces su valor no se puede cambiar una vez después de la inicialización, y si es una variable de tipo de referencia, a continuación, después de su inicialización no permitirá su punto a otro objeto. Por lo tanto: Para utilizar el clon () no aumentar la palabra clave final en el método de variables miembro de la clase.

　　3 extendida, el modelo de prototipo

　　prototipo de modelo puede ser extendido con un prototipo del gestor de modelo de prototipo, que añade un gestor de prototipo clases PrototypeManager sobre la base de un modelo prototipo. Esta clase con un HashMap guardar copias múltiples del prototipo, la clase de cliente puede obtener una copia del prototipo (String id) get del gerente. La estructura mostrada en la Figura:

　　Código es el siguiente:

importar java.util. * ;
interfaz Shape se extiende Cloneable 
{ 
    público clon Object ();    // 拷贝
    pública  vacío countArea ();    // 计算面积
}
 clase Circle implementos Forma 
{ 
    público clon Object () 
    { 
        Circle w = nulo ;
        tratar 
        { 
            w = (círculo) súper .clone (); 
        } 
        Catch (CloneNotSupportedException e) 
        { 
            System.out.println ("Copia no redonda!" ); 
        } 
        Volver W; 
    } 
    pública  vacío countArea () 
    { 
        int R ^ = 0 ; 
        de System.out.print ( "Esto es un círculo, el radio del círculo entran:" ); 
        escáner ENTRADA = nuevo nuevo escáner (la System.in); 
        R & lt = input.nextInt (); 
        System.out.println ( "área del círculo =" + 3,1415 * R & lt * lt + "\ n-" I + ); 
    } 
} 
clase Square los implementos la Forma 
{ 
    público clon Object ( ) 
    { 
        Square B= NULL ;
         input.nextInt ();el try 
        { 
            B = (Square) Súper .clone (); 
        } 
        la captura (CloneNotSupportedException E) 
        { 
            System.out.println ( "no copia cuadrado!" ); 
        } 
        retorno de B; 
    } 
    pública  vacío countArea () 
    { 
        int A = 0 ; 
        de System.out.print ( "este es un cuadrado, la longitud del lado que introduzca:" ); 
        de entrada del escáner = nuevo nuevo escáner (la System.in); 
        un = ); 
    }
        System.out.println ( "该正方形的面积=" + a * a + "\ n"
} 
Clase ProtoTypeManager 
{ 
    privado HashMap <String, Forma> ht = nuevo HashMap <String, Forma> (); 
    pública ProtoTypeManager () 
    { 
        ht.put ( "Círculo", nuevo círculo ()); 
        ht.put ( "Square", nueva Square ()); 
    } 
    Pública  vacío addShape (String key, Forma obj) 
    { 
        ht.put (clave, obj); 
    } 
    Pública Forma getShape (String key) 
    { 
        Forma temp = ht.get (clave);
        retorno (Forma) temp.clone ();
    } 
} 
Pública  de clase ProtoTypeShape 
{ 
    públicas  estáticas  void main (String [] args) 
    { 
        ProtoTypeManager pm = nueva ProtoTypeManager ();    
        Forma obj1 = (círculo) pm.getShape ( "Circle" ); 
        obj1.countArea ();          
        Forma obj2 = (Forma) pm.getShape ( "Square" ); 
        obj2.countArea ();     
    } 
}

　　Resultados del ensayo:

Esta es una circular, introduzca el radio del círculo: 3 
área del círculo = 28,2735 

Este es un cuadrado, introduzca su longitud lateral: 3 
área del cuadrado = 9