装饰模式

package com.decorator;

public interface  Person {
    public void show();
}

package com.decorator;

public class People implements Person{
    private String name;
    public  People(String name){
        this.name=name;
    }
    @Override
    public void show() {
        System.out.println("装饰对象："+name);
    }

}

package com.decorator;

public abstract class Finery implements Person{
    
    public  Person people;
    public void setPeople(Person people){
        this.people=people;
    }
    public void show(){
        if(people!=null){
            people.show();
        }
    }    
}

class Thirts extends Finery{
    @Override
    public void show(){
        people.show();
        System.out.println("装饰Thirst");
    }    
}

class Trouser extends Finery{

    @Override
    public void show(){
        people.show();
        System.out.println("装饰垮裤");
    }    
}

class gymShoes extends Finery{

    @Override
    public void show(){
        people.show();
        System.out.println("装饰运动鞋");
    }    
}

class businessSuit extends Finery{

    @Override
    public void show(){
        people.show();
        System.out.println("装饰西装");
    }    
}

class Tai extends Finery{

    @Override
    public void show(){
        people.show();
        System.out.println("装饰领带");
    }    
}

class leatherShoes extends Finery{

    @Override
    public void show(){
        people.show();
        System.out.println("装饰皮鞋");
    }    
}

package com.decorator;

public class Test {
    public static void main(String[] args){
        
        People people=new People("小明");
        
        System.out.println("第一种装扮：");
        Thirts ts=new Thirts();
        Trouser tr=new Trouser();
        
        ts.setPeople(people);
        tr.setPeople(ts);
        tr.show();
        
        
    }

}

我插入的是一个简单的装饰模式例子。

我的描述：

首先一个接口1定义主要的抽象方法。

一个抽象类2继承接口1，在抽象类2中声明一个接口1。抽象类2声明一个实现接口1的对象x，如果接口1的对象不为空，接口继承下来的方法都的执行都x的对应方法。

具体的实现类继承抽象类，并且重写对应的方法，不过在对应方法里面不能忘记调用父容器的该方法，表示在原基础上装饰

测试：

实例化接口1的实现类Object1，new一个装饰类dec1，以Object1为参数，new一个装饰类dec2以dec1为参数，... 执行最后一个装饰类的对应方法

 

书中的点：

需要将所需的功能都按照正确的顺序串联起来进行控制

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

Component是定义一个对象接口，可以给这些对象动态的增加一些职责。Decorator，装饰抽象类，继承了Component，从外类来拓展Component的功能来说，是无需知道Decorator的存在的。至于ConcreteDecorator就是具体的装饰对象，祈祷给Component添加职责功能的功能。

装饰模式是利用SetComponent来对对象进行包装的。

每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对项链当中。

如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。

装饰模式是将己已有功能动态的添加更多功能的一种方式。

系统需要新功能时，是向旧的类中添加新的代码。这些新加的代码通常装饰了原有类的核心职责和主要行为。

在主类中添加了新的字段新的方法和新的逻辑，从而添加了主类的复杂度。新加入的东西仅仅是为了满足在某些特定的情况下的特殊行为的需要，这个时候可以使用装饰模式。

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

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