设计模式（八）装饰模式

版权声明： https://blog.csdn.net/if_i_were_a/article/details/83989658

装饰模式（Decotator）:动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活

这是在网上找的关于装饰模式的类图，

http://img0.imgtn.bdimg.com/it/u=3834882730,1020120806&fm=214&gp=0.jpg

Component是定义一个对象的接口，可以给这些对象动态地添加职责，ConcreteComponet是定义了一个具体的对象，也可以给这个对象添加一些职责。Decorator装饰抽象类，继承了Component从外类扩展Componet的功能。至于ConcreteDecorator就是具体的装饰对象

public abstract class Component {
    public abstract void operation();
}
public class ConcreteComponent extends Component {
    @Override
    public void operation() {
        System.out.println("具体对象的操作");
    }
}
public abstract class Decorator extends Component{
    protected Component component;

    public void setComponent(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component!=null)
        {
            component.operation();
        }
    }
}
public class ConcreteDecoratorA  extends Decorator{
    private String addedState;
    @Override
    public void operation() {
        super.operation();
        addedState="new State";
        System.out.println("具体装饰对象A的操作");
    }
}
public class ConcreteDecoratorB extends Decorator {
    @Override
    public void operation() {
        super.operation();
        addBehavior();
    }
    private void addBehavior()
    {
        System.out.println("具体装饰对象B的操作");
    }
}
public class Main {
    public static void main(String[] args) {
        ConcreteComponent c=new ConcreteComponent();
        ConcreteDecoratorA d1=new ConcreteDecoratorA();
        ConcreteDecoratorB d2=new ConcreteDecoratorB();
        //用装饰类A去装饰c
        d1.setComponent(c);
        //用装饰类A去装饰C
        d2.setComponent(d1);
        d2.operation();
    }
}

下面再举一个具体应用到装饰对象的例子：

一个人要穿衣服，搭配服饰。下面是具体的实现：

public class Person {
    private String name;
    public Person() {
    }

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

}
public abstract class Finery extends Person{
    public Person person;

    public void setPerson(Person person) {
        this.person = person;
    }

    @Override
    public void show() {
        if(null!=person)
        {
            person.show();
        }
    }
}
public class BigTrouser extends Finery {
    @Override
    public void show() {
        System.out.print("大垮裤"+" ");
        super.show();
    }
}
public class Dress extends Finery {
    @Override
    public void show() {
        System.out.print("裙子"+" ");
        super.show();
    }
}
public class Shoes extends Finery{
    @Override
    public void show() {
        System.out.print("破球鞋"+" ");
        super.show();
    }
}
public class TShirts extends Finery {
    @Override
    public void show() {
        System.out.print("大T恤"+" ");
        super.show();
    }
}
public class Main {
    public static void main(String[] args) {
        Person p=new Person("小明") ;
        System.out.println("第一种打扮");
        TShirts tShirts=new TShirts();
        Dress dress=new Dress();
        Shoes shoes=new Shoes();
        tShirts.setPerson(p);
        dress.setPerson(tShirts);
        shoes.setPerson(dress);
        shoes.show();

        System.out.println("第二种打扮");
        Shoes shoes1=new Shoes();
        BigTrouser bigTrouser=new BigTrouser();
        shoes1.setPerson(p);
        bigTrouser.setPerson(shoes1);
        bigTrouser.show();

    }
}

装饰模式的优点就是把类中的装饰功能从类中搬移去除，这样可以简化原有的类

有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中的重复值逻辑