装饰者模式的简单应用

目录

如果你想动态的扩展 一个类的功能，可以看看 java.io.InputStream的源码，

 * @see java.io.InputStream  抽象构件
 * @see java.io.FilterInputStream 抽象装饰类
 * @see java.io.BufferedInputStream 具体的装饰类
 * @see java.io.DataInputStream 具体的装饰类

源码如下：

抽象构件

public abstract class InputStream implements Closeable {
    public abstract int read() throws IOException;
}

抽象装饰类
装饰类 持有 抽象类（被装饰类）的 实例， 而且 是 volatile 修饰的，被多个线程共享，当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

public class FilterInputStream extends InputStream {

    protected volatile InputStream in;
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
      public int read() throws IOException {
        return in.read();
    }

具体的装饰类

public
class DataInputStream extends FilterInputStream{

 public DataInputStream(InputStream in) {
        super(in);
    }
   public final int read(byte b[]) throws IOException {
        return in.read(b, 0, b.length);
    }

}

或者

public
class BufferedInputStream extends FilterInputStream {

}

* 就是 抽象类A 被 继承者B 继承， 继承者B 拥有 抽象类的 实例，又有很多的 实现类CDEF 来 继承 继承者B，每个 CDEF 都可以 给这个 A的方法做 任何 操作，

public class DecoratorPattern {
    //抽象构件(Component)
    static abstract class Man {
        abstract void aboutMe();
    }

    //具体的构件(ConcreteComponent)
    static class Potato extends Man {

        @Override
        public void aboutMe() {
            System.out.print("Hi，我是土豆");
        }
    }

    //抽象装饰类(Decorator)
    static abstract class Decorator extends Man {
        private Man man;

        protected Decorator(Man man) {
            this.man = man;
        }

        @Override
        public void aboutMe() {
            man.aboutMe();
        }
    }

    //具体装饰类（ConcreteDecorator）
    static class ProgrammerDecorator extends Decorator {
        public ProgrammerDecorator(Man man) {
            super(man);
        }

        @Override
        public void aboutMe() {
            super.aboutMe();
            System.out.print("，我的职业是程序员");
        }
    }

    //具体装饰类（ConcreteDecorator）
    static class ReaderDecorator extends Decorator {
        public ReaderDecorator(Man man) {
            super(man);
        }

        @Override
        public void aboutMe() {
            super.aboutMe();
            System.out.print("，我喜欢读书");

        }
    }

    //具体装饰类（ConcreteDecorator）
    static class GitHubDecorator extends Decorator {
        public GitHubDecorator(Man man) {
            super(man);
        }

        @Override
        public void aboutMe() {
            super.aboutMe();
            System.out.print("，闲暇时我喜欢在 GitHub 上溜达");

        }
    }

    //具体装饰类（ConcreteDecorator）
    static class WriterDecorator extends Decorator {
        public WriterDecorator(Man man) {
            super(man);
        }

        @Override
        public void aboutMe() {
            super.aboutMe();
            System.out.print("，也会去写一些技术文章");

        }
    }

    //具体装饰类（ConcreteDecorator）
    public static void main(String[] args) {
        Man potato = new Potato();
        potato.aboutMe();
        //Hi，我是土豆

        System.out.println();

        potato = new WriterDecorator(
                new GitHubDecorator(
                new ReaderDecorator(
                        new ProgrammerDecorator(potato))));
        potato.aboutMe();
        //Hi，我是土豆，我的职业是程序员，我喜欢读书，闲暇时我喜欢在 GitHub 上溜达，也会去写一些技术文章
    }
}