Java设计模式-装饰器模式

Java设计模式-装饰器模式

原创  2017年08月27日 18:30:34

• 193

装饰器设计模式顾名思义就是装饰某个对象，让一个功能单一的对象拥有一些其他的功能，这些功能的添加是动态的。用户可以随意的扩展原有对象的功能。一方面代替了继承，相对于继承带来的功能扩展，装饰器模式可以理解为动态的扩展，用户需要什么就扩展什么功能，非常灵活，而继承带来的缺点就是不方便修改，是静态的扩展。由于他的方便也带来了缺点，在装饰的过程中，其实创建了很多的对象占据内存资源，这些对象大多都很相似，排查错误也是有很大困难。

比如有一根电线，现在只有铜丝，只不过现在只能导电，我们在他的外面加一层绝缘体比如橡胶，这样他在导电的同时还安全了，外部具有绝缘的功能。

装饰器模式中有一个抽象的对象，定义为接口，为什么这么定义呢，这里的例子是电脑的例子，先定义一个基本的电脑，他可以是笔记本电脑，台式电脑，平板电脑等等，但是他们都有相同的基本信息，他们有名字，有价格。我们定义所有电脑基本的抽象方法（更像是一种规范），后期如果有新式的电脑出现，新的名字，新的价格出现，最基本的是这些。

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. public interface AbstractComputer {  
4.     public abstract String name();  
5.   
6.     public abstract double price();  
7. }  

下面是一个对接口的实现，也是对抽象产品的具体化，这个实现可能会有很多，有恨多品牌名字价格的电脑，也是为什么要定义一个抽象类或者接口。假设电脑的基本价格是3000，名字叫做普通电脑。

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. public class Computer implements AbstractComputer{  
4.   
5.   
6.     @Override  
7.     public String name() {  
8.         return "普通电脑";  
9.     }  
10.   
11.     @Override  
12.     public double price() {  
13.         return 3000;  
14.     }  
15.   
16.   
17. }  

下面我们对这个电脑进行改进，我们要在电脑里加内存条，增大运行内存。定义一个抽象的原件类，同样实现接口，为什么这样呢？

装饰者模式必然有一个公共的接口或抽象类，用来作为对象的传递。你需要根据接口实现基本的被装饰类，以及装饰类的公共接口，以后所有的装饰类都是继承自公共的装饰类接口，内部实现。

在逻辑上也是可以说的过去的，电脑配件依附于电脑，拥有和电脑一样的属性。

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. public abstract class Device implements AbstractComputer{  
4.   
5.   
6.     public abstract String name();  
7.   
8.     public abstract double price();  
9. }  

接下来具体要装饰的内容

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. /*内存类*/  
4.   
5. public class Memory extends Device{  
6.   
7.     public AbstractComputer computer;  
8.   
9.     public Memory(AbstractComputer computer) {  
10.         this.computer = computer;  
11.     }  
12.   
13.     public String name() {  
14.         return computer.name() + "加内存";  
15.     }  
16.   
17.     public double price() {  
18.         return computer.price() + 300;  
19.     }  
20.   
21. }  

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. /*硬盘类*/  
4.   
5. public class HardDisk extends Device{  
6.     public AbstractComputer computer;  
7.   
8.     public HardDisk(AbstractComputer computer) {  
9.         this.computer = computer;  
10.     }  
11.   
12.     public String name() {  
13.         return computer.name() + "加硬盘";  
14.     }  
15.   
16.     public double price() {  
17.         return computer.price() + 500;  
18.     }  
19. }  

在装饰的过程中最重要的就是子类继承父类，在执行子类的构造方法的时候，会隐式调用super()，如下

[java]  view plain  copy

1. public Memory(AbstractComputer computer) {  
2.         super();  
3.         this.computer = computer;  
4.     }  

[java]  view plain  copy

1. public HardDisk(AbstractComputer computer) {  
2.         super();  
3.         this.computer = computer;  
4.     }  

接下来写测试类

[java]  view plain  copy

1. package demo_dectorator;  
2.   
3. /* 
4. * 客户类，测试装饰器模式*/  
5.   
6. public class Client {  
7.     public static void main(String[] args) {  
8.   
9.         Computer computer = new Computer();  
10.   
11.         HardDisk h = new HardDisk(computer);  
12.         System.out.println(h.name());  
13.         System.out.println("价格:"+h.price());  
14.   
15.         Memory m = new Memory(computer);  
16.         System.out.println(m.name());  
17.         System.out.println("价格:"+m.price());  
18.   
19.         HardDisk h1=new HardDisk(m);  
20.         System.out.println(h1.name());  
21.         System.out.println("价格:"+h1.price());  
22.   
23.   
24.     }  
25. }  

输出结果

[plain]  view plain  copy

1. 普通电脑加硬盘  
2. 价格:3500.0  
3. 普通电脑加内存  
4. 价格:3300.0  
5. 普通电脑加内存加硬盘  
6. 价格:3800.0  

装饰器模式很好的体现开闭原则：对于扩展是开放的，对于修改是关闭的。用户可以动态添加功能。在java的io流中也是应用了装饰器模式。

版权声明：本文为博主原创文章，未经博主允许不得转载。 http://blog.csdn.net/qq_38663729/article/details/77622086

• 本文已收录于以下专栏：
• Java常用设计模式