黑马程序员---装饰设计模式

------- android培训、java培训、期待与您交流！ ----------

装饰设计模式：
        当想要对已有的对象进行功能增强时，
        可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
        那么自定义的该类称为装饰类。
        装饰类通常会通过构造方法接收被装饰的对象。
        并基于被装饰的对象的功能，提供更强的功能。

        其原理类似于代理。

装饰与继承的区别：

        MyReader//专门用于读取数据的类。
        |--MyTextReader
        |--MyBufferTextReader
        |--MyMediaReader
        |--MyBufferMediaReader
        |--MyDataReader
        |--MyBufferDataReader


        class MyBufferReader
        {
               MyBufferReader(MyTextReader text)
               {}
               MyBufferReader(MyMediaReader media)
               {}
        }
       上面这个类扩展性很差。
       找到其参数的共同类型。通过多态的形式。可以提高扩展性。

        class MyBufferReader extends MyReader
        {
               private MyReader r;
               MyBufferReader(MyReader r)
               {}
        }

        MyReader//专门用于读取数据的类。
        |--MyTextReader
        |--MyMediaReader
        |--MyDataReader
        |--MyBufferReader

以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。

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


装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

实例：

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

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



class  PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person();

		SuperPerson sp = new SuperPerson(p);
		sp.superEat();

	}
}

模拟一个BufferedReader类。

明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader

import java.io.*;
class MyBufferedReader extends Reader
{
	
	private Reader r;
	MyBufferedReader(Reader r)
	{
		this.r = r;
	}

	//可以一次读一行数据的方法。
	public String myReadLine()throws IOException
	{
		//定义一个临时容器。原BufferReader封装的是字符数组。
		//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while((ch=r.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}

		if(sb.length()!=0)
			return sb.toString();
		return null;		
	}

	/*
	覆盖Reader类中的抽象方法。

	*/
	public int read(char[] cbuf, int off, int len) throws IOException
	{
		return r.read(cbuf,off,len) ;
	}

	public void close()throws IOException
	{
		r.close();
	}
	public void myClose()throws IOException
	{
		r.close();
	}
}


class  MyBufferedReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("buf.txt");

		MyBufferedReader myBuf = new MyBufferedReader(fr);

		String line = null;

		while((line=myBuf.myReadLine())!=null)
		{
			System.out.println(line);
		}

		myBuf.myClose();
	}
}

模拟一个LineNumberReader类。

class MyLineNumberReader 
{
	private Reader r;
	private int lineNumber;
	MyLineNumberReader(Reader r)
	{
		this.r = r;
	}

	public String myReadLine()throws IOException
	{

		lineNumber++;
		StringBuilder sb = new StringBuilder();

		int ch = 0;

		while((ch=r.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public void setLineNumber(int lineNumber)
	{
		this.lineNumber = lineNumber;
	}
	public int getLineNumber()
	{
		return lineNumber;
	}

	public void myClose()throws IOException
	{
		r.close();
	}
}