¿Cuál es el modo decorador?
Agregue dinámicamente algunas responsabilidades adicionales a un objeto. En términos de agregar funciones, el modo decorador es más flexible que generar subclases.
1. Estructura
Componente: define una interfaz de objeto que puede agregar dinámicamente responsabilidades a estos objetos.
Componente de interfaz {public void operation ();} ConcreteComponent: implementa la interfaz definida por componente. clase ConcreteComponent implementa componente {@Override public void operation () {system.out.println ("comportamiento inicial"); }} Decorador: Decorar la clase abstracta, hereda el componente, extiende las funciones de la clase de componentes de clases externas, pero para el componente, no es necesario saber la existencia de decorador.
Class Decorator implementa el componente {// Mantenga un objeto componente y forme una relación de agregación con componente componente protegido por componente; // Pase en el objeto para modificar adicionalmente el decorador público (componente componente) {this.component = componente; } @Override // llame al método original a modificar public void operation () {component.operation (); }} Concretedecorator: los objetos decorativos específicos juegan la función de agregar responsabilidades al componente.
clase Concretedecoratora extiende Decorator {String privado Se agregaState = "Nueva propiedad 1"; public ConcretedEcoratora (componente componente) {super (componente); } Operación pública vacía () {super.operation (); System.out.println ("Agregar atributo:" + agregadoState); }} La clase ConcretedecoratorB extiende el decorador {public ConcretedeCoratorB (componente componente) {super (componente); } Operación pública vacía () {super.operation (); Agregado } public void agregedBehavior () {System.out.println ("Agregar comportamiento"); }} Código de prueba
clase pública decoratorPattern {public static void main (string [] args) {componente componente = new ConcreteComponent (); componente.operation (); System.out.println("================================================================================================== ============================================================= ============================================================== ============================================================= ============================================================= ============================================================= ============================================================== System.out.println("================================================================================================ System.out.output(); }} Resultados de ejecución
Inicial Comportamiento ============================================================ =================================================================== =================================================================== ===================================================================
2. Escenarios de aplicación
1. Es necesario agregar responsabilidades a un objeto dinámica y transparentemente, es decir, no afecta a otros objetos.
2. Debe agregar dinámicamente funciones a un objeto, y estas funciones pueden deshacerse dinámicamente.
3. Es necesario agregar una gran cantidad de funciones generadas por el arreglo y la combinación de algunas funciones básicas, de modo que la relación de herencia se vuelve poco realista.
4. Cuando el método de generar subclases no se puede usar para la expansión. Un escenario es que puede haber una gran cantidad de extensiones independientes, lo que producirá una gran cantidad de subclases para apoyar cada combinación, lo que provoca que explote el número de subclases. Otro caso puede deberse a que la definición de clase está oculta o la definición de clase no puede usarse para generar subclases.
3. Puntos clave
1. Los objetos decorativos y los objetos reales tienen la misma interfaz. De esta manera, el objeto del cliente puede interactuar con el objeto decorativo de la misma manera que el objeto real.
2. El objeto decorativo contiene una referencia a un objeto real.
3. El objeto decorativo acepta todas las solicitudes del cliente. Reenvía estas solicitudes al objeto real.
4. Los objetos decorativos pueden agregar algunas funciones adicionales antes o después de reenviar estas solicitudes. Esto asegura que en tiempo de ejecución, se puedan agregar funciones adicionales externamente sin modificar la estructura de un objeto dado. En el diseño orientado a objetos, las extensiones funcionales a una clase dada generalmente se logran a través de la herencia.
Lo anterior es una introducción al contenido relevante sobre el modo decorador Java, espero que sea útil para el aprendizaje de todos.