设计模式之装饰器模式

装饰器模式一、

// 抽象组件。
public interface Component{
	// 装饰方法
	public void display();
}
// 具体组件1
public class ConcreteComponent1 implements Component{
	@Override
	public void display(){
		System.out.printlin("我是组件1")
	}
}
// 装饰者1
public class Decorator1 implements Component{
	private Component compeonent
	public Decoratoor1(Component concreteComponent){
		this. component = concreteComponent;
	}
	@Override
	public void display(){
		component.display();
		System.out.println("被装饰者1进行装饰");
	}
}
// 具体组件2
public class ConcreteComponent2 implements Component{
	@Override
	public void display(){
		System.out.line("我是组件2");
	}
}
// 具体装饰者2
public class Decorator2 implements Component{
	private Component component;
	public Decorator2(Component concreteComponent){
		this.component = concreteComponent;
	}
	@Override
	public void display(){
		component.display();
		System.out.println("被装饰者2装饰");
	}
}
public class Client{
	public static void main(String[] args){
		Component component1 = new ConcreteComponet1();
		component1.display();
		
		Decorator1 decorator1 = new Decorator1(component1);
		decorator1.display();
	} 
}

装饰器模式二、 抽象出装饰者的公共父类，避免编写重复方法

// 抽象组件。
public interface Component{
	// 装饰方法
	public void display();
}
// 装饰者公共父类
public class Decorator implements Comonent{
	private Component componet;
	public Decorator(Component concerteComponent){
		this.component = concerteComponent;
	}
	@Override
	public void display(){
		component.display();
	}
}
// 具体组件1
public class ConcreteComponent1 implements Component{
	@Override
	public void display(){
		System.out.printlin("我是组件1")
	}
}
// 装饰者1
public class Decorator1 extends Decorator{
	public Decoratoor1(Component concreteComponent){
		super(concreteComponent);
	}
	@Override
	public void display(){
		super.display();
		System.out.println("被装饰者1进行装饰");
	}
}
// 具体组件2
public class ConcreteComponent2 implements Component{
	@Override
	public void display(){
		System.out.line("我是组件2");
	}
}
// 具体装饰者2
public class Decorator2 extends Decorator{
	public Decorator2(Component concreteComponent){
		super(concerteComponent);
	}
	@Override
	public void display(){
		component.display();
		System.out.println("被装饰者2装饰");
	}
}
public class Client{
	public static void main(String[] args){
		Component component1 = new ConcreteComponet1();
		component1.display();
		
		Decorator1 decorator1 = new Decorator1(component1);
		decorator1.display();
		
		Decorator2 decorator2 = new Decorator2(component1);
		decorator2.display();	// 虽然被装饰者1装饰过，但这里只会拥有装饰者2的功能
	} 
}

以上两种方法，没有把目标方法装饰进已有的组件对象，组件对象不会拥有目标方法
装饰者模式三：

// 抽象组件。
public interface Component{
	// 装饰方法
	public void display();
}
// 装饰者公共父类
public interface Decorator{
	Component componentDecorated(Component component);
}
// 具体组件1
public class ConcreteComponent1 implements Component{
	@Override
	public void display(){
		System.out.printlin("我是组件1")
	}
}
// 装饰者1
public class Decorator1 implements Decorator{
	private Component component
	@Override
	public Component componentDecorated(Component concreteComponent){
		this.component = concreteComponent;
		return new ComponentDecorated(); // 返回被装饰的对象
	}
	// 内部类
	class ComponentDecorated implements Component{
		@Override
		public void display(){
			if(component != null){
				component.display();
			}
			System.out.println("装饰者1进行装饰")
		}
	}
}
// 具体组件2
public class ConcreteComponent2 implements Component{
	@Override
	public void display(){
		System.out.line("我是组件2");
	}
}
// 具体装饰者2
public class Decorator2 implements Decorator{
	private Component component
	@Override
	public Component componentDecorated(Component concreteComponent){
		this.component = concreteComponent;
		return new ComponentDecorated(); // 返回被装饰的对象
	}
	// 内部类
	class ComponentDecorated implements Component{
		@Override
		public void display(){
			if(component != null){
				component.display();
			}
			System.out.println("装饰者2进行装饰");
		}
	}
}
public class Client{
	public static void main(String[] args){
		Component component1 = new ConcreteComponet1();
		component1.display();
		
		Decorator decorator1 = new Decorator1();
		component1 = decorator1.componentDecorated(component1);
		component1.display();
		
		Decorator decorator1 = new Decorator2();
		component1 = decorator2.componentDecorated(component1);
		compponent1.display();	// 会有decorator1 装饰的功能。一旦被装饰者装饰，就不能移除被装饰的功能
	} 
}

装饰者模式4：
若想能够根据需要添加或者移除被装饰的功能。可以在组件的公共父类中声明一个Map或List，Map的value或List用来存储装饰者，并遍历这些装饰者装饰的功能。提供添加或者移除方法，能够添加或者移除装饰者，达到添加或者移除功能的效果。

	// 抽象组件
	public abstract class Component{
		 protected Map<String,Decorate> decorateMap = new HashMap<>();
		 // 添加装饰者
		 public void addDecorator(Decorator decorator){
		 	decoratorMap.put(decorator.getClass().getName(), decorator);
		 }
		 // 移除装饰者
		 public void removeDecorator(Decorator decorator){
		 	decoratorMap.remove(decorator.getClass().getName());
		 }
		 public void display();
	}
	// 抽象装饰者
	public abstract class Decorator{
		// 装饰的方法入口
		public void decorateMethod();
	}
	// 具体组件1
	public class ConcreteComponent1 extends Component{
		@Override
		public void display(){
			System.out.println("我是组件1");
			// 遍历装饰者，查看装饰了哪些功能
			decoratorMap.forEach((key, value) -> {
				value.decoratorMehod();
			})
		}
	}
	// 具体装饰者1
	public class ConcreteDecorato1 extends Decorator{
		@Override
		public void decoratorMethod(){
			method1();
			method2();
		}
		private void method1(){
			System.out.println("装饰了功能1-1")
		}
		private void method2(){
			System.out.println("装饰了功能1-2")
		}
	}
	// 具体组件2
	public class ConcreteComponent2 extends Component{
		@Override
		public void display(){
			System.out.println("我是组件2");
			// 遍历装饰者，查看装饰了哪些功能
			decoratorMap.forEach((key, value) -> {
				value.decoratorMehod();
			})
		}
	}
	// 具体装饰者2
	public class ConcreteDecorato2 extends Decorator{
		@Override
		public void decoratorMethod(){
			method1();
			method2();
		}
		private void method1(){
			System.out.println("装饰了功能2-1")
		}
		private void method2(){
			System.out.println("装饰了功能2-2")
		}
	}
	public class Client{
		public static void main(String[] args){
			Component component1 = new ConcreteComponent();
			component1.display();	// 未装饰
			System.out.println("*****************************")
			
			compont1.addDecorator(new ConcreteDecorator1());
			component1.display();	// 装饰了装饰者1的功能
			System.out.println("*****************************")
		
			component1.addDecortor(new ConcreteDecorator2());
			component1.display();	// 在装饰了装饰者1的功能的基础上装饰了装饰了装饰者2的功能
			System.out.println("*****************************")
			
			component1.removeDecorator(new ConcreteComponent1());
			component1.display();	// 移除了装饰者2的功能
		}
	}