Java设计模式—装饰模式

 

（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/51570272冷血之心的博客）

目录

装饰模式

定义：

通用类图：

角色分类：

抽象构件(Component)

具体构件(ConcreteComponent)

装饰角色(Docorator)

具体装饰角色(ConcreteDecoratorA和B)

 装饰模式与类继承的区别：

装饰模式的特点：

案例分析：

输出结果如图所示：

分析1：

分析2：

分析3：

分析4：

分析5：

分析6：

分析7：

---

装饰模式

是一种比较常见的模式

定义：

动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更加灵活。

通用类图：

饰模式的构成：

抽象构件(Component)

是一个接口或者是抽象类，就是定义我们最核心的对象，也就是原始的对象。

******在装饰模式中必须有一个最基本，最核心，最原始的接口或者抽象类来充当Component抽象构件******

 

具体构件(ConcreteComponent)

是最核心，最原始，最基本的接口或者抽象类的实现，你要装饰的就是它。

 

装饰角色(Docorator)

一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象方法呀，在它的属性里必然有一个private变量指向Component抽象构件。

 

具体装饰角色(ConcreteDecoratorA和B)

是两个具体的装饰类，你要把你最核心，最原始，最基本的东西装饰成其他东西。

 

装饰模式与类继承的区别：

 

• 装饰模式是一种动态行为，对已经存在类进行随意组合，而类的继承是一种静态的行为，一个类定义成什么样的，该类的对象便具有什么样的功能，无法动态的改变。
• 装饰模式扩展的是对象的功能，不需要增加类的数量，而类继承扩展是类的功能，在继承的关系中，如果我们想增加一个对象的功能，我们只能通过继承关系，在子类中增加两个方法。
• 装饰模式是在不改变原类文件和使用继承的情况下，动态的扩展一个对象的功能，它是通过创建一个包装对象，也就是装饰来包裹真是的对象。

 

装饰模式的特点：

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

案例分析：

package zhuangshimoshi;
/*
 * 装饰模式
 */
public class Test {

	public static void main(String[] args) {
		//要修饰的对象com
		Component com=new ConcreteComponent();
		
		//进行第一次修饰
		com=new ConcreteDecorator1(com);
		
		//进行第2次修饰
		com=new ConcreteDecorator2(com);
		
		com.operate();
		
		//com=new ConcreteDecorator2(new ConcreteDecorator1(new ConcreteComponent()));
		

	}

}

//抽象构件
abstract class Component{
	//抽象方法
	public abstract void operate();
}

//具体构件
class ConcreteComponent extends Component{

      //具体实现
	public void operate() {
		System.out.println("这里是具体构件，实现了抽象构件中的方法");
	}
	
}

//抽象装饰者，一般为一个抽象类
abstract class Decorator extends Component{
	//必须有一个private变量指向Component抽象构件
	private Component component;
	//通过构造函数传递被修饰者
	public Decorator(Component component)
	{
		System.out.println("这里是抽象类Decortor...");
		this.component=component;
	}
	
	//委托给被修饰者执行
	public void operate()
	{
		System.out.println("父类的操作方法...");
		this.component.operate();
	}
}

//具体的装饰类
class ConcreteDecorator1 extends Decorator{

	//定义被装饰者
	public ConcreteDecorator1(Component component) {
		super(component);
		
	}
	//定义自己的修饰方法
	private void method1()
	{
		System.out.println("method1修饰。。。");
	}
	
	//重写父类的operate方法
	public void operate()
	{
		this.method1();
		super.operate();
	}
	
}

class ConcreteDecorator2 extends Decorator{

	//定义被装饰者
	public ConcreteDecorator2(Component component) {
		super(component);
		
	}
	//定义自己的修饰方法
	private void method2()
	{
		System.out.println("method2修饰。。。");
	}
	
	//重写父类的operate方法
	public void operate()
	{
		super.operate();
		this.method2();
	}
	
}

输出结果如图所示：

分析1：

主函数中执行了com=new ConcreteDecorator1(com);这个语句，将调用ConcreteDecorator1的构造函数，接着调用父类的构造函数，所以输出了一句“这里是抽象类Decortor...”。

分析2：

同理执行了com=new ConcreteDecorator2(com);也输出了“这里是抽象类Decortor...”。

分析3：

执行了com.operate()，首先是ConcreteDecorator2类的operate()方法被执行，即super.operate();，此时要执行其父类的operate()。父类Decorator的operate()方法被执行，输出了“父类的操作方法...”。

分析4：

接着执行this.component.operate();语句。注意了！！！！此时component对象指的是ConcreteDecorator1类的对象，即将要执行的ConcreteDecorator1类中的operate()方法，所以输出了"method1修饰。。。"

分析5：

接着执行super.operate();语句，又回到父类Decorator中的operate()方法，输出了“父类的操作方法...”。

分析6：

接着执行this.component.operate();语句。注意了！！！！此时component对象指的是ConcreteComponent类的对象，所以执行ConcreteComponent类的operate()方法。所以输出了"这里是具体构件，实现了抽象构件中的方法"。

分析7：

最后执行this.method2();语句，输出"method2修饰。。。"

以上是本例的详细解释，得多看几遍细细领悟才行。

 

如果对你有帮助，记得点赞哦~欢迎大家关注我的博客，我会持续更新，如果有什么问题，可以进群366533258一起交流学习哦~