【设计模式】## 3、装饰者模式 ##

如果要增强一个类的功能

①可以选择继承
优点： 代码结构简单
缺点： 使用不灵活，会导致继承体系过于庞大，（子类太多）

②使用装饰者设计模式！！！

装饰者设计模式： 增强一个类的功能，并且让装饰类互相装饰！！

步骤：
①装饰类内部维护一个被装饰类的引用。
②让装饰类有一个共同的被装饰类或者接口

需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。

 需求2：编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号。


 需求3： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号。

 需求4： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号+ 分号。


 需求5： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号+ 双引号。

 需求6： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号+ 行号。

 需求7： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号+ 分号+双引号。

继承实现的增强类和修饰模式实现的增强类有何区别？

    继承实现的增强类：
        优点：代码结构清晰，而且实现简单. 
        缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。

修饰模式实现的增强类：
        优点：内部可以通过多态技术对多个需要增强的类进行增强， 可以是这些装饰类达到互相装饰的效果。使用比较灵活。

        缺点：需要内部通过多态技术维护需要被增强的类的实例。进而使得代码稍微复杂。


*/
import java.io.IOException;


//带行号的缓冲输入字符流
class BufferedLineNum2  extends BufferedReader{  

    //在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;

    int count = 1;

    public BufferedLineNum2(BufferedReader bufferedReader){
        super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
        this.bufferedReader = bufferedReader;
    }


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


//带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader{  //为什么要继承?  是为了让这些装饰类的对象可以作为参数进行传递，达到互相装饰 的效果。

    //在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;


    public BufferedSemi2(BufferedReader bufferedReader){ // new BuffereLineNum();
        super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException{
        String line = bufferedReader.readLine();  //如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
        if(line==null){
            return null;
        }
        line = line +";";
        return line;
    }

}

//缓冲类带双引号
class BufferedQuto2 extends BufferedReader{

    //在内部维护一个被装饰的类
    BufferedReader bufferedReader;

    public BufferedQuto2(BufferedReader bufferedReader){  //new  BufferedSemi2();
        super(bufferedReader) ; //只是为了让代码不报错..
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException{
        String line = bufferedReader.readLine();  //如果这里的ReadLine方法是调用了buffereLineNum的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:\\Demo1.java");
        FileReader fileReader = new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //建立带行号的缓冲输入字符流
        BufferedLineNum2 bufferedLineNum = new BufferedLineNum2(bufferedReader);

        //带分号的缓冲输入字符流
        BufferedSemi2 bufferedSemi2 = new BufferedSemi2(bufferedLineNum);

        //带双引号的缓冲输入字符流
        BufferedQuto2 bufferedQuto2 = new  BufferedQuto2(bufferedSemi2);

        String line = null;
        while((line = bufferedQuto2.readLine())!=null){
            System.out.println(line);
        }




    }

}

---

---

---

---

---

做一个小作业：

一家三口都会工作， 儿子只会画画，妈妈除了画画，还会上颜色，爸爸除了画画上颜色， 还会表画框。

interface Work{
    public abstract void work();
}



class Son implements Work{

    public void work(){
        System.out.println("儿子画画");
    }
}


class Mother implements Work{
    Work mother_Work;

    public Mother(Work mother_Work){
        this.mother_Work = mother_Work;

 }

    public void work(){
        mother_Work.work();
        System.out.println("妈妈上颜色");
    }
}

class Father implements Work{
    Work father_Work;

    public Father(Work father_Work){
        this.father_Work = father_Work;

 }

    public void work(){
        father_Work.work();
        System.out.println("爸爸裱画匡");
    }
}




public class rrr {
    public static void main(String[] args){
        Son s = new Son();
        s.work();
        Mother m = new Mother(s);
        m.work();
        Father f = new Father(s);
        f.work();
        }

}

注意难点是 虽然都实现了Work接口， 但是儿子没有维护Work对象， 因为他是最基本的 相当于被装饰类！！， 这点跟共同装饰类不一样。