装饰设计模式

当想要对已有的对象进行功能增强时，可以定义一个类，将已有对象传入，

基于已有对象的功能并提供加强功能，那么自定义的该类就称为装饰类。

装饰模式比继承灵活，避免了继承体系的臃肿。而且降低了类与类之间的关系。

装饰类因为增强了已有对象，具备的功能和已有的是相同的，只不过提供了更强功能，

所以装饰类和被装饰类通常是属于一个体系的

装饰和继承的区别

不用给每一个类派生子类增加功能，而是给一个体系的类封装一个共有的增强类

优化后的体系

JAVA API例子： FileReader  BufferedReader

read() 和readLine()

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test0714 {
	
	public static void main(String[] args){
		/*FileWriter fw=null;
		try {
			fw=new FileWriter("demo.txt",true);//相对路径 创建对象  boolean append 
			fw.write("hahaha\r\n一一一 ");//将字符串写入到流中
			fw.flush();//刷新流对象中的缓冲中的数据  将字符串刷新到目的地中
			
		} catch (IOException e) {
			
			System.out.println(e.getMessage());
		}
		finally
		{
			try {
				if(fw!=null)//判断fw是否初始化成功
					fw.close();//关闭流资源，在关闭前先刷新流对象
			} catch (IOException e2) {
				System.out.println(e2.toString());
			}
		}*/
		
		//读取单个字符
		/*
		FileReader fr=new FileReader("demo.txt");
		try {
			fr=new FileReader("demo.txt");
			
			int c=fr.read();
			while(c!=-1)
			{
				System.out.println((char)c);
				c=fr.read();
			}
			
		} catch (IOException e) {
			
			System.out.println(e.getMessage());
		}
		finally
		{
			try {
				if(fr!=null)//判断fw是否初始化成功
					fr.close();//关闭该流并释放与之关联的所有资源。
			} catch (IOException e2) {
				System.out.println(e2.toString());
			}
		}*/
			
		//通过字符数组进行读取
		/*FileReader fr=new FileReader("demo.txt");
		try {
			fr=new FileReader("demo.txt"); 
			
			int num=0;
			char[] buf=new char[1024];
			while((num=fr.read(buf))!=-1)
			{
				System.out.print(new String(buf,0,num));
			}
		
			
		} catch (IOException e) {
			
			System.out.println(e.getMessage());
		}
		finally
		{
			try {
				if(fr!=null)//判断fw是否初始化成功
					fr.close();//关闭流资源，在关闭前先刷新流对象
			} catch (IOException e2) {
				System.out.println(e2.toString());
			}
		}*/
		
		
		/*FileWriter fw=null;
		FileReader fr=null;
		try {
			fw=new FileWriter("demo_copy.txt",true);
			fr=new FileReader("demo.txt"); 
			
			int len=0;
			char[] buf=new char[1024];
			
			while((len=fr.read(buf))!=-1)
			{
				fw.write(buf,0,len);
			}
		
			
		} catch (IOException e) {
			
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fr!=null)
				try {				
						fr.close();									
				} catch (IOException e2) {
					System.out.println(e2.toString());
				}
			if(fw!=null)
				try {
					fw.close();//关闭流资源，在关闭前先刷新流对象
				} catch (IOException e2) {
					System.out.println(e2.toString());
				}
		}*/
		
		
		/*FileWriter fw=null;
		FileReader fr=null;
		BufferedWriter bw=null;
		BufferedReader br=null;
		try {
			fw=new FileWriter("buf_copy.txt");
			bw=new BufferedWriter(fw);
			
			fr=new FileReader("buf.txt");
			br=new BufferedReader(fr);
			
			String str=null;	
			
			while((str=br.readLine())!=null)
			{
				
				bw.write(str);
				bw.newLine();
			}
			
			
		} catch (Exception e) {
			
		}
		finally {
				
			if(bw!=null)
				try {				
					bw.close();	//关闭缓冲区，就是在关闭缓冲区中的流对象								
				} catch (IOException e2) {
					System.out.println(e2.toString());
				}
			if(br!=null)
				try {				
					br.close();	//关闭缓冲区，就是在关闭缓冲区中的流对象								
				} catch (IOException e2) {
					System.out.println(e2.toString());
				}
			
		}*/
		
		
		Person p=new Person();
		SuperPeron sp=new SuperPeron(p);
		sp.superEat();
	
	}
}

class Person
{
	public void eat()
	{
		System.out.println("吃饭");
	}

}
class SuperPeron
{
	private Person person;
	public SuperPeron(Person person) {
		this.person=person;
	}
	
	public void superEat()
	{
		System.out.println("开胃");
		person.eat();
		System.out.println("甜点");
		System.out.println("来一根");
	}
}