简单工厂模式、代理模式、策略模式如此相似

最近，一直在看设计模式，感觉简单工厂模式、代理模式、策略模式、依赖注入在实现方式上简直是大同小异。有些可能侧重点不同。下面通过代码比较下他们之间的区别，pk下。

1、定义个接口

package com.cvicse.Ifruit;

/**
 * 水果接口
 * 
 */
public interface Fruit {
	/**
	 * 水果生长
	 */
	public void grow();

	/**
	 * 吃水果
	 */
	public void eat();
}

 

2、定义该接口的实现类

 

package com.cvicse.fruitImpl;

import com.cvicse.Ifruit.Fruit;

public class Apple implements Fruit {

	public void eat() {
		System.out.println("吃苹果！");
	}

	public void grow() {
		System.out.println("苹果在生长！");
	}
}

package com.cvicse.fruitImpl;

import com.cvicse.Ifruit.Fruit;

public class Orange implements Fruit {

	public void eat() {
		System.out.println("吃橘子！");
	}

	public void grow() {
		System.out.println("橘子在生长！");
	}
}

 3、定义最关键的部分，仔细观察他们的区别

    工厂方法类

package com.cvicse.factory;

import com.cvicse.Ifruit.Fruit;
import com.cvicse.fruitImpl.Apple;
import com.cvicse.fruitImpl.Orange;

/**
 * 静态工厂类
 */
public class FruitFactory {
	// 采用类的反射机制获取类的实例
	public static Fruit fruitFactory(Class clazz) {
		Fruit fruit = null;
		try {
			fruit = (Fruit) Class.forName(clazz.getName()).newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return fruit;
	}

	/**
	 * 正宗静态方法
	 * 
	 * @param type
	 * @return
	 */
	public static Fruit fruitFactory(String type) {
		Fruit fruit = null;
		if ("apple".equals(type)) {
			fruit = new Apple();
		} else if ("orange".equals(type)) {
			fruit = new Orange();
		}
		return fruit;
	}
}

    代理模式类

package com.cvicse.factory;

import com.cvicse.Ifruit.Fruit;
import com.cvicse.fruitImpl.Apple;

/**
 * 代理模式实现类
 * 
 */
public class FruitProxy implements Fruit {

	private Fruit fruit;

	public FruitProxy() {
		this.fruit = new Apple();
	}

	public FruitProxy(Fruit fruit) {
		this.fruit = fruit;
	}

	public void eat() {
		fruit.eat();
	}

	public void grow() {
		fruit.grow();
	}
}

    策略模式类

package com.cvicse.factory;

import com.cvicse.Ifruit.Fruit;

/**
 *策略模式实现
 */
public class StrategyContext {
	private Fruit fruit;

	public StrategyContext(Fruit fruit) {
		this.fruit = fruit;
	}

	public void eat() {
		fruit.eat();
	}

	public void grow() {
		fruit.grow();
	}
}

  策略模式和工厂模式结合

package com.cvicse.factory;

import com.cvicse.Ifruit.Fruit;
import com.cvicse.fruitImpl.Apple;
import com.cvicse.fruitImpl.Orange;

public class StrategyFacoty {
	private Fruit fruit;

	public StrategyFacoty(String type) {
		if ("apple".equals(type)) {
			this.fruit = new Apple();
		} else if ("orange".equals(type)) {
			this.fruit = new Orange();
		}
	}

	public void eat() {
		fruit.eat();
	}

	public void grow() {
		fruit.grow();
	}
}

 总结：在实现上他们很相似，但有条原则是趋向遵从的就是组合优先，继承随后。