装饰者设计模式

/*
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类成为装饰类。

装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象提供更强的功能。

装饰类和继承的区别：

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

class MyBufferReader
{
private MyBufferTextReader text;
private MyBufferMediaReader media;
private MyBufferDataReader data;
MyBufferReader(MyBufferTextReader text)
{
this.text = text;
}
MyBufferReader(MyBufferMediaReader media)
{
this.media = media;
}
MyBufferReader(MyBufferDataReader data)
{
this.data = data;
}
}
上面这个类扩展性很差。
找到其参数的共同类型，通过多态的形式，可以提高扩展性。
eg：
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{
this.r = r;
}
}

通过装饰类优化后：
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader

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

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

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

/*对Person进行增强*/
class SuperPerson{
private Person p;
SuperPerson(Person p){
this.p = p;
}
public void superEat(){
System.out.println("开胃菜");
p.eat();
System.out.println("甜点");
}
}

class PersonDemo{
public static void main(String[] args) {
Person p = new Person();
//p.eat();
SuperPerson sp = new SuperPerson(p);
sp.eat();
}
}
/*-----------------------------------------------------------------*/
/*
eg:自定义字符流缓冲区包装类。
*/
import java.io.*;
class MyBufferedReader extends Reader{
private Reader r;
MyBufferedReader(Reader r){
this.r = r;
}

//可以一次读一行数据的方法
public String MyReaderLine()throws IOException{
/*
定义一个临时容器。原BufferedReader封装的是字符数组。
为了演示方便，定义一个StringBuilder容器。因为最终还是要变成字符串。
*/
StringBuilder sb = new StringBuilder();
while((int 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 MyClose()throws IOException{
r.close();
}

/*
覆盖Reader类中的抽象方法。
*/
public void close()throws IOException{
r.close();
}
public int read(char[] cbuf,int off,int len)throws IOException{
return r.read(cbuf,off,len);
}
}

class MyBufferedReaderDemo{
public static void main(String[] args){
FileReader fr = null;
MyBufferedReader mybr = null;
try{
fr = new FileReader("copyText.java");
mybr = new MyBufferedReader(fr);
while((String line = mybr.myReadLine()) != null){
System.out.println(mybr.MyReaderLine()+":"+line);
}
}catch (IOException e){
throw new IOException("读写失败！");
}finally{
try{
if(mybr != null)
mybr.myClose();
}catch (IOException e){
throw new IOException("读写失败！");
}
}
}
}
/*
eg:自定义带行号的字符流包装类。
*/
import java.io.*;
class MyLineNumberReader extends MyBufferedReader{
//private Reader r;
private int lineNumber;

MyLineNumberReader(Reader r){
//this.r = r;
super(r);
}
/*
public String myReadLine()
{
lineNumber ++;
StringBuilder sb = new StringBuilder();

while((int 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 void getLineNumber(){
return lineNumber;
}
/*
public void myClose()
{
r.close();
}
*/
}

class MyLineNumberReaderDemo{
public static void main(String[] args){
FileReader fr = null;
MyLineNumberReader mylnr = null;
try{
fr = new FileReader("copyText.java");
mylnr = new MyLineNumberReader(fr);
while((String line = mylnr.myReadLine()) != null){
System.out.println(mylnr.getLineNumber()+":"+line);
}
}catch (IOException e){
throw new IOException("读写失败！");
}finally{
try{
if(mylnr != null)
mylnr.myClose();
}catch (IOException e){
throw new IOException("读写失败！");
}
}
}
}
/*
eg:自定义字节流缓冲区包装类。
*/
import java.io.*;
class MyBufferedInputStream{
private InputStream in;

private byte[] buffer = new byte[1024];

private int pos = 0;

private int count = 0;

MyBufferedInputStream(InputStream in){
this.in = in;
}

//一次读一个字节，从缓冲区(字节数组)获取。
public int myRead() throws IOException{
//通过in对象读取硬盘上数据，并存储buffer中
if(count == 0){
count = in.read(buffer);
if(count < 0)
return -1;
pos = 0;
byte b = buffer[pos];

count --;
pos ++;
return b&255;
}else if(count > 0){
byte b = buffer[pos];

count --;
pos ++;
return b;
}
return -1;
}
public void MyClose(){
in.close();
}
}