结合I/O讲讲装饰模式(Decorator)

简介

  • 装饰模式又名包装(Wrapper)模式
  • 装饰模式以对客户透明的方式扩展对象(并非类)的功能,是继承关系的一个替代方案。
  • 装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之,客户端并不觉得对象在装饰前后有不同。
  • 装饰模式可以在不创造更多子类的情况下,将对象的功能扩展。

装饰模式的角色:

  • 抽象构件角色(Component):给出一个抽象接口,以规范准备接收附加责任的对象。
    例如:InputStream
  • 具体构件角色(Concrete Component):定义一个将要接受附加责任的对象。
    例如:FileInputStream
  • 装饰角色(Decorator):持有一个构件(Component)对象的引用,并定义一个与抽象构件接口一致的接口。
    例如:FilterInputStream
  • 具体装饰角色(Concrete Decorator):负责给构件对象贴上附加的责任。
    例如:BufferedInputStream

装饰模式的特点

  • 装饰对象和真实对象有相同的接口。这样客户端对象就可以以和真是对象相同的方式和装饰对象交互。
  • 装饰对象包含一个真实对象的引用(reference)。意味着,装饰对象可以调用真实对象的方法。
  • 装饰对象接收所有来自客户端的请求。它把这些请求转发给真实的对象。
  • 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时,不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中,通常是通过继承来实现对给定类的功能扩展。

一个简单的例子

抽象构件角色(Component)

public interface Component {
    void doSomething();
}

具体构件角色(ConcreteComponent)

public class ConcreteComponent implements Component {
    @Override
    public void doSomething() {
        System.out.println("功能A");
    }
}

装饰角色(Decorator)

public class Decorator implements Component {
    //包含一个抽象构件角色的引用
    private Component component;

    public Decorator(Component component){
        this.component = component;
    }
    @Override
    public void doSomething() {
        component.doSomething();
    }
}

具体装饰角色(ConcreteDecorator1)

public class ConcreteDecorator1 extends Decorator {

    public ConcreteDecorator1(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }
	//增强的功能
    private void doAnotherThing() {
        System.out.println("功能B");
    }
}

具体装饰角色(ConcreteDecorator2)

public class ConcreteDecorator2 extends Decorator {

    public ConcreteDecorator2(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }

    private void doAnotherThing() {
        System.out.println("功能C");
    }
}

客户端(Client)

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteDecorator2(
                new ConcreteDecorator1(
                        new ConcreteComponent()
                )
        );
        component.doSomething();
    }
}

最终输出的结果是:

功能A
功能B
功能C

优点

1、装饰器是继承的有力补充,比继承灵活,不改变原有对象的情况下动态地给一个对象扩展功能,即插即用。
2、通过使用不同装饰类以及这些装饰类的排列组合,可实现不同效果
3、装饰器完全遵守开闭原则。

缺点

1、会出现更多的代码,更多的类,增加程序复杂性
2、动态装饰时,多层装饰时会更复杂。

装饰模式VS继承

  • 装饰模式

    • 用来扩展特定对象的功能。
    • 不需要子类,防止由于子类而导致的复杂和混乱。
    • 动态,运行时分派职责。
    • 更过的灵活性。对于一个给定的对象,客户端可以选择合适的装饰。
  • 继承

    • 用来扩展一类对象的功能。
    • 需要子类。
    • 静态,编译时分派职责。
    • 缺乏灵活性。

装饰模式的适用性

  • 想要透明并且动态地给对象增加新的职责(方法)而不影响其它对象。
  • 给对象增加的职责在未来可能会发生改变。
  • 用子类扩展功能不实际的情况下。

看看I/O中活生生的例子

BufferedInputStream
FileterInputStream
额外提一下,这里为什么要用volatile,面试常考题:
1.做内存可见性的处理。当有多个线程的时候,每个线程会有自己的工作内存,此外还有一个总内存。如果一个线程修改了自己工作内存的变量值且不加volatile,在修改完的某瞬间,并不会更新到总内存。也就是其它线程看到的值没有变化。如果变量使用了volatile,会被立刻刷新到其它线程的工作内存。实际上,其它线程在处理被volatile修饰的变量的时候,会刷新一下自己的工作内存。
2.防止指令重排序。编译器为了优化代码,编译好的字节码定义的程序顺序可能和原来不一样,加上volatile可以避免。

©️2020 CSDN 皮肤主题: 岁月 设计师: pinMode 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值