装饰者设计模式

package 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;

/*
装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰。

BufferedReader是不是拓展了FileReader的功能。
BuferedWriter 也是拓展了FileWriter的功能。

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

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

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

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

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

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

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

----| 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;
}
}

//带双引号的缓冲输入字符流
class  BufferedQuto extends BufferedReader{

public BufferedQuto(Reader in) {
super(in);
}

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

public class Demo1 {

public static void main(String[] args) throws IOException {
File file = new File("F:\\Demo1.java");
//建立数据的输入通道
FileReader fileReader = new FileReader(file);
//建立带行号的缓冲输入字符流
BufferedLineNum bufferedLineNum = new BufferedLineNum(fileReader);

//带有分号的缓冲输入字符流
BufferedSemi bufferedSemi = new BufferedSemi(fileReader);

//带有双引号的缓冲输入字符流
BufferedQuto bufferedQuto = new BufferedQuto(fileReader);

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

}

}

package other;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
/*
装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰。

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

需求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);
}

}

}

package other;

/*练习：
一家三口每个人都会工作，儿子的工作就是画画，母亲的工作就是在儿子的基础上做一个增强，不单止可以画画，还可以上涂料。
爸爸的工作就是在妈妈基础上做了增强，就是上画框。
*/

interface Work{

public void work();
}

class Son implements Work{

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

class Mather implements Work{

//需要被增强的类。
Work worker;

public Mather(Work worker){
this.worker = worker;
}

@Override
public void work() {
worker.work();
System.out.println("给画上颜色..");
}
}

class Father implements Work{

//需要被增强的类的引用
Work worker;

public Father(Work worker){
this.worker = worker;
}

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

}

public class Demo3 {

public static void main(String[] args) {
Son s = new Son();
//      s.work();
Mather m = new Mather(s);
//      m.work();
Father f = new Father(s);
f.work();

}
}