装饰者模式

  1 package com.beiwo.Io;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.FileReader;
  5 import java.io.IOException;
  6 
  7 /*
  8  
  9           需求1 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个行号。
 10           需求2 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号。
 11           需求5 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 行号。
 12           
 13           
 14           需求3 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个引号。
 15           
 16   //=========================================================
 17           需求4 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个引号 + 行号。
 18       
 19           需求6 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 引号。
 20           需求7 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 引号 + 行号。
 21  
 22    装饰者模式 ：  增强一个类的功能还可以让装饰者类之间互相装饰。
 23    
 24    使用装饰者模式的步骤:
 25     1.装饰者类中需要维护一个被装饰者类的引用。 引用就是你需要拓展功能的类。
 26     2.让一个装饰类有一个共同的父类或者是父接口  ： 可以让装饰者类之间互相装饰
 27     
 28     装饰者模式和继承的区别：
 29         继承实现的增强类：
 30         优点：代码结构清晰，而且实现简单
 31         缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。
 32     装饰模式实现的增强类：
 33         优点：内部可以通过多态技术对多个需要增强的类进行增强
 34         缺点：需要内部通过多态技术维护需要增强的类的实例。进而使得代码稍微复杂。
 35 
 36  37  */
 38 
 39 //带行号的
 40 class BufferedReadLineNum1 extends BufferedReader{
 41     
 42     //内部维护的被装饰者类
 43     BufferedReader bufferedReader;
 44     
 45     int count = 1;
 46     
 47     public BufferedReadLineNum1(BufferedReader read) throws IOException{
 48         super(read); // 意义就用保证不报错。
 49         this.bufferedReader = read;
 50     }
 51     
 52     //开始拓展功能
 53     public String  readLine() throws IOException {
 54         //调用被组装饰者类的拓展方法
 55         String content = bufferedReader.readLine(); //构造方法中传的是哪一个对象，调用的就是谁的方法。
 56         
 57         if(content == null){
 58             
 59             return null;
 60         }

 62         content = count+" "+content;
 63         count++;
 64         return content;
 65     }
 67 }
 68 
 69 //带分号的
 70 class BufferedReadLineSemi1 extends BufferedReader{
 71     
 72     //内部维护的被装饰者类
 73     BufferedReader bufferedReader;
 74   
 76     public BufferedReadLineSemi1(BufferedReader read) throws IOException{
 77         super(read); // 意义就用保证不报错。
 78         this.bufferedReader = read;
 79     }
 80     
 81     //开始拓展功能
 82     public String  readLine() throws IOException {
 83         //调用被组装饰者类的拓展方法
 84         //多态   可以是先互相装饰
 85         String content = bufferedReader.readLine();
 86         
 87         if(content == null){
 88             
 89             return null;
 90         }
 91         
 92         return content+";";
 93     }
 94     
 95 }
 96 
 97 //带引号的
 98 class BufferReaderLineMark extends BufferedReader{
 99     
100     //1.内部需要一个被装饰类的引用
101     BufferedReader bufferedReader ;
102     
103     public BufferReaderLineMark(BufferedReader read){
104         
105         super(read);
106         
107         this.bufferedReader = read;
108     }
109     
110     //开始拓展功能
111         public String  readLine() throws IOException {
112             //调用被装饰者类的拓展方法
113             //多态   可以是先互相装饰
114             String content = bufferedReader.readLine();
115             
116             if(content == null){
117                 
118                 return null;
119             }
120             
121             return """+content+""";
122         }
124 }
156 public class Demo2 {
157     
158     public static void main(String[] args) throws IOException {
159         
160         //1.开启一个通道，并且带一个文件路径
161         FileReader reader = new FileReader("C:\Users\Administrator\Desktop\ttt.txt");
162         //2.创建缓冲流
163         BufferedReader bufferedReader = new BufferedReader(reader);
164         //5.创建一个带引号的
165         BufferReaderLineMark lineMark = new BufferReaderLineMark(bufferedReader);
166         //3.创建一个带行号和引号的
167         BufferedReadLineNum1 lineNum1 = new BufferedReadLineNum1(lineMark); 
172         //4.创建一个带行号和引号和分号的
173         BufferedReadLineSemi1 lineSemi1 = new BufferedReadLineSemi1(lineNum1);

175         String content = null;
176         while((content = lineSemi1.readLine())!=null){
177             
178             System.out.println(content);
179         }
180         
181         //关闭资源
182         lineSemi1.close();
183         
184     }
185 }

这个装饰者就很好的用到了面向对象的特点，继承、多态，

1.因为有继承才可以有多个类去对一个方法进行拓展，

2.因为有多态所以它们的构造器传入的参数类型不唯一，这样可以完成对不同类的装饰（在不同类的基础上进行功能拓展），