JAVA设计模式——外观模式

什么是外观模式？

外观模式（Facade）,他隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。

通过类图来理解：

代码：
子系统：

public class ModuleA {
    //示意方法
    public void testA(){
        System.out.println("调用ModuleA中的testA方法");
    }
}

public class ModuleB {
    //示意方法
    public void testB(){
        System.out.println("调用ModuleB中的testB方法");
    }
}

public class ModuleC {
    //示意方法
    public void testC(){
        System.out.println("调用ModuleC中的testC方法");
    }
}

外观类:

public class Facade {
    //示意方法，满足客户端需要的功能
    public void test(){
        ModuleA a = new ModuleA();
        a.testA();
        ModuleB b = new ModuleB();
        b.testB();
        ModuleC c = new ModuleC();
        c.testC();
    }
}

客户端角色类：

public class Client {
    public static void main(String[] args) { 
        Facade facade = new Facade();
        facade.test();
    }
}

实例：

public class test1 {

	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.open();
		computer.close();
	}

}

class Disk {
	public void open() {
		System.out.println("open Disk");
	}

	public void close() {
		System.out.println("close Disk");
	}
}

class Momery {
	public void open() {
		System.out.println("open Momery");
	}

	public void close() {
		System.out.println("close Momery");
	}
}

class CPU {
	public void open() {
		System.out.println("open  CPU");
	}

	public void close() {
		System.out.println("close  CPU");
	}
}

class Computer {
	CPU cpu = new CPU();
	Momery momery = new Momery();
	Disk disk = new Disk();

	public void open() {
		cpu.open();
		momery.open();
		disk.open();
	}

	public void close() {
		cpu.close();
		momery.close();
		disk.close();
	}
}

总结：Facade类其实相当于A、B、C模块的外观界面，有了这个Facade类，那么客户端就不需要亲自调用子系统中的A、B、C模块了，也不需要知道系统内部的实现细节，甚至都不需要知道A、B、C模块的存在，客户端只需要跟Facade类交互就好了，从而更好地实现了客户端和子系统中A、B、C模块的解耦，让客户端更容易地使用系统。

使用门面模式还有一个附带的好处，就是能够有选择性地暴露方法。一个模块中定义的方法可以分成两部分，一部分是给子系统外部使用的，一部分是子系统内部模块之间相互调用时使用的。有了Facade类，那么用于子系统内部模块之间相互调用的方法就不用暴露给子系统外部了。

public class test1 {

	public static void main(String[] args) {
		ModuleFacade M = new ModuleFacade();
		M.facade();
	}

}

class ModuleA {
	public void a1() {
		System.out.println("public a1");
	};// 提供给子系统外部使用的方法

	private void a2() {
		System.out.println("private a2");
	};// 子系统内部模块之间相互调用时使用的方法

	private void a3() {
		System.out.println("private a3");
	};
}

class ModuleB {
	public void b1() {
		System.out.println("public b1");
	};// 提供给子系统外部使用的方法

	private void b2() {
		System.out.println("public b2");
	};// 子系统内部模块之间相互调用时使用的方法

	private void b3() {
		System.out.println("public b3");
	};
}

class ModuleC {
	public void c1() {
		System.out.println("public c1");
	};// 提供给子系统外部使用的方法

	private void c2() {
		System.out.println("public c2");
	};// 子系统内部模块之间相互调用时使用的方法

	private void c3() {
		System.out.println("public c3");
	};
}

class ModuleFacade {

	ModuleA a = new ModuleA();
	ModuleB b = new ModuleB();
	ModuleC c = new ModuleC();// 下面这些是A、B、C模块对子系统外部提供的方法

	public void facade() {
		a.a1();
		b.b1();
		c.c1();
	}
}

这样定义一个ModuleFacade类可以有效地屏蔽内部的细节，免得客户端去调用Module类时，发现一些不需要它知道的方法。比如a2()和a3()方法就不需要让客户端知道，否则既暴露了内部的细节，又让客户端迷惑。对客户端来说，他可能还要去思考a2()、a3()方法用来干什么呢？其实a2()和a3()方法是内部模块之间交互的，原本就不是对子系统外部的，所以干脆就不要让客户端知道。

总结：
一个系统可以有几个门面类？
　　在门面模式中，通常只需要一个门面类，并且此门面类只有一个实例，换言之它是一个单例类。当然这并不意味着在整个系统里只有一个门面类，而仅仅是说对每一个子系统只有一个门面类。或者说，如果一个系统有好几个子系统的话，每一个子系统都有一个门面类，整个系统可以有数个门面类。

为子系统增加新行为？
初学者往往以为通过继承一个门面类便可在子系统中加入新的行为，这是错误的。门面模式的用意是为子系统提供一个集中化和简化的沟通管道，而不能向子系统加入新的行为。
门面模式的优点：
　　　（1）松散耦合
　　门面模式松散了客户端与子系统的耦合关系，让子系统内部的模块能更容易扩展和维护。
　　　（2）简单易用
　　门面模式让子系统更加易用，客户端不再需要了解子系统内部的实现，也不需要跟众多子系统内部的模块进行交互，只需要跟门面类交互就可以了。
　　（3）　更好的划分访问层次
　　通过合理使用Facade，可以帮助我们更好地划分访问的层次。有些方法是对系统外的，有些方法是系统内部使用的。把需要暴露给外部的功能集中到门面中，这样既方便客户端使用，也很好地隐藏了内部的细节。