Java 模式3（结构模式） - 享元模式，门面模式，桥梁模式

1.享元模式 - Flyweight Pattern

享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。享元模式能做的关键是区分内蕴状态和外蕴状态。

一个内蕴状态是存储在享元对象内部的，并且不会随着环境改变而有所不同。因此一个享元可以具有内蕴状态并可以共享。

一个外蕴状态是随环境改变而改变的、不可以共享的状态。享元的外蕴状态必须由客户端保存，并在享元对象被创建之手，在需要使用的时候再传入到享元对象的。

根据所涉及的享元对象的内部表象，享元模式可以分成单纯享元模式和复合享元模式。

package CompositeFlyweight;public abstract class Flyweight {//externalState - external statusabstract public void operation(String externalState);}

package CompositeFlyweight;public class ConcretFlyweight extends Flyweight{private Character internalState = null;//internalState - internal statuspublic ConcretFlyweight(Character internalState){this.internalState = internalState;}@Overridepublic void operation(String externalState) {System.out.println("\nIntrinsic State = " +  internalState + ", Extrinsic State = " +  externalState);}}

package CompositeFlyweight;import java.util.HashMap;import java.util.Iterator;import java.util.Map;/** *  This ConcretCompositeFlyweight object is composed by Flyweight object. */public class ConcretCompositeFlyweight extends Flyweight{private HashMap<Character, Flyweight> files = new HashMap<Character, Flyweight>(10);public ConcretCompositeFlyweight(){};public void add(Character key, Flyweight fly){files.put(key, fly);}public void operation(String exState){Flyweight fly = null;for (Iterator<?> it = files.entrySet().iterator(); it.hasNext();){Map.Entry<Character, Flyweight> e = (Map.Entry<Character, Flyweight>)it.next();fly = e.getValue();fly.operation(exState);}}}

package CompositeFlyweight;import java.util.HashMap;import java.util.Iterator;import java.util.Map;public class FlyweightFactory {//Unique instance is defined hereprivate static final FlyweightFactory MY_INSTANCE = new FlyweightFactory();private HashMap<Character, Flyweight> files = new HashMap<Character, Flyweight>();/* * Private constructor */private FlyweightFactory(){};/* * Get unique instance method of the class */public static FlyweightFactory getInstance(){return MY_INSTANCE;}/* * Generate Flyweight object by this factory method */public Flyweight factory(String compositeState){ConcretCompositeFlyweight compositeFlyweight = new ConcretCompositeFlyweight();int length = compositeState.length();Character interState = null;for (int i = 0; i < length; i++){interState = new Character(compositeState.charAt(i));System.out.println("factory(" + interState + ")");compositeFlyweight.add(interState, this.factory(interState));}return compositeFlyweight;}/* * Generate Flyweight object by this factory method */public Flyweight factory(Character state){//Return indirectly if exist this state object;if (files.containsKey(state)){return files.get(state);}else {//if does not exist this state object, so create new one;Flyweight flyweight = new ConcretFlyweight(state);//Store it in fliesfiles.put(state, flyweight);return flyweight;}}/* * Check Flyweight object */public void checkFlyweight(){int i = 0;System.out.println("\n===========checkFlyweight()============");for (Iterator<?> it = files.entrySet().iterator(); it.hasNext();){Map.Entry<Character, Flyweight> entry = (Map.Entry<Character, Flyweight>)it.next();System.out.println("Item " + (++i) + ":" + entry.getKey());}}}

package CompositeFlyweight;public class Client {public static void main(String[] str){FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();Flyweight flyweight = flyweightFactory.factory("abac");flyweight.operation("Composite call");flyweightFactory.checkFlyweight();}}

Output:

factory(a)
factory(b)
factory(a)
factory(c)

Intrinsic State = b, Extrinsic State = Composite call

Intrinsic State = c, Extrinsic State = Composite call

Intrinsic State = a, Extrinsic State = Composite call

===========checkFlyweight()============
Item 1:b
Item 2:c
Item 3:a

2. 门面模式 - Facade

是对象的结构模式。外部与一个子系统的通信必须通过一个统一的门面（Facade）对象的进行，这就是门面模式。

门面模式中有两个角色：1）门面（Facade）角色：客户端可以调用这个角色的方法。此角色知道相关的（一个或多个）子系统的功能和责任。在正常情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去。2）子系统（Subsystem）角色：可以同时有一个或多个子系统。每一个子系统都不是一个单独的类，而是一个类的集合。每一个子系统都可以被客户端调用或者被门面角色调用。子系统并不知道门面的存在，对于子系统而言，门面仅仅是另外一个客户端而已。

一个系统可以有多个门面类

门面类为子系统增加新的行为

什么情况下使用门面模式：

1）为一个复杂的子系统提供一个简单的接口；2）子系统的独立性；3）层次化结构；

package Facade;public class Camera {public void turnOn(){System.out.println("Turning on the camera.");}public void turnOff(){System.out.println("Turning off the camera.");}public void rotate(int degree){System.out.println("Rotating the camera by " + degree + " degrees.");}}

package Facade;public class Light {public void turnOn(){System.out.println("Turning on the light.");}public void turnOff(){System.out.println("Turning off the light.");}public void changeBulb(){System.out.println("Changing the light-bulb.");}}

package Facade;public class Sensor {public void activate(){System.out.println("Activating the sensor.");}public void deactivate(){System.out.println("Deactivating the sensor.");}public void trigger(){System.out.println("The sensor has been triggered.");}}

package Facade;public class Alarm {public void activate(){System.out.println("Activating the alarm.");}public void deactivate(){System.out.println("Deactivating the alarm.");}public void ring(){System.out.println("Ring the alarm.");}public void stopRing(){System.out.println("stop the alarm.");}}

package Facade;public class securityFacade {private Camera camera1 = new Camera();private Camera camera2 = new Camera();private Light light1 = new Light();private Light light2 = new Light();private Light light3 = new Light();private Sensor sensor = new Sensor();private Alarm alarm = new Alarm();public void activate(){camera1.turnOn();camera2.turnOn();light1.turnOn();light2.turnOn();light3.turnOn();sensor.activate();alarm.activate();}public void deactive(){camera1.turnOff();camera2.turnOff();light1.turnOff();light2.turnOff();light3.turnOff();sensor.deactivate();alarm.deactivate();}}

package Facade;public class Client {private static securityFacade security = new securityFacade();public static void main(String[] str){security.activate();}}

Output:

Turning on the camera.
Turning on the camera.
Turning on the light.
Turning on the light.
Turning on the light.
Activating the sensor.
Activating the alarm.

3.桥梁模式 - Bridge - 开闭原则，组合/聚合复用原则 - 接口（Interface）模式 - 柄体（Handle and Body）模式

桥梁模式的用意是将“将抽像化（Abstraction）与实现化(Implementation)脱耦，使二者可以独立地变化。”

两个等级结构： 1）由抽象化角色和修正抽象化角色组成抽象化等级结构；2）由实现化角色和两个具体实现化角色所组成的实现化等级结构。

桥梁械所涉及的角色：1）抽象化角色：抽象化化出的定义，并保存一个对实现化对象的引用；2）修正抽象化角色：扩展抽象化角色，改变和修正父类对抽象化的定义。3）实现化角色：这个角色给出实现化的接口，但不给出具体的实现。必须指出，这个接口不一定和抽象化的接口定义相同，实际上，这两个接口可以非常不一样。实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层的操作。4）具体实现化角色：这个角色给出实现化角色接口的具体实现。

package Bridge;public abstract class AirplaneMaker {abstract public void product();}

package Bridge;public class Airbus extends AirplaneMaker{@Overridepublic void product() {System.out.println("Made by Airbus company");}}

package Bridge;public class Boeing extends AirplaneMaker{@Overridepublic void product() {System.out.println("Made by Boeing company");}}

package Bridge;public class MD extends AirplaneMaker{@Overridepublic void product() {System.out.println("Made by MD company");}}

package Bridge;public abstract class Airplane {protected AirplaneMaker maker;abstract public void fly();public void made(){maker.product();}}

package Bridge;public class PassangerPlane extends Airplane{@Overridepublic void fly() {System.out.println("Fly for taking passengers.");}}

package Bridge;public class CargoPlane extends Airplane{@Overridepublic void fly() {System.out.println("Fly for taking cargo.");}}

package Bridge;public class Client {public static Airplane passangerPlane, cargoPlane;/** * @param args */public static void main(String[] args) {passangerPlane = new PassangerPlane();passangerPlane.maker = new Airbus();cargoPlane = new CargoPlane();cargoPlane.maker = new MD();System.out.println("=============The passanger plane=================");passangerPlane.made();passangerPlane.fly();System.out.println("=============The cargo plane=================");cargoPlane.made();cargoPlane.fly();}}

Output:

=============The passanger plane=================
Made by Airbus company
Fly for taking passengers.
=============The cargo plane=================
Made by MD company
Fly for taking cargo.