de modo de patrón de diseño exterior (la fachada) y código de ejemplos detallados

Definición de un modelo de apariencia

　　Definir la apariencia (la fachada) Modo: Modo de la fachada conocida, es una a través de proporcionar una interfaz consistente a múltiples subsistemas complejos , subsistemas que el patrón que se acceda más fácilmente. El modelo tiene una interfaz unificada para las aplicaciones externas, externos no se preocupan por los detalles específicos de los subsistemas internos, que reduciría en gran medida la complejidad de la aplicación, mejorar la capacidad de mantenimiento del programa.

En segundo lugar, las ventajas y desventajas de aspecto del modelo

　　ventajas:

• Simplificar el proceso de llamada, sin tener que saber detallada del subsistema, prevenir riesgos
• sistemas de reducción de confiar, débilmente acoplados
• nivel de división mejor acceso
• De acuerdo con la Ley de Demeter, a saber, el principio de mínima conocimientos

　　desventajas:

• Aumentar subsistema, el subsistema de expansión fácil de introducir el comportamiento de riesgo
• No cumple con el principio de apertura y cierre

En tercer lugar, para lograr el modo de aparición

　　Apariencia del modelo de estructura (Fachada) es relativamente simple, es la definición de una interfaz de alto nivel. Contiene una referencia a los diversos subsistemas, el cliente puede acceder a él a través de los diversos subsistemas. Ahora, para analizar la estructura y la implementación básica.

　　Aspecto modelo (Fachada) consiste en lo siguiente papel importante.

• Apariencia (Fachada) función: proporcionar un múltiplo común de subsistema de interfaz externa.
• Subsistema papel (Sub System): para lograr parte de las funciones del sistema, los clientes pueden acceder a él a través de la aparición de los caracteres.
• Cliente (Client) Función: el acceso de los diferentes subsistemas de la aparición de un papel.

　　La estructura mostrada en la Figura:

　　　　　　　　　　　　　　

　　Los códigos son comunes en ambos casos pertenecen al modelo de apariencia, el siguiente código:

　　Todos los subsistemas para lograr una interfaz unificada:

pública  interfaz del Sistema {
     público  vacío doSomething (); 
} 

pública  clase SubSystemA los instrumentos del sistema { 

    público  vacío doSomething () { 
        System.out.println ( "Subsistema Método A" ); 
    } 
} 

pública  clase SubSystemB los instrumentos del Sistema { 

    público  vacío doSomething () { 
        System.out.println ( "subsistema método B" ); 
    } 
} 

pública  clase del Fachada { 

    // delegado objeto de 
    la Sistema a, B; 
    
    públicaFachada () { 
        a = nuevo SubSystemA (); 
        b = nuevo SubSystemB (); 
    } 
    
    // 提供给外部访问的方法
    pública  vacío MethodA () {
         este .a.dosomething (); 
    } 
    
    Pública  vacío methodB () {
         este .b.dosomething (); 
    } 
} 

Pública  clase de cliente { 

    públicas  estáticas  void main (String [] args) { 
        Fachada Fachada = nueva fachada (); 
        
        facade.methodA (); 
        facade.methodB ();
    } 
}

　　No todos los subsistemas para lograr una interfaz unificada:

público  de clase SubSystemA { 

    público  vacío dosomethingA () { 
        System.out.println ( "Subsistema Método A" ); 
    } 
} 

pública  clase SubSystemB { 

    público  vacío dosomethingB () { 
        System.out.println ( "Subsistema Método B" ); 
    } 
} 

pública  clase del Fachada { 

    // delegado objeto 
    SubSystemA a; 
    SubSystemB B; 
    
    pública la fachada () { 
        un = nueva nueva SubSystemA (); 
        B = nueva nueva SubSystemB (); 
    }
    
    // 提供给外部访问的方法
    pública  vacío MethodA () {
         este .a.dosomethingA (); 
    } 
    
    Pública  vacío methodB () {
         este .b.dosomethingB (); 
    } 
} 

Pública  clase de cliente { 

    públicas  estáticas  void main (String [] args) { 
        Fachada Fachada = nueva fachada (); 
        
        facade.methodA (); 
        facade.methodB (); 
    } 
}

　　resultados de la prueba son los siguientes:

Un método de subsistema 
subsistema Método B

el modo de aparición Escena del uso de cuatro

　　En general se puede considerar en la siguiente utilizando el modelo de apariencia.

• Subsistema más compleja, lo que aumenta la aparición del modelo proporciona una interfaz sencilla llamadas
• Construcción de la arquitectura del sistema de múltiples capas, usando el aspecto de cada objeto como una entrada, una simplificación de las llamadas inter-capa

modo de apariencia Extended V.

　　En el modo de aparición, al añadir o eliminar la necesidad de modificar el subsistema basado en la apariencia, lo cual es contrario al "principio de encendido-apagado". Si la introducción de la aparición clase abstracta, es en cierta medida a resolver el problema, la estructura que se muestra en la figura Fig.:
　　　　　　　　　　 

　　Código es el siguiente:

público  clase FacadePattern 
{ 
    público  estáticas  void principales (String [] args) 
    { 
        Fachada f = nuevo FacadeImpl1 (); 
        f.method (); 
        f = nuevo FacadeImpl2 (); 
        f.method (); 
    } 
} 

Interfaz Fachada {
     público  vacío método (); 
} 

// 外观角色
clase FacadeImpl1 implementos Facede 
{ 
    privado SubSystem01 obj1 = nueva SubSystem01 ();
    privadoSubSystem02 obj2 = nuevo SubSystem02 ();
    privada SubSystem03 obj3 = nueva SubSystem03 ();
    pública  vacío método () 
    { 
        obj1.method1 (); 
        obj2.method2 (); 
        obj3.method3 (); 
    } 
} 
// 外观角色
clase FacadeImpl1 implementos Facede 
{ 
    privado SubSystem02 obj2 = nueva SubSystem02 ();
    privada SubSystem03 obj3 = nueva SubSystem03 ();
    privada SubSystem04 obj4 = nueva SubSystem04 ();
    público vacío Método () 
    { 
        obj2.method2 (); 
        obj3.method3 (); 
        obj4.method4 (); 
    } 
} 

// carácter subsistema de 
clase SubSystem01 
{ 
    público   nula la metodo1 () 
    { 
        System.out.println ( "Subsistema 01 metodo1 () se llama! " ); 
    }    
} 
// subsistemas papel 
de clase SubSystem02 
{ 
    público   vacío metodo2 () 
    { 
        System.out.println ( " sub-02 metodo2 () se llama "! ); 
    }    
} 
// sub rol del sistema 
de clasesSubSystem03 
{ 
    público   vacío metodo3 () 
    { 
        System.out.println ( "sub-03 metodo3 () se llama!" ); 
    }    
} 
// función subsistemas 
clase SubSystem04 
{ 
    público   vacío método 4 () 
    { 
        System.out.println ( "subsistema 04 método 4 () se llama!" ); 
    }    
}