在装饰设计模式中，为什么装饰类和被装饰类都必须所属同一个接口或者父类？

直接定义一个Buffer类来接收一个特定的输入流或输出流，然后再自定义一个缓冲区对流中的数据进行缓冲不就行了，
何必非要属于同一个接口或者父类呢？

我想象中的缓冲类如下：

class BufferWriter//此类跟本就没必要和被装饰类属于同一个接口或者父类！
{
       
        BufferWriter(Wirter w)
        {
       
        }
}


class BufferWriter extends Writer //此类为什么非要和被装饰类属于同一个接口或者父类呢？
{
        BufferWriter(Writer w)
        {
        }
}

这个就是装饰模式嘛,你看下

1. public class BufferedWriter extends Writer {
   
2.     //装饰模式
   
3.     private Writer out;
   
4. }
   
5.    //构造函数
   
6.     public BufferedWriter(Writer out, int sz) {
   
7.         super(out);
   
8.         if (sz <= 0)
   
9.             throw new IllegalArgumentException("Buffer size <= 0");
   
10.         this.out = out;
    
11.         cb = new char[sz];
    
12.         nChars = sz;
    
13.         nextChar = 0;
    
14.         //获取换行的符号\n \r,和方法System.getProperty("line.separator")一样
    
15.         lineSeparator =        (String) java.security.AccessController.doPrivileged(
    
16.                new sun.security.action.GetPropertyAction("line.separator"));
    
17.     }
    
18. //write有关
    
19. public void write(int c) throws IOException {
    
20.         synchronized (lock) {
    
21.             //判断是否有输出流
    
22.             ensureOpen();
    
23.             //如果缓存数组写满了，就flush数组。
    
24.             if (nextChar >= nChars)
    
25.                 flushBuffer();
    
26.             //将内容写入缓存数组中
    
27.             cb[nextChar++] = (char) c;
    
28.         }
    
29. }
    
30. //flush，这个方法就知道flush的重要性，
    
31. void flushBuffer() throws IOException {
    
32.         synchronized (lock) {
    
33.             ensureOpen();
    
34.             if (nextChar == 0)
    
35.                 return;
    
36.             //将数据写入流
    
37.             out.write(cb, 0, nextChar);
    
38.             nextChar = 0;
    
39.         }
    
40. }
    
41. 
    
42. public void write(String s, int off, int len) throws IOException {
    
43.         synchronized (lock) {
    
44.             ensureOpen();
    
45.             
    
46.             int b = off, t = off + len;
    
47.             while (b < t) {
    
48.                 int d = min(nChars - nextChar, t - b);
    
49.                 //将字符串转为字符数组
    
50.                 s.getChars(b, b + d, cb, nextChar);
    
51.                 //写入缓存数组
    
52.                 b += d;
    
53.                 nextChar += d;
    
54.                 if (nextChar >= nChars)
    
55.                     //如果写满了，就写入流中。
    
56.                     flushBuffer();
    
57.             }
    
58.         }
    
59. }
    
60. //writeLine 写一个换行
    
61. public void newLine() throws IOException {
    
62.         //同样写到缓存数组里
    
63.         write(lineSeparator);
    
64. }
    
65. //flush
    
66. public void flush() throws IOException {
    
67.         synchronized (lock) {
    
68.             flushBuffer();
    
69.             out.flush();
    
70.         }
    
71. }
    
72. //关闭资源
    
73. public void close() throws IOException {
    
74.         synchronized (lock) {
    
75.             if (out == null) {
    
76.                 return;
    
77.             }
    
78.             try {
    
79.                 //最后还释放了一次。不过没有执行flush方法，所以在close前还是要执行一次flush！
    
80.                 flushBuffer();
    
81.             } finally {
    
82.                 out.close();
    
83.                 out = null;
    
84.                 cb = null;
    
85.             }
    
86.         }
    
87. }

复制代码