2.装饰者模式

装饰者模式类似于代理，你将一个对象传进去装饰类，它将此对象的同名方法做一些加强

1.要被修饰的父类

/**
 * 粮食
 * @author Administrator
 *
 */
public abstract class Beverage {
	String description="Unknown Beverage";
	public String getDescription(){
		return this.description;
	}
	public abstract double cost();
}

2.装饰的父类

/**
 * 加料
 * @author Administrator
 *
 */
public abstract class CondimentDecorator extends Beverage {
	public abstract String getDescription();
}

3.创建两种被修饰的类

public class Rice extends Beverage {
	public Rice(){
		description="饭";
	}
	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return 2.00;
	}

}
public class Noodle extends Beverage {
	public Noodle() {
		description="粉";
	}
	
	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return 1.00;
	}

}

4.创建装饰类

public class Egg extends CondimentDecorator {
    private Beverage beverage;
    public Egg(Beverage beverage) {
		this.beverage=beverage;
	}
	@Override
	public String getDescription() {
		// TODO Auto-generated method stub
		return "蛋炒"+this.beverage.getDescription();
	}

	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return 0.5+this.beverage.cost();
	}
	

}

5.组合(把被修饰的类进行装饰加强)

public class Cook {
	public static void main(String[] args) {
		//饭
		Rice rice=new Rice();
		//粉
		Noodle noodle=new Noodle();
		//蛋炒饭
		Egg eggRice=new Egg(rice);
		System.out.println("套餐:"+eggRice.getDescription()+",售价:"+eggRice.cost());
		//蛋炒粉
		Egg eggNoodle=new Egg(noodle);
		System.out.println("套餐:"+eggNoodle.getDescription()+",售价:"+eggNoodle.cost());
		
		//炒饭再加个蛋
		Egg eggDoubleNoodle=new Egg(eggRice);
		System.out.println("套餐:"+eggDoubleNoodle.getDescription()+",售价:"+eggDoubleNoodle.cost());
	}
}

　　结果是这样的:

 tip:这里，你可以说，干嘛这么麻烦，继承不就搞定了，但是，你有没有想过，如果万一有一点，没有蛋炒饭和蛋炒粉这菜式了，那这两个类不就废弃了吗，而且还要重新写，但是如果你做成组件形式的，即使你没有这两样菜式了，但是只要是蛋炒别的，那你照样可以用这个调料装饰类。这样子不只提高了类的可用性，更减少了类的无限增长.关键点就是通过注入来继承被装饰类的方法和字段，而不是通过简单地继承父类的信息。