装饰类 比继承灵活在什么地方呢？  装饰不还是在内部调用了被装饰的类吗？谁给详细的解释下

装饰类之所以比继承灵活，是因为它避免了继承体系给程序带来的臃肿。因为继承只能是单继承的，如果你为了给这个类增加功能就使用继承，那么你就不能再去继承其他的类了。

假设有一个继承体系：
　　Ａ－｜－－Ａ１
　　　　｜－－Ａ２
　　　　｜－－Ａ３
当子类的功能都需要加强，且加强的方法基本一致时，如果采用继承覆写的方式，那么，继承体系显得臃肿（“三代”类出现），为了解决这个问题，引入一个装饰类Ａ‘继承Ａ，它的构造方法中有参数，这个参数就是你需要加强的对象引用，然后通过传入对象的方法加强相应功能。由于有了入参，可以通过多态的形式传入需要加强的对象。因此更加灵活。希望你ＬＺ能明白哈。

这个今天又个类似的问题
下面是我的笔记

1. 
   
2. /*装饰者设计模式与继承的比较
   
3. 
   
4. MyReader//专门用于读取数据-----继承的结构
   
5.         |--MyTextReader
   
6.                 |--MyBufferTextReader
   
7.         |--MyMediaReader
   
8.                 |--MyBufferMediaReader
   
9.         |--MyDataReader
   
10.                 |--MyBufferDataReader
    
11. 
    
12. class MyBufferReader
    
13. {
    
14.         MyBufferReader(MyTextReader text){
    
15.         }
    
16. 
    
17.         MyBufferReader(MyMediaReader text){
    
18.         }
    
19. 
    
20.         MyBufferReader(MyDataReader text){
    
21.         }
    
22. }
    
23. 该类的扩展性很差，
    
24. 找到其参数的共同类型，通过多态形式通过扩展性
    
25. 
    
26. class MyBufferReader extends MyReader                //继承公共父类，即MyReader，而不像继承结构中-继承MyReader的子类
    
27. {
    
28.         MyBufferReader(MyReader r){
    
29.         }
    
30. }
    
31. 
    
32. MyReader//专门用于读取数据的类-----装饰模式的结构
    
33.         |--MyTextReader
    
34.         |--MyMediaReader
    
35.         |--MyDataReader
    
36.         |--MyBufferReader     //组合结构
    
37. 
    
38. */
    
39. 
    
40. 
    
41. import java.io.*;
    
42. 
    
43. class MyBufferedReader extends Reader
    
44. {
    
45.         private Reader fr = null;
    
46.         MyBufferedReader(Reader fr){
    
47.                 this.fr = fr;
    
48.         }
    
49. 
    
50.         public String myReadLine() throws IOException{
    
51.                 StringBuilder sb = new StringBuilder();   //StringBuilder();
    
52.                 int ch = 0;
    
53.                 while ((ch = fr.read())!= -1)
    
54.                 {
    
55.                         if (ch=='\r')
    
56.                                 continue; // the keyword continue.
    
57.                         if(ch == '\n')
    
58.                                 return sb.toString();
    
59.                         sb.append((char)ch);
    
60.                 }
    
61.                 if (sb.length() != 0)
    
62.                         return sb.toString(); //important to return the last line.
    
63.                
    
64.                 return null;
    
65.         }
    
66. 
    
67.         public int read (char[] buf, int off, int len) throws IOException{
    
68.                 return read (buf, off, len);                //调用对象方法
    
69.         }
    
70. 
    
71.         public void close() throws IOException{
    
72.                 fr.close();                        //调用对象方法
    
73.         }
    
74. 
    
75.         public void myClose() throws IOException{
    
76.                 fr.close();
    
77.         }
    
78. 
    
79. }
    
80. 
    
81. class MyBufferedReaderDemo{
    
82. 
    
83.         public static void main(String[] args) throws IOException
    
84.         {
    
85.                 FileReader fr = new FileReader("buf.txt");
    
86.                 MyBufferedReader mr = new MyBufferedReader(fr);
    
87.                 String line = null;
    
88.                 while ((line = mr.myReadLine()) != null)
    
89.                 {
    
90.                         System.out.println(line);
    
91.                 }
    
92.                 System.out.println("Hello World!");
    
93.         }
    
94. }
    

复制代码

毕老师的课程是第19天
装饰和继承的比较