Prototype modo padrão de design (o protótipo) Comentários e código de exemplo

I. Definições e Características de Prototype Modelo

　　Protótipo modo definido (o protótipo) são como se segue: com um exemplo já criada como um protótipo para criar um protótipo dos mesmos ou similares novos objectos, copiando este objecto protótipo. Ela pertence a 创建型projetar padrões para a criação de objetos duplicados, assegurando desempenho (muito eficiente para criar um objeto desta forma).

　　Este modelo é implementado um protótipo de interface do objeto atual criado para a clonagem da interface. Quando o custo direto da criação de objetos de relativamente grande, usando este modelo. Por exemplo, um objecto precisa de ser criado depois da base de dados é uma operação dispendiosa. Podemos armazenar em cache o objeto e retorna um clone dele quando uma solicitação seguinte, para atualizar o banco de dados, quando necessário, a fim de reduzir as chamadas de banco de dados.

Em segundo lugar, as vantagens do modelo de protótipo

• Excelente desempenho: o modo de protótipo é uma cópia em memória do fluxo binário, um novo objeto é muito melhor do que o desempenho, especialmente quando um grande número de classe de objeto circuito produziu mais pronunciada.
• Escapar construtor restrição: esta é a coexistência das vantagens e desvantagens que copiam na memória diretamente, o construtor não será implementada.

Em terceiro lugar, o modelo de protótipo de cenários de uso

• Resource cenário de inicialização: class necessidade de inicialização para consumir uma grande quantidade de recursos de tempo.
• Desempenho e requisitos de segurança da cena: As novas necessidades objeto para produzir um muito tediosas tempos de preparação e de acesso a dados.
• Uma pluralidade de objetos cena modificadores: um objeto precisa fornecer acesso a outros objetos, e cada chamador pode precisar ser modificado para considerar o seu valor.

　　Os modelos reais protótipos projeto raramente ocorrem sozinho, e padrão geral fábrica aparecem juntos, criar um método clone objeto, e depois fornecido para o chamador pelo método de fábrica.

Em quarto lugar, a estrutura e implementação dos protótipos

　　Porque objetos Java fornece método clone (), com uma implementação Java do modelo protótipo é muito simples, apenas implementar a interface Cloneable e método clone de sobreposição () , em segundo lugar apenas para o modo simples e um padrão único concretização iteração.

　　modelo de protótipo consiste no papel principal seguinte.

• classe abstrata protótipo: especifica a interface deve implementar objeto de protótipo específico.
• protótipo de classe DETALHADA: Protótipo classe abstrata implementar o método clone (), que é copiado objeto.
• classes de acesso: usando clone () método de protótipo de classe específica para copiar o novo objeto.

　　A estrutura mostrada na Figura:

　　　　　　　　　　　　　　

 　　Código é implementado da seguinte forma:

// específica classe de protótipos 
classe Realizetype os implementos da Cloneable 
{ 
    Realizetype () 
    { 
        System.out.println ( "protótipo específico criado com sucesso!" ); 
    } 
    Pública objeto clone () lança CloneNotSupportedException 
    { 
        System.out.println ( "sucesso específica protótipo replicar! " );
         retorno  (Realizetype) Super .clone () ; 
    } 
} 

// classe modo de teste do protótipo 
pública  classe PrototypeTest 
{ 
    público  estático  vazioprincipal (String [] args) lança CloneNotSupportedException 
    { 
        Realizetype Obj1 = novo Realizetype (); 
        Realizetype obj2 = (Realizetype) obj1.clone (); 
        System.out.println ( "obj1 == obj2?" + (Obj1 == obj2)); 
    } 
}

　　Os resultados são os seguintes:

sucesso prototipagem específico!　　　　// Este construtor não executa em tempo de clone, porque o objeto é uma memória para copiar a forma como o fluxo binário, é claro, não será executada a partir de um 
sucesso específico protótipo replicar! 
obj1 == obj2? falsa　　　// não é o mesmo objeto

V. suplemento

　　1, não será executada quando o clone construtor

　　O método de construção não se apresentar no clone de tempo, porque o objectivo é copiado do fluxo binário de memória na forma de curso não executa, no exemplo apresentado acima.

　　2, cópia profunda, cópia superficial

　　O código a seguir, é cópia superficial:

