装饰者模式

亦凉 2022-02-18 11:23 203阅读 0赞

*  TB - top bottom（自上而下）
 *  BT - bottom top（自下而上）
 *  RL - right left（从右到左）
 *  LR - left right（从左到右）

继承

可以给这些对象动态的添加职责

继承了Component从外类来拓展父类的功能

也可以给这个对象添加一些职责

起到给component添加职责的功能

ConcreteDecoratorA

Decorator抽象类

ConcreteDecoratorB

ConcreteComponet类

Componet抽象类

Componet是定义一个对象接口

Decorator装饰抽象类

ConcreteComponet是定义了一个具体的对象

ConcreteDecorator就是具体的装饰对象

#### component ####

public abstract class SchoolReport {
    
        //成绩单主要展示的就是你的成绩情况
        public abstract void report();
    
        //成绩单要家长签字，这个是最要命的
        public abstract void sign(String name);
    
        public abstract void feedback(String content);
    
    
    }

#### Decorate ####

public abstract class Decorate extends SchoolReport {
    
        protected SchoolReport schoolReport;
    
        public Decorate(SchoolReport schoolReport) {
            this.schoolReport = schoolReport;
        }
    
        @Override
        public void report() {
            System.out.println(schoolReport.getClass().getSimpleName());
            this.schoolReport.report();
        }
    
        @Override
        public void sign(String name) {
            System.out.println(schoolReport.getClass().getSimpleName());
            this.schoolReport.sign(name);
        }
    
        @Override
        public void feedback(String content) {
            this.schoolReport.feedback(content);
        }
    }

#### ConcreteComponet ####

public class FouthGradeSchoolReport extends SchoolReport {
    
    
        //我的成绩单
        public void report() {
            //成绩单的格式是这个样子的
            System.out.println("尊敬的XXX家长:");
            System.out.println(" ......");
            System.out.println(" 语文 62 数学65 体育 98 自然 63");
            System.out.println(" .......");
            System.out.println(" 家长签名： ");
        }
    
        //家长签名
        public void sign(String name) {
            System.out.println("家长签名为：" + name);
        }
    
        @Override
        public void feedback(String content) {
            System.out.println("反馈意见为：" + content);
        }
    }

#### ConcreteDecoratorA ####

public class HighScoreDecorator extends Decorate {
    
    
        public HighScoreDecorator(SchoolReport schoolReport) {
            super(schoolReport);
        }
    
        //我要汇报最高成绩
        public void reportHighScore() {
            System.out.println("这次考试语文最高是75，数学是78，自然是80");
        }
    
        @Override
        public void report() {
            this.reportHighScore();
            schoolReport.report();
        }
    }

#### ConcreteDecoratorB ####

public class SortDecorator extends Decorate {
    
        public SortDecorator(SchoolReport schoolReport) {
            super(schoolReport);
        }
    
        public void reportSort() {
            System.out.println("我是排名第38名...");
        }
    
        @Override
        public void report() {
            super.report();
            this.reportSort();
        }
    }

#### 主方法 ####

public class Client {
        
        public static void main(String[] args) {
            //把美化过的成绩单拿过来
            SchoolReport sr;
            sr = new FouthGradeSchoolReport();
            sr = new HighScoreDecorator(sr);
            sr = new SortDecorator(sr);
            sr.report();
            sr.sign("老三");
            sr.feedback("无");
        }
    }

装饰模式（Decorator Pattern）是一种比较常见的模式，其定义如下：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。

继承

ConcreteDecoratorA

Decorator

ConcreteDecoratorB

ConcretConcrete类

Componet抽象类

*  Component抽象构件

Component是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原始的对象，如上面的成绩单。

注意　在装饰模式中，必然有一个最基本、最核心、最原始的接口或抽象类充当Component抽象构件。

*  ConcreteComponent 具体构件

ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的就是它。

*  Decorator装饰角色

一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象的方  
法呀，在它的属性里必然有一个private变量指向Component抽象构件。

*  具体装饰角色

ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类，你要把你最核心的、最  
原始的、最基本的东西装饰成其他东西，上面的例子就是把一个比较平庸的成绩单装饰成家  
长认可的成绩单。

### 装饰模式的优点 ###

*  装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无须知道Decorator类，Decorator类是从外部来扩展Component类的功能，而Decorator也不用知道具体的构件。
 *  装饰模式是继承关系的一个替代方案。我们看装饰类Decorator，不管装饰多少层，返回的对象还是Component，实现的还是is-a的关系。
 *  装饰模式可以动态地扩展一个实现类的功能。

### 装饰模式的缺点 ###

多层的装饰代码逻辑比较复杂

### 装饰模式的使用场景 ###

*  需要扩展一个类的功能，或给一个类增加附加功能。
 *  需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
 *  需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。