装饰者模式

1、需求分析：

1. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有行号
2. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有分号
3. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有双引号
4. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有行号+分号
5. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有分号+双引号
6. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有行号+双引号
7. 编写一个类拓展BuffereedReader的功能，增强readLine方法返回的字符串 带有分号+行号+双引号

2、增强一个类的功能的时候，我们可以选择使用继承。

通过继承实现增强一个类的功能优点：代码结构清晰，通俗易懂。

----------------| Reader

-------------------|BufferedReader

---------------------|BufferedLineNum 带行号

---------------------|BufferedSemi  带分号

---------------------|BufferedQuto 带引号

---------------------|子类

缺点：使用不灵活，会导致继承的体系过于庞大

 

class BufferedLineNum extends BufferedReader{
    int count=1;
    public BufferedLineNum(Reader in) {
        super(in);
    }

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

class BufferedSemi extends BufferedReader{
    public BufferedSemi(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line=super.readLine();
        if(line==null) return null;
        line=line+";";
        return line;
    }    
} 

3、装饰者模式的思想：

4、装饰者模式的开发步骤

1. 在装饰类的内部维护一个被装饰类的引用。
2. 让装饰类有一个共同的父类或者是父接口。

5、代码实现

package cn.lyjs.other;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//带有行号的
class BufferedLineNum2 extends BufferedReader{
    BufferedReader bufferedReader;
    int count=1;
    public BufferedLineNum2(BufferedReader bufferedReader) {
        super(bufferedReader);
        this.bufferedReader=bufferedReader;
    }
    @Override
    public String readLine() throws IOException {
        String line=bufferedReader.readLine();
        if(line==null) return null;
        line=count+" "+line;
        count++;
        return line;
    }
    
    
}
//带有引号的
class BufferedQuto2 extends BufferedReader{
    BufferedReader bufferedReader;
    public BufferedQuto2(BufferedReader bufferedReader) {
        super(bufferedReader);
        this.bufferedReader=bufferedReader;
    }
    @Override
    public String readLine() throws IOException {
        String line=bufferedReader.readLine();
        if(line==null) return null;
        line="\""+line+"\"";
        return line;
    }
    
    
}


//带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader{
    //在内部维护一个被装饰类的引用
    BufferedReader bufferedReader;
    public BufferedSemi2(BufferedReader bufferedReader) {
        super(bufferedReader);//这句代码并没有什么用，只是为了不让程序报错。
        this.bufferedReader=bufferedReader;
    }
    @Override
    public String readLine() throws IOException {
        String line=bufferedReader.readLine(); //这里如果调用了带有行号的方法，问题就很容易解决
        if(line==null) return null;
        line=line+";";
        return line;
    }    
}
public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file=new File("F:\\lyjss\\day21\\src\\cn\\lyjs\\writer\\copyImage.java");
        FileReader fileReader=new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader buffered=new BufferedReader(fileReader);
        //建立带行号的缓冲输入字符流
        BufferedLineNum2 bufferedLineNum=new BufferedLineNum2(buffered);
        //带分号的缓冲输入字符流
        BufferedSemi2 bufferedSemi=new BufferedSemi2(bufferedLineNum);
        //带引号的缓冲输入字符流
        BufferedQuto2 bufferedQuto=new BufferedQuto2(bufferedSemi);
        String line=null;
        while((line=bufferedQuto.readLine())!=null){
            System.out.println(line);
        }
    }
}

6、练兵场地

package cn.lyjs.other;
/*
 * 一家三口每个人都有工作，儿子的工作是画画，
 * 母亲的工作就是在儿子的基础上做一个增强，不仅会画画，还可以涂料
  * 父亲的工作是在妈妈的基础上，添加框架。请用装饰者模式写出代码。
 */
interface Work{
    public void work();
}

class Son implements Work{

    @Override
    public void work() {
        System.out.println("画画.....");
        
    }
    
}

class Mother implements Work{
    
    Work worker;
    
    public Mother(Work work){
        this.worker=work;
        
    }
    @Override
    public void work() {
        worker.work();
        System.out.println("给画添加颜色");
    }
    
}

class Father implements Work{
    Work worker;
    public Father(Work work){
        this.worker=work;
    }
    @Override
    public void work() {
        worker.work();
        System.out.println("添加框架....");
        
    }
    
}
public class Demo {
    public static void main(String[] args) {
        Son son=new Son();
        System.out.println("儿子的工作：");
        son.work();
        System.out.println();
        Mother mother=new Mother(son);
        System.out.println("妈妈的工作：");
        mother.work();
        System.out.println();
        Father father=new Father(mother);
        System.out.println("爸爸的工作：");
        father.work();
        System.out.println();
    }
}