浅谈装饰模式

装饰与继承的区别：

装饰：基于已有的功能，并提供加强功能，装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。相对于继承来说装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。英文叫：Decorator

继承：因为要扩展某个功能，就得继承父类，然后覆盖重写，导致这个体系更加臃肿，并且内存占用高。

一般情况下，其实接口也可以当做一种抽象类来看待，也就是说父类对象也可以是接口，如果一个类A实现了一个接口T，当我们在声明实例：T t =new A();时，t看起来是一个T，本质上是一个A，这也是多态的一种！

验证一下，首先先创建一个接口a：

public class test {
   interface a{
       void fun();
   }
   class b implements a{

    public void fun() {
        System.out.println("这个实现接口类！");
    }
       
   }
   class c extends  b{
       public void fun(){
           System.out.println("这是实现接口类的子类！！");
       }
   }
   public static void main(String[] args) {
        a dd = new test().new c();
       dd.fun();
    }
}

运行：

 例1：

摘自CSDN的一位大神的例子，看这个程序只要多态的功能理清楚也就明白了，说白了装饰模式无非就是多态与构造方法的灵活运用罢了：

public class decorateMode{
    //定义被装饰者
    public interface Human {
        public void wearClothes();

        public void walkToWhere();
    }

    //定义装饰者
    public abstract class Decorator implements Human {
        private Human human;

        public Decorator(Human human) {
            this.human = human;
        }

        public void wearClothes() {
            human.wearClothes();
        }

        public void walkToWhere() {
            human.walkToWhere();
        }
    }

    //下面定义三种装饰，这是第一个，第二个第三个功能依次细化，即装饰者的功能越来越多
    public class Decorator_zero extends Decorator {

        public Decorator_zero(Human human) {
            super(human);
        }

        public void goHome() {
            System.out.println("进房子。。");
        }

        public void findMap() {
            System.out.println("书房找找Map。。");
        }

        public void wearClothes() {
            // TODO Auto-generated method stub
            super.wearClothes();
            goHome();
        }

        public void walkToWhere() {
            // TODO Auto-generated method stub
            super.walkToWhere();
            findMap();
        }
    }

    public class Decorator_first extends Decorator {

        public Decorator_first(Human human) {
            super(human);
        }

        public void goClothespress() {
            System.out.println("去衣柜找找看。。");
        }

        public void findPlaceOnMap() {
            System.out.println("在Map上找找。。");
        }

        public void wearClothes() {
            // TODO Auto-generated method stub
            super.wearClothes();
            goClothespress();
        }

        public void walkToWhere() {
            // TODO Auto-generated method stub
            super.walkToWhere();
            findPlaceOnMap();
        }
    }

    public class Decorator_two extends Decorator {

        public Decorator_two(Human human) {
            super(human);
        }

        public void findClothes() {
            System.out.println("找到一件D&G。。");
        }

        public void findTheTarget() {
            System.out.println("在Map上找到神秘花园和城堡。。");
        }

        public void wearClothes() {
            // TODO Auto-generated method stub
            super.wearClothes();
            findClothes();
        }

        public void walkToWhere() {
            // TODO Auto-generated method stub
            super.walkToWhere();
            findTheTarget();
        }
    }

    //定义被装饰者，被装饰者初始状态有些自己的装饰
    public class Person implements Human {

        public void wearClothes() {
            // TODO Auto-generated method stub
            System.out.println("穿什么呢。。");
        }

        public void walkToWhere() {
            // TODO Auto-generated method stub
            System.out.println("去哪里呢。。");
        }
    }
    //测试类，看一下你就会发现，跟java的I/O操作有多么相似
    public static void main(String[] args) {
        decorateMode decorateMode=new decorateMode();
        Human person =decorateMode. new Person();
        Decorator decorator = decorateMode.new Decorator_two(decorateMode.new Decorator_first(
                decorateMode.new Decorator_zero(person)));
        decorator.wearClothes();
        decorator.walkToWhere();
    }
}

  运行结果：

 例2:

读取文件的行内容，并给每行前加上行数、行后加上分号

package com.beiwo.Io;

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

/*
 
 BufferedReader : 拓展FileReader的功能。
 
          需求1 ：实现通过readLine读取代码  ，每一行加上一个行号。
          需求2 ：实现通过readLine读取代码  ，每一行加上一个分号。
          需求3 ：实现通过readLine读取代码  ，每一行加上一个引号。
          
  //=========================================================
          需求4 ：实现通过readLine读取代码  ，每一行加上一个引号 + 行号。
          需求5 ：实现通过readLine读取代码  ，每一行加上一个分号 + 行号。
          需求6 ：实现通过readLine读取代码  ，每一行加上一个分号 + 引号。
          需求7 ：实现通过readLine读取代码  ，每一行加上一个分号 + 引号 + 行号。
          
     如果用继承：
              好处：代码结构和清晰容易理解
              缺点：继承体系会很庞大。实现七个需求就得创建七个子类
              
  
  装饰者模式 ：  增强一个类的功能还可以让装饰者类之间互相装饰。
              
    
 
 */

//添加行号
class BufferedReaderLineNum extends BufferedReader{
    //定义一个对象来接收传进来的对象
    BufferedReader bufferedReader;
    int count = 1;
    
    //子类继承父类会默认调用父类的无参构造方法
    public BufferedReaderLineNum (BufferedReader in) {
        super(in);
        this.bufferedReader = in;
    }
    
    //复写readLine方法
    @Override
    public String readLine() throws IOException {
        // TODO Auto-generated method stub
        //调用父类的readLine
        String content = bufferedReader.readLine();
        //给内容田间一个行号
        if(content == null){
            
            return null;
        }
        content = count+"  "+content;
        count++;
        return content;
    }
    
}

//添加分号的
class BufferedReaderLineSemi extends BufferedReader{
    //定义一个对象来接收传进来的对象
    BufferedReader bufferedReader;
    //子类继承父类会默认调用父类的无参构造方法
    public BufferedReaderLineSemi (BufferedReader in) {
        super(in);
        this.bufferedReader = in;
    }
    
    //复写（重写）readLine方法
    @Override
    public String readLine() throws IOException {
        // TODO Auto-generated method stub 
        //调用父类的readLine
        String content = bufferedReader.readLine();
        //给内容田间一个行号
        if(content == null){//表示数据已经读完
            
            return null;
        }
        
        return content+";";
    }
    
}



public class Demo1 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        testLineNum();
    }
    
    public static void testLineNum () throws IOException{
        
        //1.开启一个通道，并且带一个文件路径
        FileReader reader = new FileReader("这里填上文件路径如：C:\a.java");
        //创建缓冲流
        BufferedReader bufferedReader = new BufferedReader(reader);
        //2.创建一个带分号的缓冲流
        BufferedReaderLineSemi lineSemi = new BufferedReaderLineSemi(bufferedReader);  
        //创建一个缓冲流 ，带行号加分号
        BufferedReaderLineNum lineNum = new BufferedReaderLineNum(lineSemi);
        //3.开始读取数据
        String content = null;
        while((content = lineNum.readLine())!=null){
            
            System.out.println(content);
        }
        
        //4.关闭资源
        lineNum.close();
    }
}

效果：