Este artículo describe el modo de disfrute del patrón de diseño Java. Compártelo para su referencia, como sigue:
Explique el concepto: es decir, si hay múltiples objetos idénticos en un sistema, solo comparta una copia, y no hay necesidad de instanciar un objeto para cada uno. Por ejemplo, en un sistema de texto, cada letra se define como un objeto, por lo que hay 52 letras superiores y minúsculas, por lo que deben definirse 52 objetos. Si hay un texto de 1M, entonces hay tantas letras. Si cada letra define un objeto, la memoria habría explotado hace mucho tiempo. Luego, si cada letra comparte un objeto, entonces ahorrará recursos.
En el modo de peso mosca, dado que se generan varios objetos, el modo de fábrica a menudo aparece en modo de peso mosca. El estado interno del peso mosca se usa para compartir. Flyweight Factory es responsable de mantener un grupo de almacenamiento de objetos (piscina de peso mosca) para almacenar objetos con estado interno. El modo Flyweight es un modo que mejora la eficiencia y el rendimiento del programa, lo que acelerará en gran medida la velocidad de ejecución del programa. Hay muchas ocasiones de aplicación, como sigue:
Primero defina una clase abstracta de peso mosca:
Package Flyweight; Public Abstract Class Flyweight {Public Abstract Void Operation ();}Implementar una clase específica:
Package Flyweight; public class ConcreteflyWeight extiende Flyweight {private String String; public ConcreteFlyweight (String Str) {string = str;} public void operation () {System.out.println ("Concrete --- Flyweight:" + String);}}Implementar una clase de método de fábrica:
Package Flyweight; import java.util.hashtable; public class FlyweightFactory {PRIVED HASHTABLE FLYWEWSS = NUEVO Hashtable (); // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- nulo){//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------Esta clase de método de fábrica es muy crítica, aquí hay una explicación detallada:
Un hashtable se define en 1 para almacenar cada objeto; Se selecciona un objeto que se instancia en 2, y el objeto se devolverá a las 6. Si no hay ningún objeto que se seleccione en el hashtable, la mosca variable es nulo y se genera un nuevo peso mosca para almacenarse en la HAESHABLE, y el objeto se devuelve.
Finalmente, echemos un vistazo a la llamada de peso mosca:
paquete de peso mosca; import java.util.hashtable; public class FlyWeightPattern {FlyWeightFactory Factory = new FlyWeightFactory (); FlyWeight Fly1; FlyWeight Fly2; Flyweight Fly3; Flyweight Fly4; FlyWeight Fly5; FlyWeight Fly6;/***// ** crea una nueva instancia de Flylywewight FlyWeightpattern () {{Fly Fly1 = Fly1 = {Fly1 = {Fly1 = factory.getflyweight ("google"); fly2 = factory.getflyweight ("qutr"); fly3 = factory.getflyweight ("google"); fly4 = factory.getflyweight ("google"); fly5 = factory.getflyweight ("google"); fly6 = factory.getflyweight ("google");} public void showflyweight () {fly1.operation (); fly2.operation (); fly3.operation (); fly4.operation (); fly5.operation (); fly6.operation (); int objSize = factory.getflyWeSeSize (); system.out.println ("objsize =" + objSize);} Public static void (string [string [] string [] [] [] args) {System.out.println ("¡El patrón de peso mosca!"); FlyWeightPattern FP = new FlyWeightPattern (); fp.showflyweight ();}}Aquí están los resultados de ejecución:
Concreto --- peso mosca: Google
Concreto --- peso mosca: QUTR
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
Concreto --- peso mosca: Google
objSize = 2
Hemos definido 6 objetos, 5 de los cuales son los mismos. Según la definición de modo de peso mosca, "Google" debería compartir un objeto. En el número real de objetos, podemos ver que solo hay 2 objetos.
Resumir:
El modo de peso mosca es muy importante porque puede ayudarlo a guardar mucho espacio de memoria en un sistema complejo. En el idioma Java, el tipo de cadena usa el modo Enciclopedia. El objeto de cadena es de tipo final y no se puede cambiar una vez que se crea. En Java, las constantes de cadena están presentes en la piscina constante. Java se asegurará de que una constante de cadena solo tenga una copia en el grupo constante. Cadena a = "ABC", donde "ABC" es una constante de cadena.
Aquellos que están familiarizados con Java deben saber el siguiente ejemplo:
Cadena a = "hola"; cadena b = "hola"; if (a == b) system.out.println ("ok"); elsesystem.out.println ("error");El resultado de la salida es: OK. Se puede ver que si la condición compara las direcciones de dos A y B, o se puede decir que es espacio de memoria
Resumen del núcleo: los objetos que se pueden compartir, es decir, los objetos del mismo tipo devuelto son en realidad la misma instancia. Cuando el cliente requiere que se genere un objeto, la fábrica detectará si existe una instancia de este objeto. Si existe, entonces devuelva directamente esta instancia de objeto. Si no existe, cree y guárdelo. Esto tiene algún significado de patrón Singleton. Por lo general, la clase de fábrica tendrá una variable de tipo de tipo establecido para guardar objetos, como hashtable, vector, etc. en Java, grupos de conexión de bases de datos, grupos de subprocesos, etc. son aplicaciones que usan el modo Enyuan.
Para obtener más contenido relacionado con Java, los lectores interesados en este sitio pueden ver los temas: "Estructura de datos de Java y tutorial de algoritmo", "Resumen de las puntas de nodo de operación Java DOM", "Resumen de los archivos Java y consejos de operación de directorio" y "Summary of Java Cache Operation Tips" ".
Espero que este artículo sea útil para la programación Java de todos.