java-装饰者模式

装饰者模式

介绍：
简单点来说，就是为这个对象动态的赋予它其他的功能。
装饰者模式是动态的将责任附加到对象上（引自《Head First设计模式》）。这里的重点在于动态这两个字，我们都知道继承的实现的方式，它是是类编译的时候就去加载文件，属于一种静态的附加，而我们要实现动态的附加就不能单纯的通过继承来实现。在这种背景下，装饰者模式就应运而生了。装饰者模式的实现：首先所有的类都有一个共同的抽象，这个抽象可以是一个抽象类，也可以是一个接口，所有的类该抽象的子类或者实现。

主要解决：我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

举例：
我们给一个人添加一下他的穿着。

/**
 * 人
 */
public abstract class Person {

    //穿衣服
    public abstract void getDressed();

    //价格
    public abstract double price();
}

张三穿了一个衬衫太少了，我们给他穿一个裤子和鞋子吧，注意这里是动态的添加。

/**
 * 张三
 */
public class Zhangsan extends Person {

    @Override
    public void getDressed() {
        System.out.println("张三穿衬衫");
    }

    @Override
    public double price() {
        //衬衫的价格100
        return 100;
    }
}

创建一个装饰者，它继承一个Person

/**
 * 装饰者
 */
public abstract class Decorator extends Person{

    private Person person = null;

    public Decorator(Person person){
        this.person = person;
    }

    @Override
    public void getDressed() {
        this.person.getDressed();
        this.price();
    }

    @Override
    public double price() {
        return person.price();
    }
}

穿牛仔裤，这里是继承装饰者对象的。

package com.example.maybatissource.decorate;

public class JeansDecorator extends Decorator {

    Person person = null;

    public JeansDecorator(Person person) {
        super(person);
        this.person = person;
    }
    
    // 重写父类的方法
    @Override
    public void getDressed(){
    	// 调用父类的方法
        super.getDressed();
        this.price();
        this.decorateMethod();
    }

    @Override
    public double price() {
        //裤子的价格100
        return person.price()+100;
    }

	 // 定义自己的修饰逻辑
    private void decorateMethod(){
        System.out.println("穿牛仔裤");
    }
}

穿鞋。同样是继承装饰者对象

package com.example.maybatissource.decorate;

/**
 * 穿鞋
 */
public class ShoesDecorator extends Decorator {

    Person person = null;

    public ShoesDecorator(Person person) {
        super(person);
        this.person = person;
    }

    // 重写父类的方法
    @Override
    public void getDressed(){
    	//调用父类的方法
        super.getDressed();
        this.price();
        this.decorateMethod();
    }
    @Override
    public double price() {
        //鞋子的价格100
        return person.price()+100;
    }

    // 定义自己的修饰逻辑
    private void decorateMethod(){
        System.out.println("穿李宁鞋子");
    }
}

main方法

package com.example.maybatissource.decorate;

public class main {
    public static void main(String[] args) {
        Person zhangsan = new Zhangsan();
        // 第一次修饰，穿裤子
        Decorator jeans = new JeansDecorator(zhangsan);
        //将对象进行第二次修饰，当然这里你也可以选择不让他穿鞋子。
        Decorator shoesDecorator = new ShoesDecorator(jeans);
//        jeans.getDressed();
        shoesDecorator.getDressed();
//        System.out.println(jeans.price());
        System.out.println("总价格："+shoesDecorator.price());
    }
}

动态的为对象赋予它其他的功能（穿牛仔裤，穿鞋）。当然这要注意的是被修饰的对象（Zhangsan）和修饰者对象（Decorator ）是都需要继承同一个对象（Person ）的，这里为什么要继承同一个对象呢？起到一个约束作用。

可以看下这篇文章为什么要用到装饰者模式：
https://blog.csdn.net/nugongahou110/article/details/50413668