Java 的设计模式之一装饰者模式

刚开始接触装饰者的设计模式，感觉挺难理解的，不够后来花了一个晚上的时间，终于有头绪了

装饰者设计模式：如果想对已经存在的对象进行装饰，那么就定义一个类，在类中对已经有的对象进行功能的增强或添加另外的行为，这个类就叫装饰者类。被修饰的类叫被装饰者类，是已经存在有的功能。在装饰者类之间又可以互相装饰

特点：
          1.装饰类通过构造方法来接收被装饰者的对象，调用它里面的功能或行为
          2. 基于对被装饰对象的功能进行扩展，提供更强大的功能

Java中的IO流是典型的装饰者模式

下面来看一行简短的代码：

扩展一个接口，定义一个抽象的方法,这个接口实际上就是一个被装饰者类

interface Work {
    public void work();
}

画画类：

class Drawing implements Work { //实现接口
    
    @Override
    public void work() {  //必须实现接口中的方法
        // TODO Auto-generated method stub
        System.out.println("画画");
    }
}

上色类：

class Colour implements Work {
    
    Work w;//在内部维护一个被装饰的类
    
    public Colour(Work w) {
        this.w = w;
    }
    @Override
    public void work() {
        
        w.work();
        System.out.println("给画上色");
    }
}

装裱类：

class Mounting implements Work {
    
    Work w;//在内部维护一个被装饰的类
        
    public Mounting(Work w) {
        
        this.w = w;
    }
        
    @Override
    public void work() {
        
        w.work();
        System.out.println("给画装裱");
    }
}

测试类：

public class Test {

    public static void main(String[] args) throws FileNotFoundException {
        
        Work w = new Drawing();
        Colour c = new Colour(w);
        Mounting m = new Mounting(c);
        m.work();
    }
}

上面是一个简单的装饰者模式。

装饰者模式的设计原则：
      　　　　　　　　  1.多用组合，少用继承
　　　　　　　　　      继承的子类实现父类的行为，是在编译时静态决定的，而且继承的行为是相同的，但是利用装饰者之间的相互修饰（组合）
 　　　　　　　  就可以扩展出强大的功能，可以动态的进行扩展，也可以撤销
　　　　　　　　　　  2.对扩展开放，对修改关闭
　　　　　　　　      扩展是在继承的前提下实现，在子类中修改。扩展是在继承被装饰者类实现行为或功能，不需要修改装饰者的类，只是在此基础　　　　　　　　上，装饰另外的功能或行为

需求：定义一个人吃面，可以加生菜，也可以加辣椒，也可以都加

EatNoodle类：

class EatNoodle {
    
    public void eat() {
        
        System.out.print("吃面");
    }
}

装饰者类

class SunEatNoodle1 {
    
    EatNoodle eatNd;
    
    public SunEatNoodle1(EatNoodle eatNd) {  //定义构造方法来接收被装饰者的对象
        
        this.eatNd = eatNd;
    }
    
    public void eat() {
        
        eatNd.eat();
        System.out.println("加点香菜，感觉好吃");
    }
}

装饰者之间的相互修饰

class SunEatNoodle2 {
    
    //EatNoodle eatNd;
    SunEatNoodle1 sunEat1;
    public SunEatNoodle2( SunEatNoodle1 sunEat1) {   //定义构造方法来接收装饰者的对象
        
        //this.eatNd = eatNd;
        this.sunEat1 = sunEat1;
    }
    
    public void eat() {
        
        System.out.println();
        //eatNd.eat();
        sunEat1.eat();
        System.out.println("再来点辣椒，就更好吃了");
    }
}

测试类：

public class Demo1 {

    public static void main(String[] args) {  
        
        EatNoodle eatNoodle = new EatNoodle();
        //eatNoodle.eat();
        
        SunEatNoodle1 sunEat1 = new SunEatNoodle1(eatNoodle);
        sunEat1.eat();
        
        SunEatNoodle2 sunEat2 = new SunEatNoodle2(sunEat1);//装饰者类之间的相互修饰
        sunEat2.eat();
    }

}

运行结果：

装饰者与继承的关系

在添加 不同功能的时候。我们会想到了用继承来实现。而且刚学装饰者模式的时候，觉得挺难理解的，装饰者的前世今生就是继承。那为什么不用继承呢？这样岂不是更容易理解，用起来也挺方便。下面通过一个简单的Demo做一下比较。

需求：用继承来实现通过readLine读取代码  ，每一行加上一个行号和分号的功能

