继承,装饰者模式和动态代理之间的区别

Java中,需要对对象进行增强时,我们常用的三种方法是 继承, 装饰者模式和动态代理.现在,举个例子来描述这三者之间的区别.

在星巴克喝咖啡时, 可以选择各种调味品, 黑咖啡中可以选择加糖,加奶,加蜂蜜. 这样咖啡的味道被改变,我们可以说黑咖啡被"增强"了.用java代码这样表示:

/**
* 创建一个咖啡的类,里面有黑咖啡
*/
class Coffee{
void blankCoffee(){
System.out.println("黑咖啡");
}
}
/**
* 现在要对黑咖啡加糖
*/
class Sugar extends Coffee {
void blankCoffee() {
super.blankCoffee();
System.out.println("加糖");
}
}
/**
* 现在要对黑咖啡加奶
*/
class Milk extends Coffee {
void blankCoffee() {
super.blankCoffee();
System.out.println("加奶");
}
}

/**
* 现在要对黑咖啡加蜂蜜
*/
class Honey extends Coffee {
void blankCoffee() {
super.blankCoffee();
System.out.println("加蜂蜜");
}
}

这样子我们得到了三种不同口味的黑咖啡. 现在又有了新的问题, 要求要加奶又加糖的咖啡,需要给加奶的咖啡加上糖,用继承这样子来实现

/**
* 现在需要加奶加糖咖啡
*/
class SugarMilke extends Milk {
void blankCoffee() {
super.blankCoffee();
System.out.println("加糖");
}
}
...

可能还需要加奶加蜂蜜的咖啡... 多种排列组合就会出现很多类, 出现了新的一种口味又需要增加很多的类.

这时候我们用装饰者模式来解决这个问题

/**
* 首先定义一个接口来规范咖啡.
*/
interface Coffee {
void coffee();
}
/*
* 实现这个上面这个接口中的方法.
*/
class CoffeeImpl implements Coffee {
public void coffee(){
System.out.println("黑咖啡");
}
}
/*
* 在给黑咖啡添加调味品之前,我们先定义一个类,这个类是所有添加调味品咖啡的父类,进行包装
*/
class CoffeeWrapper implements Coffee {
private Coffee cof;
public CoffeeWrapper(Coffee cof){
this.cof = cof;
}
public void coffee(){
cof.coffee();
}
}

/**
* 加糖咖啡
*/
class Sugar extends CoffeeWrapper {
public Sugar(Coffee cof) {
super(cof);
}
public void coffee(){
super.coffee();
System.out.println("加糖");
}
}
/**
* 加奶咖啡
*/
class Milk extends CoffeeWrapper {
public Milk(Coffee cof) {
super(cof);
}
public void coffee(){
super.coffee();
System.out.println("加奶");
}
}
/**
* 蜂蜜咖啡
*/
class Honey extends CoffeeWrapper {
public Honey(Coffee cof) {
super(cof);
}
public void coffee(){
super.coffee();
System.out.println("加蜂蜜");
}
}

/**
* 演示
*/
public class Demo() {
public static void main(String[] args) {
//首先创建一个黑咖啡
Coffee cof = new CoffeeImpl();
//加糖咖啡
Coffee sugar = new Sugar(cof);
sugar.coffee();
//加糖又加奶咖啡
Coffee milk = new Milk(sugar);
sugar.coffee();
}
}

这样我们就解决了这个问题.

* 继承

  被增强的对象固定的

  增强的内容也是固定的

* 装饰者模式

  被增强的对象是可以切换的

  增强的内容是固定的

还有一种更加灵活的方式,面向切面编程(AOP) ,比装饰者模式更加灵活, 被增强的对象和增强的内容都是可以更换的.