java设计模式-装饰模式

模式导读：

    给你一个没装修的房子，让你利用自己的艺术细菌去想象如何去让自己的房子更加漂亮，更加完美。这就需要我们慢慢去思考了...通过动态的给一个对象增加新的功能，使无需通过继承的方式增加子类既能够扩展对象功能，使用对象的关联关系代替继承关系，更加灵活，同时类型体系的快速膨胀。至于使用继承关系实现为什么膨胀，看下面这张图你就清楚了。

很明显，如果对象的功能开始复杂起来时，我们需要重新定义一个新的对象来实现，这就增加了更多地子类，所以膨胀了。

参考类图：

1.Component抽象构件角色：使真实对象和装饰对象有相同的接口，这样，客户端对象就能够以真实对象相同的方式同装饰对象交互。
2.ConcretComponent具体构件角色（真实对象）：如io流中的FileInputStream,FileOutputStream。
3.Decorator装饰角色：持有一个抽象构件的引用，装饰对象接收所有的客户端的请求，并把这些请求转发给真实的对象，这样就能够在真实对象调用前后增加新的功能。
4.ConcretDecorator具体装饰角色：负责给构件对象增加新的责任。
代码实现：

1.抽象构件类

package com.etc;
//抽象构件角色
public interface AbstractCar {
     void move();
}

2.具体构件类

package com.etc;
//具体构件角色
public class Car implements AbstractCar{

    @Override
    public void move() {
        System.out.println("**正常由人操控陆地行驶!**");
    }

}

3.装饰者角色类

package com.etc;
//装饰角色，将传入的不同请求转发给真实对象
public class Decorator implements AbstractCar{
    private AbstractCar car;
    //构造器，用于接收具体的装饰子对象
    public Decorator(AbstractCar car) {
        super();
        this.car = car;
    }
    @Override
    public void move() {
        car.move();
    }

}

4.特征类

//将共同的特征抽取出来  ->swim，fly，ai
public class Feature {

    // 私有化构造器
    private Feature() {

    }

    // 可以潜水
    public static void swim() {
        System.out.println("具备潜水功能");
    }

    // 可以飞
    public static void fly() {
        System.out.println("具备飞行功能");
    }

    // 可以人工智能
    public static void ai() {
        System.out.println("具备人工智能");
    }
}

5.具体装饰角色类

public class SwimCar extends Decorator {

    public SwimCar(AbstractCar car) {
        super(car);
    }

    // 重写父类的方法，给车增加swim()的功能
    public void move() {
        super.move();
        Feature.swim();
    }
}

public class SwimFlyCar extends Decorator {

    public SwimFlyCar(AbstractCar car) {
        super(car);
    }

    // 重写父类的方法，给车增加fly(),swim()的功能
    public void move() {
        super.move();
        Feature.fly();
        Feature.swim();
    }
}

//具体的装饰角色
public class FlyCar extends Decorator {

    public FlyCar(AbstractCar car) {
        super(car);
    }

    // 重写父类的方法，给车增加fly()的功能
    public void move() {
        super.move();
        Feature.fly();
    }
}

public class AICar extends Decorator {

    public AICar(AbstractCar car) {
        super(car);
    }

    // 重写父类的方法，给车增加AI()的功能
    public void move() {
        super.move();
        Feature.ai();
    }
}

6.客户端类

package com.etc;
//根据情景需要给车增加不同的功能
public class Client {

    public static void main(String[] args) {
        //让车增加可以飞的功能
        Car car=new Car();
        FlyCar flyCar=new FlyCar(car);
        flyCar.move();
        //让车增加可以潜水的功能
        SwimCar swimCar=new SwimCar(car);
        swimCar.move();
        //让车增加可以潜水,飞的功能
        SwimFlyCar sfCar=new SwimFlyCar(car);
        sfCar.move();
    }

}

效果截图：

装饰模式的优缺点：

优点：

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

缺点：

多层装饰比较复杂。

适用场景：

1、扩展一个类的功能。
2、动态增加功能，动态撤销。