结构型模式--适配器、装饰器、外观模式（三）

「爱情、让人受尽委屈。」 2022-02-20 06:27 210阅读 0赞

**结构型模式涉及如何组合类和对象以形成更大的结构。继承的概念被用来组合接口和定义组合对象获得新功能的方式。**

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

## 适配器模式 ##

定义：将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以在一起工作。

适用场景：已经存在的类，它的方法和需求不匹配时（方法结果相同或相似）

优点：能提高类的透明性和复用，现有的类复用但不需要改变。

缺点：可能会增加系统的复杂性，增加系统代码的可读难度。

类适配器：继承方式

对象适配：构造函数传递

接口适配方式：直接按照需求，调用不同的实现

public interface Target {
        void request();
    }

public class ConcreteTarget implements Target {
        @Override
        public void request() {
            System.out.println("concreteTarget目标方法");
        }
    }

public class Adaptee {
        public void adapteeRequest(){
            System.out.println("被适配者的方法");
        }
    }

/**
     * 类适配器
     * Target 目标方法 接口
     * ConcreteTarget 目标方法
     * Adaptee 需要适配的新方法
     * Adapter 适配器
     */
    public class Adapter extends Adaptee implements Target{
        @Override
        public void request() {
            //...
            super.adapteeRequest();
            //...
        }
    }

/**
     * 对象是配置
     */
    public class Adapter implements Target{
        private Adaptee adaptee = new Adaptee();
    
        @Override
        public void request() {
            //...
            adaptee.adapteeRequest();
            //...
        }
    }

public static void main(String[] args) {
            Target adapterTarget = new Adapter();
            adapterTarget.request();
        }

**应用场景**

1、我们在使用第三方的类库，或者说第三方的API的时候，我们通过适配器转换来满足现有系统的使用需求。

2、我们的旧系统与新系统进行集成的时候，我们发现旧系统的数据无法满足新系统的需求。

## 装饰器模式 ##

对已经存在的某些类进行装饰，以此来扩展一些功能。

定义：在不改变原有对象的基础上，将功能附加到对象上。

适用场景：扩展一个类的功能或给一个类添加附加职责。动态的给一个对象添加功能，这些功能可以动态撤销。

优点：继承的有力补充，比继承更灵活，不改变原有对象的情况下给对象扩展功能。通过使用不同的装饰类以及这些装饰类的排列组合，可以实现不同效果。

缺点：会出现更多代码，更多类。增加程序复杂性，动态装饰时，多层装饰时会更复杂。

实例化一个煎饼，加2个蛋1个香肠

public static void main(String[] args) {
            ABattercake aBattercake = new Battercake();
            aBattercake = new EggDecorator(aBattercake);
            aBattercake = new EggDecorator(aBattercake);
            aBattercake = new SausageDecorator(aBattercake);
            System.out.println(aBattercake.getDesc()+" 销售价格:"+aBattercake.cost());
        }

/**
     * 父抽象类
     */
    public abstract class ABattercake {
        protected abstract String getDesc();
        protected abstract int cost();
    }
    
    /**
     * 父装饰类
     */
    public abstract class AbstractDecorator extends ABattercake {
        private ABattercake aBattercake;
    
        public AbstractDecorator(ABattercake aBattercake) {
            this.aBattercake = aBattercake;
        }
    
        protected abstract void doSomething();
    
        @Override
        protected String getDesc() {
            return this.aBattercake.getDesc();
        }
    
        @Override
        protected int cost() {
            return this.aBattercake.cost();
        }
    }

/**
     * 煎饼
     */
    public class Battercake extends ABattercake {
        @Override
        protected String getDesc() {
            return "煎饼";
        }
    
        @Override
        protected int cost() {
            return 8;
        }
    }

/**
     * 蛋
     */
    public class EggDecorator extends AbstractDecorator {
        public EggDecorator(ABattercake aBattercake) {
            super(aBattercake);
        }
    
        @Override
        protected void doSomething() {
        }
    
        @Override
        protected String getDesc() {
            return super.getDesc()+" 加一个鸡蛋";
        }
    
        @Override
        protected int cost() {
            return super.cost()+1;
        }
    }

/**
     * 香肠
     */
    public class SausageDecorator extends AbstractDecorator{
        public SausageDecorator(ABattercake aBattercake) {
            super(aBattercake);
        }
    
        @Override
        protected void doSomething() {
        }
    
        @Override
        protected String getDesc() {
            return super.getDesc()+" 加一根香肠";
        }
    
        @Override
        protected int cost() {
            return super.cost()+2;
        }
    }

与代理模式：

1、装饰是添加功能，代理是控制用户访问。

2、装饰是原始对象，代理是一个构造的对象，可以隐藏原有的属性。

## 外观模式(就是使用一个方法，封装多个方法的调用) ##

隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。

提供单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

定义：又叫门面模式，提供了一个统一的接口，用来访问系统中的一群接口。

适用场景：子系统越来越复杂，构建多层系统结构，利用外观对象作为每层入口，简化层间调用。

优点：简化调用过程，减少系统依赖、松散解耦，更好划分访问层次，符合迪米特法则（最少知道原则）

缺点：增加子系统、扩展子系统容易引入风险。不符合开闭原则。

public class Computer {
    	AliSmsService aliSmsService;
    	EamilSmsService eamilSmsService;
    	WeiXinSmsService weiXinSmsService;
    
    	public Computer() {
    		aliSmsService = new AliSmsServiceImpl();
    		eamilSmsService = new EamilSmsServiceImpl();
    		weiXinSmsService = new WeiXinSmsServiceImpl();
    	}
    
    	public void sendMsg() {
    		aliSmsService.sendSms();
    		eamilSmsService.sendSms();
    		weiXinSmsService.sendSms();
    
    	}
    }
    
    public class Client {
    
    	public static void main(String[] args) {
    		// AliSmsService aliSmsService= new AliSmsServiceImpl();
    		// EamilSmsService eamilSmsService= new EamilSmsServiceImpl();
    		// WeiXinSmsService weiXinSmsService= new WeiXinSmsServiceImpl();
    		// aliSmsService.sendSms();
    		// eamilSmsService.sendSms();
    		// weiXinSmsService.sendSms();
    		new Computer().sendMsg();
    	}
    }