装饰模式及简单Java案例代码实现

说明：本文是《大话设计模式》的学习记录及结合网上相关信息编写，原书代码例子采用C#编写，本文采用Java稍加改写。如有不当，欢迎指正，共同进步。

 

1.装饰模式概述:

装饰模式（Pattern:Decorator）属于结构型模式，指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

 

2.装饰模式包含的角色及其职责:

（1）抽象构件角色[Component]：给出一个抽象接口，以规范准备接收附加责任的对象。
（2）具体构件角色[Concrete Component]：定义一个将要接收附加责任的类。
（3）装饰角色[Decorator]：持有一个构件（Component）对象的实例，并实现一个与抽象构件接口一致的接口。

（4）具体装饰角色[Concrete Decorator]：负责给构件对象添加上附加的责任。

 

3.策略模式的设计原则及UML类图:

（1）设计原则：

 

① 多用组合，少用继承。

 

       利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。

②类应设计的对扩展开放，对修改关闭。

 

（2）UML类图：

 

 

4.Java案例代码:

（1）装饰模式代码简化原则：

 

①如果只有一个Concrete Component类而没有抽象的Component接口时，可以让Decorator继承Concrete Component。

 

②如果只有一个Concrete Decorator类时，可以将Decorator和Concrete Decorator合并。

 

（2）代码结构图：

 

 

（3）具体构件角色：

package DecoratorPattern;

/**
 * 具体构建角色[ConcreteComponent]
 */
public abstract class Person {
	private String name;

	public Person() {
	}
	
	public Person(String name) {
		this.name = name;
	}
	
	public abstract void show();
	
}

（4）装饰角色：

package DecoratorPattern;

/**
 * 服饰类[Decorator]
 */
public class Finery extends Person {
	private Person person;
	
	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}

	//打扮
	public void Decorate(Person person) {
		this.person = person;
	}

	@Override
	public void show() {
		if (person != null) {
			person.show();
		}
	}

}

（5）具体装饰角色：

package DecoratorPattern;

/**
 * 具体服饰类[ConcreteDecorator]之‘T恤’
 */
public class TShirts extends Finery {
	@Override
	public void show() {
		System.out.print("T恤    ");// 在实际开发中，此应该为对人数据进行处理的过程。
		super.show();// 父类处理的过程
	}
}

/**
 * 具体服饰类[ConcreteDecorator]之‘垮裤’
 */
class BigTrouser extends Finery{
	@Override
	public void show() {
		System.out.print("垮裤    ");
		super.show();
	}
}

/**
 * 具体服饰类[ConcreteDecorator]之‘破球鞋’
 */
class Sneakers extends Finery{
	@Override
	public void show() {
		System.out.print("破球鞋    ");
		super.show();
	}
}

/**
 * 具体服饰类[ConcreteDecorator]之‘西装’
 */
class Suit extends Finery{
	@Override
	public void show() {
		System.out.print("西装    ");
		super.show();
	}
}

/**
 * 具体服饰类[ConcreteDecorator]之‘领带’
 */
class Tie extends Finery{
	@Override
	public void show() {
		System.out.print("领带    ");
		super.show();
	}
}

/**
 * 具体服饰类[ConcreteDecorator]之‘皮鞋’
 */
class LeatherShoes extends Finery{
	@Override
	public void show() {
		System.out.print("皮鞋    ");
		super.show();
	}
}

（6）客户端测试代码：

package DecoratorPattern;

public class Test {
	public static void main(String[] args) {
		String name = "小菜";
		Person person = new Person(name) {
			@Override
			public void show() {
				System.out.print("装扮的" + name);
			}
		};
		
		System.out.print("第一种装扮：");
		Sneakers sneakers = new Sneakers(); //破球鞋
		BigTrouser bigTrouser = new BigTrouser(); //垮裤
		TShirts tShirts = new TShirts(); //T恤
		
		sneakers.Decorate(person);
		bigTrouser.Decorate(sneakers);
		tShirts.Decorate(bigTrouser);
		tShirts.show();
	//----------------------------------------------------------
		System.out.print("\n第二种装扮：");
		LeatherShoes leatherShoes = new LeatherShoes(); //皮鞋
		Tie tie = new Tie(); //领带
		Suit suit = new Suit(); //西装
		
		leatherShoes.Decorate(person);
		tie.Decorate(leatherShoes);
		suit.Decorate(tie);
		suit.show();
	}

}

（7）客户端测试代码结果：

 

5.装饰模式的优缺点及使用场景:

（1）优点：

①装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。

②通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。

（2）缺点：

①这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。
②装饰模式会导致设计中出现许多小类，如果过度使用，会使程序变得很复杂。

③装饰模式是针对抽象组件（Component）类型编程。但是，如果你要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。当然也可以改变Component接口，增加新的公开的行为，实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。

（3）应用场景：

①需要扩展一个类的功能，或给一个类添加附加职责。
②需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
③需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
④当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。