设计模式-装饰模式(Decorator )

  装饰器在现实场景中很常见：譬如：你搭梯子上楼，一个梯子长度正好 3 米，而二楼刚好三米，这张梯子刚好，可是三楼却有5米高，为了上二楼，我们得把原来的梯子加长2米，刚好，四楼也正好比三楼高了2米，为了上四楼 梯子要得加长2米，而5楼却比四楼高了4米，这样梯子要得加长4米了。这种模式就是装饰模式（Decorator）

看图：

设计图

上代码：

public interface Ladder {
	int height();
}

具体组件：

public class ThreeMeterHighStaircase implements Ladder {
	private final int height = 3;
	
	public int height() {
		return height;
	}

}

装饰组件

public abstract class AbstractLadder implements Ladder {

	private Ladder ladder;
	
	public AbstractLadder(Ladder ladder) {
		this.ladder = ladder;
	}
	
	public AbstractLadder() {
		
	}
	
	public abstract int height();

}

具体组件

public class TwoMeterHight extends AbstractLadder {
	public final int height = 2;
	
	private Ladder ladder;
	
	public TwoMeterHight(Ladder ladder) {
		this.ladder = ladder;
	}

	@Override
	public int height() {
		return ladder.height() + height;
	}
}

使用：

	public static void main(String[] args) {
		ThreeMeterHighStaircase basic = new ThreeMeterHighStaircase();
		belongFloor(basic);
		
		AbstractLadder three = new TwoMeterHight(basic);
		belongFloor(three);
		
		AbstractLadder four = new TwoMeterHight(three);
		belongFloor(three);
		
		AbstractLadder five = new TwoMeterHight(new TwoMeterHight(four));
		belongFloor(five);
	}

	
	public static void belongFloor(Ladder ladder) {
		if(ladder.height() == 3) {
			System.out.println("二楼到了");
		}else if(ladder.height() == 5) {
			System.out.println("三楼到了");
		}else if(ladder.height() == 7) {
			System.out.println("四楼到了");
		}else if(ladder.height() == 11) {
			System.out.println("五楼楼到了");
		}
	}

二楼到了
三楼到了
三楼到了
5楼楼到了

在上一个例子

组件接口

public interface Car {

	public void assemble();
}

组件具体实现：

public class BasicCar implements Car {

	@Override
	public void assemble() {
		System.out.print("Basic Car.");
	}

}

装饰器

public class CarDecorator implements Car {

	protected Car car;
	
	public CarDecorator(Car c){
		this.car=c;
	}
	
	@Override
	public void assemble() {
		this.car.assemble();
	}

}

具体装饰器

public class LuxuryCar extends CarDecorator {

	public LuxuryCar(Car c) {
		super(c);
	}
	
	@Override
	public void assemble(){
		super.assemble();
		System.out.print(" Adding features of Luxury Car.");
	}
}

ublic class SportsCar extends CarDecorator {

	public SportsCar(Car c) {
		super(c);
	}

	@Override
	public void assemble(){
		super.assemble();
		System.out.print(" Adding features of Sports Car.");
	}
}

 测试实现：

public class DecoratorPatternTest {

	public static void main(String[] args) {
		Car sportsCar = new SportsCar(new BasicCar());
		sportsCar.assemble();
		System.out.println("\n*****");
		
		Car sportsLuxuryCar = new SportsCar(new LuxuryCar(new BasicCar()));
		sportsLuxuryCar.assemble();
	}

}

类图

从两个例子看出 装饰器模式：优势比较明显 要比子类继承更有优势 ，而且更加灵活，当选择数量较多时，易于维护和扩展。装饰器设计模式的缺点是它使用了很多相似类型的对象。装饰器模式在Java IO类中被大量使用，例如FileReader、BufferedReader等