装饰者模式

package com.beiwo.Io;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 
          需求1 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个行号。
          需求2 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号。
          需求5 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 行号。
          
          
          需求3 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个引号。
          
  //=========================================================
          需求4 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个引号 + 行号。
      
          需求6 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 引号。
          需求7 ：BufferedReader拓展实现通过readLine读取代码  ，每一行加上一个分号 + 引号 + 行号。
 
   装饰者模式 ：  增强一个类的功能还可以让装饰者类之间互相装饰。
   
   使用装饰者模式的步骤:
    1.装饰者类中需要维护一个被装饰者类的引用。 引用就是你需要拓展功能的类。
    2.让一个装饰类有一个共同的父类或者是父接口  ： 可以让装饰者类之间互相装饰
    
    装饰者模式和继承的区别：
        继承实现的增强类：
        优点：代码结构清晰，而且实现简单
        缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。
    装饰模式实现的增强类：
        优点：内部可以通过多态技术对多个需要增强的类进行增强
        缺点：需要内部通过多态技术维护需要增强的类的实例。进而使得代码稍微复杂。

 37  */

//带行号的
class BufferedReadLineNum1 extends BufferedReader{
    
    //内部维护的被装饰者类
    BufferedReader bufferedReader;
    
    int count = 1;
    
    public BufferedReadLineNum1(BufferedReader read) throws IOException{
        super(read); // 意义就用保证不报错。
        this.bufferedReader = read;
    }
    
    //开始拓展功能
    public String  readLine() throws IOException {
        //调用被组装饰者类的拓展方法
        String content = bufferedReader.readLine(); //构造方法中传的是哪一个对象，调用的就是谁的方法。
        
        if(content == null){
            
            return null;
        }

        content = count+" "+content;
        count++;
        return content;
    }
}

//带分号的
class BufferedReadLineSemi1 extends BufferedReader{
    
    //内部维护的被装饰者类
    BufferedReader bufferedReader;
  
    public BufferedReadLineSemi1(BufferedReader read) throws IOException{
        super(read); // 意义就用保证不报错。
        this.bufferedReader = read;
    }
    
    //开始拓展功能
    public String  readLine() throws IOException {
        //调用被组装饰者类的拓展方法
        //多态   可以是先互相装饰
        String content = bufferedReader.readLine();
        
        if(content == null){
            
            return null;
        }
        
        return content+";";
    }
    
}

//带引号的
class BufferReaderLineMark extends BufferedReader{
    
    //1.内部需要一个被装饰类的引用
    BufferedReader bufferedReader ;
    
    public BufferReaderLineMark(BufferedReader read){
        
        super(read);
        
        this.bufferedReader = read;
    }
    
    //开始拓展功能
        public String  readLine() throws IOException {
            //调用被装饰者类的拓展方法
            //多态   可以是先互相装饰
            String content = bufferedReader.readLine();
            
            if(content == null){
                
                return null;
            }
            
            return """+content+""";
        }
}
public class Demo2 {
    
    public static void main(String[] args) throws IOException {
        
        //1.开启一个通道，并且带一个文件路径
        FileReader reader = new FileReader("C:\Users\Administrator\Desktop\ttt.txt");
        //2.创建缓冲流
        BufferedReader bufferedReader = new BufferedReader(reader);
        //5.创建一个带引号的
        BufferReaderLineMark lineMark = new BufferReaderLineMark(bufferedReader);
        //3.创建一个带行号和引号的
        BufferedReadLineNum1 lineNum1 = new BufferedReadLineNum1(lineMark); 
        //4.创建一个带行号和引号和分号的
        BufferedReadLineSemi1 lineSemi1 = new BufferedReadLineSemi1(lineNum1);

        String content = null;
        while((content = lineSemi1.readLine())!=null){
            
            System.out.println(content);
        }
        
        //关闭资源
        lineSemi1.close();
        
    }
}

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

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

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