装饰者设计模式

我可能是个假开发

于 2016-11-16 16:30:55 发布

阅读量277

点赞数 1

分类专栏： JavaSE

本文链接：https://blog.csdn.net/csdn_gia/article/details/53188007

版权

JavaSE 专栏收录该内容

110 篇文章 0 订阅

订阅专栏

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

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

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

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
//需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。
import java.io.Reader;


class BufferedReaderLineNum extends BufferedReader{
	
	int count = 1;

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

public class Demo1 {
	
	public static void main(String[] args) throws IOException {
		File file = new File("F:\\z.txt");
		FileReader fr = new FileReader(file);
		//建立带行号的缓冲输入字符流
		BufferedReaderLineNum brl = new BufferedReaderLineNum(fr);
		
		String line = null;
		while((line = brl.readLine())!=null){
			System.out.println(line);
		}
	}
	
	
	
	

}

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

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;


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

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

public class Demo2 {
	
	public static void main(String[] args) throws IOException {
		File file = new File("F:\\z.txt");
		BufferedSemi bs = new BufferedSemi(new FileReader(file));
		
		String line = null;
		while((line = bs.readLine())!=null){
			System.out.println(line);
		}
	}
	
	
	

}

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

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

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


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 Demo3 {
	
	public static void main(String[] args) throws IOException {
		File file = new File("F:\\z.txt");
		BufferedQuto bq = new BufferedQuto(new FileReader(file));
		
		String line = null;
		while((line = bq.readLine())!=null){
			System.out.println(line);
		}
	}
	
	
	
	
	

}

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

1. 在装饰类的内部维护一个被装饰类的引用。

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

class BufferedLineNum{
	
	BufferedReader bufferedReader;
	
	int count = 1; 
	
	public BufferedLineNum(BufferedReader bufferedReader){   
		this.bufferedReader = bufferedReader;
	}
	
	public String readLine() throws IOException{
		String line = bufferedReader.readLine();
		
		if(line == null){
			return null;
		}
		
		line = count + " " + line;
		count++;
		return line;
	}
	
	
}

public class Demo4 {
	
	public static void main(String[] args) throws IOException {
		File file = new File("F:\\z.txt");
		BufferedLineNum bln = new BufferedLineNum(new BufferedReader(new FileReader(file)));
		
		String line = null;
		while((line = bln.readLine())!=null){
			System.out.println(line);
		}
		
	}

}

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

class BufferedSemi2{
	
	BufferedReader bufferedReader;
	public BufferedSemi2(BufferedReader bufferedReader){
		this.bufferedReader = bufferedReader;
	}
	
	public String readLine() throws IOException{
		String line = bufferedReader.readLine();
		if(line == null){
			return null;
		}
		line = line + ";";
		
		return line;
	}
	
}

public class Demo5 {
	
	public static void main(String[] args) throws IOException {
		
		BufferedSemi2 bufferedSemi = new BufferedSemi2(new BufferedReader(new FileReader("F:\\z.txt")));
		
		String line = null;
		while((line = bufferedSemi.readLine())!=null){
			System.out.println(line);
		}
				
		
		
	}

}

2. 让装饰类有一个共同的父类或者是父接口。

都继承BufferedReader:

package dec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

class BufferedLineNum3 extends BufferedReader{
	
	BufferedReader bufferedReader;
	
	int count = 1; 
	
	public BufferedLineNum3(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 BufferedSemi3 extends BufferedReader{
	
	BufferedReader bufferedReader;
	public BufferedSemi3(BufferedReader bufferedReader){
		super(bufferedReader);
		this.bufferedReader = bufferedReader;
	}
	
	public String readLine() throws IOException{
		String line = bufferedReader.readLine();
		if(line == null){
			return null;
		}
		line = line + ";";
		
		return line;
	}
	
}

public class Demo6 {
	
	public static void main(String[] args) throws IOException {
		File file = new File("F:\\z.txt");
		FileReader fileReader = new FileReader(file);
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		
		/*BufferedLineNum3 bln = new BufferedLineNum3(new BufferedReader(new FileReader(file)));
		BufferedSemi3 bufferedSemi = new BufferedSemi3(new BufferedLineNum3(new BufferedLineNum3(new BufferedReader(new FileReader(file)))));
		*/
		BufferedLineNum3 bln = new BufferedLineNum3(bufferedReader);
		BufferedSemi3 bufferedSemi = new BufferedSemi3(bln);
		
		String line = null;
		while((line = bufferedSemi.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);
		}
		
		
		
		
	}
	
}