//1.添加行号，默认继承BufferedReader
class BufferedReaderLineNum extends BufferedReader {
    
    int count = 0;
    
    public BufferedReaderLineNum(BufferedReader in) { //Reader:默认创建一个目标文件的缓冲字符输入流的大小         
        super(in);
    }
    
    @Override//3.重写父类的readLine方法
    public String readLine() throws IOException {
        
        String countent = super.readLine();//调用父类默认的行号
        
        if (countent == null) {
            return null;
        }
        
        //System.out.println(count + " " + countent);
        count++;
        return count + " " + countent;
    }
}

//添加分号
class BufferedReaderSemicolon extends BufferedReader {

    BufferedReader reader;

    public BufferedReaderSemicolon(BufferedReader in) {//Reader:默认创建一个目标文件的缓冲字符输入流的大小         
        super(in);
        this.reader = in;
    }
    
    @Override//3.重写父类的readLine方法
    public String readLine() throws IOException {
        
        String countent = reader.readLine();
        if (countent == null) {  //判断数据已经读完
            return null;
        }
    
        return countent + ";";
    }
}

public class Demo1 {

    public static void main(String[] args) throws IOException {
    
        //FileReader用于字符输入流，FileInputStream是用字节输入流
        //1.创建通道，拿到一个指定的目标文件
        FileReader fileRead = new FileReader("C:\java\decorator\Test.java");
        BufferedReader reader = new BufferedReader(fileRead);
        
        //2.创建行号的缓冲流
        BufferedReaderLineNum readerLineNum = new BufferedReaderLineNum(reader);
        
        //.创建分号的缓冲流
        BufferedReaderSemicolon readerSemicolon = new BufferedReaderSemicolon(readerLineNum);
        
        String content = null;
        //使用readLine(),包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
        while((content = readerSemicolon.readLine()) != null) {
            System.out.println(content);
        }
        //4.关闭资源
        readerLineNum.close();
    }
}

然后再通过装饰者模式来实现上面的功能：

//添加行号
class BufferederReadLineNum extends BufferedReader {
    
    BufferedReader bufferedReader;    //1.内部维护的被装饰者的类
    int count = 1;
    
    public BufferederReadLineNum(BufferedReader read) {
        super(read);//如果没有这行代码，会显示编译报错，显示没有隐式性的给这个构造函数定义
        this.bufferedReader = read;
    }

    @Override
    public String readLine() throws IOException {
        
        String countent = bufferedReader.readLine();
        
        if(countent == null) {
            return null;
        }
        
        countent = count + " " + countent;
        count++;
        return countent;
    }
}

//2.添加分号
class BufferedReaderSemicolon1 extends BufferedReader {
    
    BufferedReader bufferedReader;    //1.内部维护的被装饰者的类
    
    public BufferedReaderSemicolon1(BufferedReader read) { 
        super(read);
        this.bufferedReader = read;
    }
    
    @Override//3.重写父类的readLine方法
    public String readLine() throws IOException {
        
        String countent = super.readLine();  //调用父类默认的行号
        if (countent == null) {   //判断数据已经读完
            return null;
        }
        
        return countent + ";";
    }
}



public class Test2 {

    public static void main(String[] args) throws IOException {
        
        //1.创建通道，拿到一个指定的目标文件
        FileReader fileRead = new FileReader("C:\java\代码\src\Test.java");
        
        //2.创建缓冲区 
        BufferedReader bufferedReader = new BufferedReader(fileRead);
                
        //3创建分号的缓冲流  
        BufferedReaderSemicolon1 readerSemicolon = new BufferedReaderSemicolon1(bufferedReader);
        
        //创建行号的缓冲流    在装饰者创建的
        BufferederReadLineNum readerLineNum = new BufferederReadLineNum(readerSemicolon);
                
        //4.读取数据
        String content = null;
        //使用readLine(),包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
        while((content = readerLineNum.readLine()) != null) {
            System.out.println(content);
        }
        //5.关闭资源
        readerLineNum.close();
        
    }
}

通过上面的代码，可能不能完全看出使用装饰者模式的强大功能，你可以在多创建几个类，添加多个功能，结果就显而易见了。

在实现多个功能的时候，使用继承的体系会过于庞大，显得很臃肿。

使用了装饰者来进行动态性的添加一些附加功能，确保在运行时，不用改变该对象的结构就可以在外部添加附加的功能。通常也是通过继承来实现给定类的功能扩展来实现更强大的功能。提高了代码的可维护性和简洁性。