Este artigo descreve o modo de diversão do padrão de design Java. Compartilhe -o para sua referência, como segue:
Explique o conceito: ou seja, se houver vários objetos idênticos em um sistema, basta compartilhar uma cópia e não há necessidade de instanciar um objeto para cada um. Por exemplo, em um sistema de texto, cada letra é definida como um objeto; portanto, existem 52 letras superiores e minúsculas, para que 52 objetos precisem ser definidos. Se houver um texto de 1M, existem muitas letras. Se cada letra definir um objeto, a memória teria explodido há muito tempo. Então, se cada letra compartilhar um objeto, ele economizará muito recursos.
No modo de peso mosca, como vários objetos devem ser gerados, o modo de fábrica geralmente aparece no modo de peso mosca. O estado interno do peso mosca é usado para compartilhar. A Flyweight Factory é responsável por manter um pool de armazenamento de objetos (pool de peso mosca) para armazenar objetos com estado interno. O Modo Flyweight é um modo que melhora a eficiência e o desempenho do programa, que acelerará bastante a velocidade de execução do programa. Existem muitas ocasiões de aplicação, como segue:
Primeiro defina uma aula abstrata de peso mosca:
Pacote Flyweight; Public Abstract Class Flyweight {Public Abstract Void Operação ();}Implementar uma classe específica:
Pacote Flyweight; Public Class ConcreteFlyweight estende o peso mosca {private string string; public concreteflyweight (string str) {string = str;} public void Operação () {System.out.println ("Concrete --- Flyweight:" + string);}}}Implementar uma classe de método de fábrica:
Pacote Flyweight; importar java.util.hashtable; public class FlyweightFactory {Private Hashtable Flyweights = novo Hashtable (); // ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nulo){//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Esta classe de método de fábrica é muito crítica, aqui está uma explicação detalhada:
A hashtable é definida em 1 para armazenar cada objeto; Um objeto a ser instanciado é selecionado em 2 e o objeto a ser retornado em 6. Se não houver um objeto a ser selecionado na hashtable, o peso da mosca variável é nulo e um novo peso de mosca é gerado para ser armazenado na hashtable e o objeto é retornado.
Por fim, vamos dar uma olhada na chamada do peso mosca:
Pacote Flyweight; importar java.util.hashtable; public class FlyweightPattern {FlyweightFactory Factory = new FlyweightFactory (); Flyweight Fly1; Flyweight Fly2; Flyweight Fly3; Flyweight Fly4; Factory.getflyweight ("Google"); Fly2 = Factory.getflyweight ("QUTR"); FLY3 = FACTORY.GETFLYWEIR ("Google"); Fly4 = Factory.getFlyweight ("Google"); Fly5 = Factory.getflyweight ("Google); showflyweight () {fly1.operation (); fly2.operation (); fly3.operation (); fly4.operation (); fly5.operation (); fly6.operation (); int objSize = factory.getflyweightSize (); system.out.println ("objsize ="]] args) {System.out.println ("O padrão de peso mosca!"); FlyweightPattern fp = new FlyweightPattern (); fp.showflyweight ();}}}Aqui estão os resultados em execução:
Concreto --- peso mosca: Google
Concreto --- Flyweight: Qutr
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
objSize = 2
Definimos 6 objetos, 5 dos quais são iguais. De acordo com a definição do modo de peso mosca, "Google" deve compartilhar um objeto. No número real de objetos, podemos ver que existem apenas 2 objetos.
Resumir:
O modo de peso mosca é tão importante porque pode ajudá -lo a economizar muito espaço de memória em um sistema complexo. No idioma java, o tipo de sequência usa o modo de enciclopédia. O objeto String é do tipo final e não pode ser alterado depois de ser criado. Em Java, as constantes de cordas estão presentes no pool constante. O Java garantirá que uma constante de corda tenha apenas uma cópia no pool constante. String a = "ABC", onde "ABC" é uma constante de string.
Aqueles que estão familiarizados com Java devem saber o seguinte exemplo:
String a = "hello"; string b = "hello"; if (a == b) system.out.println ("ok"); elSesystem.out.println ("error");O resultado da saída é: OK. Pode -se observar que se a condição comparar os endereços de dois A e B, ou pode -se dizer que é um espaço de memória
Resumo do núcleo: Objetos que podem ser compartilhados, ou seja, objetos do mesmo tipo retornados são realmente a mesma instância. Quando o cliente exige que um objeto seja gerado, a fábrica detectará se existe uma instância desse objeto. Se existir, retorne diretamente esta instância do objeto. Se não existir, crie e salve -o. Isso tem algum significado de padrão de singleton. Geralmente, a classe de fábrica terá uma variável de membro do tipo de conjunto para salvar objetos, como hashtable, vetor, etc. em java, pools de conexão de banco de dados, pools de threads, etc. são aplicativos que usam o modo Enyuan.
Para mais conteúdo relacionado ao Java, os leitores interessados neste site podem visualizar os tópicos: "Estrutura de dados Java e tutorial de algoritmo", "Resumo da operação Java Dom Node Tips", "Resumo de Dicas de Operação de Arquivos e Diretórios de Java" e "Resumo das dicas de operação do Java Cache"
Espero que este artigo seja útil para a programação Java de todos.