设计模式之结构型2

设计模式之结构型2

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

1. 装饰模式

装饰模式(Decorator),动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

• 装饰模式结构图

  

  • Component,是定义一个对象接口，可以给这些对象动态地添加职责。
  • ConcreteComponent,是定义了一个具体的对象，也可以给这个对象添加一些职责。
  • Decorator，装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的。
  • ConcreteDecorator,就是具体的装饰对象，起到给Component添加职责的功能。

• 代码实现

  • Component类

    abstract class Component{
        public abstract void Operation();
    }
    

  • ConcreteComponent类

    class ConcreteComponent implements Component{
        
        @override
        public void Operation(){
            
            System.out.println("具体对象的操作");
        }
    }
    

  • Decorator类

    abstract class Decorator implements Component{
        
        protect Compoent component;
        
        public void SetComponent(Component component){
            this.component = component;
        }
        
        @override
        public  void Operation(){
            //重写Operation(),实际执行的是Component的Operation()
            if(component != null){
                
                component.Operation();
            }
        }
    }
    

  • ConcreteDecotator类

    class ConcreteDecoratorA implements Decorator{
        
        //本类独有的功能，以区别于ConcreteDecoratorB
        private String addedState;
        
        @override
        public override void Operation(){
            //首先运行原Component的Operation(),再执行本类的功能，如
            //addedState,相当于对原Component进行了装饰
            base.Operation();
            addedState = "New State";
            System.out.println("具体装饰对象A的操作");
        }
    }
    
    class ConcreteDecoratorB implements Decorator{
        
        @override
        public override void Operation(){
            //首先运行原Component的Operation(),再执行本类的功能，如
            //addedState,相当于对原Component进行了装饰
            base.Operation();
            AddedBehavior();
            System.out.println("具体装饰对象B的操作");
        }
        
        //本类独有的方法，以区别于ConcreteDecoratorB
        private void AddedBehavior(){
            
        }
    }
    

  • 客户端代码

    static void Main(string[] args){
        
        ConcreteComponent c = new ConcreteComponent();
        ConcreteDecoratorA d1 = new ConcreteDecoratorA();
        ConcreteDecoratorB d2 = new ConcreteDecoratorB();
        
        //装饰的方法是，首先用ConcreteComponent实例化对象c，然后用ConcreteDecoratorA的实例化对象d1来包装c，再用ConcreteDecoratorB的对象d2包装d1，最终执行d2的Operation()
        d1.SetComponent(c);
        d2.SetComponent(d1);
        d2.Operation();
        
        Console.Read();
    }
    

• 以穿衣服为例

  • 代码结构图

    

  • Person类(ConcreteComponent)

    class Person{
        
        public Person(){}
        
        private String name;
        public Person(String name){
            
            this.name = name;
        }
        
        public void show(){
            System.out.println("装扮的{0}",name);
        }
    }
    

  • 服饰类(Decorator)

    class Finery implements Person{
        
        protected Person person;
        
        //打扮
        public void Decorate(Person person){
            this.person = person;
        }
        
        @override
        public void Show(){
            if(person != null){
                person.show();
            }
        }
    }
    

  • 具体服饰类(ConcreteDecorator)

    class TShirt implements Finery{
        
        @override
        public void show(){
            System.out.println("大T恤");
            super.show();
        }
    }
    
    class BigTrouser implements Finery{
        
        @override
        public void show(){
            System.out.println("跨裤");
            super.show();
        }
    }
    

  • 客户端代码

    static void main(String[] args){
        
        Person xc = new Person("小菜");
        
        Sneakers pqx = new Sneakers();
        BigTrouser kk = new BigTrouser();
        TShirts dtx = new TShirts();
        
        //装饰过程
        pqx.Decorate(xc);
        kk.Decorate(pqx);
        dtx.Decorate(kk);
        dtx.show();
        
        System.out.println("第二种装扮：");
        
        ...
    }
    

• 总结

  装饰模式可以将核心类和装饰功能区分开来，去除相关类中重复的装饰逻辑。

2. 外观模式

外观模式(Facade),为子系统的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

• 外观模式结构图

  

• 代码实现

  • 四个子系统的类

    class SubSystemOne{
        
        public void methodOne(){
            System.out.println("子系统方法一");
        }
    }
    
    class SubSystemTwo{
        
        public void methodTwo(){
            System.out.println("子系统方法二");
        }
    }
    
    class SubSystemThree{
        
        public void methodThree(){
            System.out.println("子系统方法三");
        }
    }
    
    class SubSystemFour{
        
        public void methodFour(){
            System.out.println("子系统方法四");
        }
    }
    

  • 外观类

    class Facade{
        
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        SubSystemFour four;
        
        public Facade(){
            
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
            four = new SubSystemFour();
        }
        
        public void methodA(){
            
            System.out.println("方法组A-------");
            one.method();
            two.method();
            four.method();
        }
        
         public void methodB(){
             
            System.out.println("方法组B-------");
            two.method();
            three.method();
        }
    }
    

  • 客户端调用

    static void main(String[] args){
        
        Facade facade = new Facade();
        
        facade.methodA();
        facade.methodB();
    }
    

• 总结

  对于复杂的难以维护的老系统，直接修改或者去扩展可能产生很多的问题，分成两个小组，一个开发Facade与老系统交互，另一个只要了解Facade的接口，直接开发新系统调用这些接口即可。

3. 适配器模式

适配器模式(Adapter),将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

• 适配器模式结构图

  

• 代码实现

  • Target(这是客户所期待的接口)

    class Target{
        public abstract void Request(){
            System.out.println("普通请求！");
        }
    }
    

  • Adaptee(需要适配的类)

    class Adaptee{
        public void SpecificRequest(){
             System.out.println("特殊请求！");
        }
    }
    

  • Adapter(通过在内部包装一个Adaptee对象，把源接口转换成目标接口)

    class Adapter implements Target{
        
        private Adaptee adaptee = new Adaptee();
        
        @override
        public void Request(){
            
            adaptee.SpecificRequest();
        }
    }
    

  • 客户端代码

    static void main(String[] args){
        Target target = new Adapter();
        target.Request();
    }
    

• 小结

  适配器模式其实是一种无奈之举。若在一开始就将兼容性考虑在内，就不会出现使用适配器模式才能协调的问题。