classe Thing2 implementos Cloneable {
     private ArrayList <String> list = new ArrayList <String> (); 

    @Override 
    pública clone Thing2 () { 
        Thing2 coisa = nulo ;
        tente { 
            coisa = (Thing2) Super .clone (); 
        } Captura (CloneNotSupportedException e) { 
            e.printStackTrace (); 
            System.out.println ( "克隆失败" ); 
        } 
        Retornar coisa; 
    } 

    Pública  vaziosetValue (valor de cadeia) {
         este .list.add (valor); 
    } 

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

Pública  classe SimpleClone {
     pública  estáticos  vazios principais (String [] args) { 
        Thing2 coisa = new Thing2 (); 
        thing.setValue ( "张三" ); 
        Thing2 cloneThing = thing.clone (); 
        cloneThing.setValue ( "李四" ); 
        System.out.printlnl (thing.getValue ()); 
    } 
}

　　Os resultados dos testes são produzidos como se segue:

objeto original: [John Doe] 
clone: [John Doe]

　　Modo protótipo objeto clonado deve ser independentes um do outro, então porque é que há um acesso compartilhado entre o original e clone-lo?

　　Isto é porque o método clone apenas exemplares da classe de objectos objectos presentes, o objeto de matriz interna, objecto de referência, etc, não são copiados, ou endereço que aponta para os elementos internos dos objectos nativas, a cópia superficial é uma cópia . Dois objetos compartilham uma variável privada. Esta é uma maneira muito inseguro.

　　tipos primitivos serão copiados (int, double, long ...) , String tipo serão copiados; tipo de referência matriz não serão copiados .

　　Ao usar um tipo de protótipo, variáveis ​​de membro referenciados deve satisfazer duas condições não serão copiados:

• É um membro variáveis ​​de classe, ao invés de variáveis ​​dentro do método
• Deve ser um objecto de referência variável, em vez de um tipo primitivo ou objetos imutáveis ​​(tais como final)

　　cópia profunda é a seguinte:

classe Thing1 implementos Cloneable {
     private ArrayList <String> list = new ArrayList <String> (); 

    @Override 
    pública clone Thing1 () { 
        Thing1 coisa = nulo ;
        tente { 
            coisa = (Thing1) Super .clone (); 
            thing.list = (ArrayList) esta .list.clone (); 
        } Captura (CloneNotSupportedException e) { 
            e.printStackTrace (); 
            System.out.println ( "克隆失败" ); 
        }
        retornar coisa; 
    } 

    Pública  vazio setValue (String value) {
         este .list.add (valor); 
    } 

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

Pública  classe DeepClone {
     pública  estáticos  vazios principais (String [] args) { 
        Thing1 coisa = new Thing1 (); 
        thing.setValue ( "张三" ); 
        Thing1 cloneThing = thing.clone (); 
        cloneThing.setValue ( "李四" ); 
        System.out.println ("Objeto original:" + thing.getValue ()); 
        System.out.printlnl ( "clone:" + cloneThing.getValue ()); 

    } 
}

　　A saída é:

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

　　Nota:

• Profunda e cópia cópia superficial a ser implementado separadamente, ou fará com que o programa para se tornar muito complexo
• Variável com o tipo de cópia final não é tão cópia profunda não pode ser alcançado.

　　Isso ocorre porque as características da palavra-chave final

　　Para uma variável final, se os tipos de variáveis ​​de dados básicos, então o seu valor não pode ser alterado uma vez que após a inicialização, se ela é uma variável de tipo de referência, em seguida, após a sua inicialização não vai permitir que o seu ponto para outro objecto. Portanto: Para usar o clone () não aumentar a palavra-chave final no método de variáveis ​​de membro, classe.

　　3 estendido, o modelo de protótipo

　　modelo de protótipo pode ser estendido com um protótipo do gerente modelo de protótipo, ele adiciona um gerente protótipo aulas PrototypeManager com base em um modelo de protótipo. Esta classe com um HashMap salvar várias cópias do protótipo, classe Cliente pode derivar uma cópia protótipo do get do Manager (id String) método. A estrutura mostrada na Figura:

　　　　　　　　　　　　　　　　

 　　Código é a seguinte:

importar java.util. * ;
interface de Forma estende Cloneable 
{ 
    público clone Objecto ();    // 拷贝
    pública  vazio countArea ();    // 计算面积
}
 classe Círculo implementos Forma 
{ 
    pública clone Object () 
    { 
        Círculo w = nulo ;
        tente 
        { 
            w = (Circle) Super .clone (); 
        } 
        Captura (CloneNotSupportedException e)  
        {
            System.out.printlnl ("Copiar rodada falhou!" ); 
        } 
        Retorno W; 
    } 
    pública  vazio countArea () 
    { 
        int R & lt = 0 ; 
        de System.out.print ( "Este é um círculo, o raio do círculo digite:" ); 
        Scanner ENTRADA = new new Scanner (a System.in); 
        P & lt = input.nextInt (); 
        System.out.printlnl ( "área do círculo =" + 3,1415 * P & lt * P & lt + "\ n-" ); 
    } 
} 
classe quadrado os implementos a Forma 
{ 
    público clone objecto ( ) 
    { 
        Quadrado B = nulo ;
        o try 
        { 
            B = (Square) Super .clone (); 
        } 
        a captura (CloneNotSupportedException E) 
        { 
            System.out.println ( "cópia falhou quadrado!" ); 
        } 
        return B; 
    } 
    pública  vazio countArea () 
    { 
        int a = 0 ; 
        de System.out.print ( "isto é um quadrado, o comprimento do lado que entra:" ); 
        Scanner input = novo novo Scanner (a System.in); 
        um = ); 
    } input.nextInt ();
        System.out.println ( "该正方形的面积=" + a * a + "\ n"
} 
Class ProtoTypeManager 
{ 
    privada HashMap <String, Forma> ht = new HashMap <String, Forma> (); 
    pública ProtoTypeManager () 
    { 
        ht.put ( "Circle", nova círculo ()); 
        ht.put ( "Square", nova Square ()); 
    } 
    Pública  vazio addShape (String chave, Forma obj) 
    { 
        ht.put (key, obj); 
    } 
    Público Forma getShape (String chave) 
    { 
        temperatura Forma = ht.get (chave);
        retorno (Forma) temp.clone ();
    } 
} 
Pública  classe ProtoTypeShape 
{ 
    pública  estáticos  vazios principais (String [] args) 
    { 
        ProtoTypeManager pm = new ProtoTypeManager ();    
        Forma Obj1 = (círculo) pm.getShape ( "Circle" ); 
        obj1.countArea ();          
        Forma obj2 = (Shape) pm.getShape ( "Square" ); 
        obj2.countArea ();     
    } 
}

　　Os resultados do teste:

Esta é uma circular, entre o raio do círculo: 3 
a área do círculo = 28,2735 

Este é um quadrado, introduzir o seu comprimento lateral: 3 
a área do quadrado = 9