设计模式_工厂模式

简单工厂模式

简单工厂模式由三部分组成：工厂，产品接口，产品接口的具体实现类。
接口：

interface service{
	void doService();
}

接口实现：

class Eat implements Service{
	@Override
	public void doService() {
		System.out.println("陪吃服务");
	}
}
class Drink implements Service{
	@Override
	public void doService() {
		System.out.println("陪喝服务");
	}
}

class PlayGame implements Service{
	@Override
	public void doService() {
		System.out.println("陪玩游戏服务");
	}
}

工厂：

class Factory{
	public static Service getService(String serviceName){
		if(serviceName=="Eat")
			return new Eat();
		else if(serviceName=="Dringk")
			return new Drink();
		else if(serviceName=="PlayGame")
			return new PlayGame();
		else 
			throw new IllegalArgumentException("Sorry, No such service ");
	}
}

使用：

public class Demo {
	public static void main(String[] args) {
		Service service=Factory.getService("Eat");
		service.doService();
		service=Factory.getService("PlayGame");
		service.doService();		
	}
}

小结：工厂中有一个public static 修饰的方法，这样就可以直接通过工厂类调用静态方法获取对象实例即可。但是这种设计方式并不实用，因为再工厂类中要将每个实例都要写进去，要添加新的实例时，就需要修改工厂中的源代码，不符合开闭原则（对扩展开放，对修改封闭）。
可以通过反射来做一个简单工厂模式的变形，使其符合开闭原则。
工厂：

class ReflectFactory {
	public static Object getService (Class<?> class1) throws InstantiationException, IllegalAccessException {
		return class1.newInstance();
	}
}

使用：

public class Demo {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Service service=(PlayGame)ReflectFactory.getService(Class.forName("com.xixi.demo.PlayGame"));
		service.doService();
	}
}

工厂采用反射的方式来获取对象实例，这样就不会违反开闭原则了。只不过每次都要传Class对象。

工厂方法模式

工厂方法模式与简单工厂模式相比，对工厂进行了进一步的抽象。
抽象工厂：

interface Factory{
	Service getService();
}

具体工厂：

class DrinkFactory implements Factory{
	@Override
	public Service getService() {
		return new Drink();
	}
}
class EatFactory implements Factory{
	@Override
	public Service getService() {
		return new Eat();
	}	
}
class PlayGameFactory implements Factory{
	@Override
	public Service getService() {
		return new PlayGame();
	}
}

使用：

public class Demo {
	public static void main(String[] args) {
		Factory factory=new EatFactory();
		Service service=factory.getService();
		service.doService();
		factory=new PlayGameFactory();
		service=factory.getService();
		service.doService();		
	}
}	

小结：将简单工厂的模式种的一个工厂，拆成了抽象工厂和工厂的具体实现，对应每一个产品对象实例，都有一个工厂实例与其对应。（这里看上出好像用工厂模式更加麻烦了，本来可以直接用new来创建对象的，现在却多了一些代码，其实不是这样的。当对象的创建比较复杂的时候，比如一个对象的创建要以来其他的一些对象，那么每次当我们创建一个对象的时候都得写大量重复的代码来创建对象，并且如果以后需要对代码进行修改，那么就要在每个使用的地方都要进行修改，用工厂设计模式一方面减少了代码的重写工作，另一方面也实现类解耦，当代码需要修改时，只需要修改工厂种的代码就行）。如果要添加新的产品类时，只需要创建一个新的工厂即可，符合开闭原则。

抽象工厂模式

抽象工厂模式是每个工厂生产一类产品，而抽象方法模式是每个工厂只生产一种产品。没怎么见过，就先这样吧，哈哈哈哈哈（ -_- 。
总结：
如果一个对象的创建过程要依赖于别的对象，那么在创建这个对象之前还要去创建别的对象。如果代码中很多地方有着重复的创建，那么不妨考虑将这些重复的代码，写在一起进行重用。工厂模式基本上也是做了这个一个事。通过工厂来获取对象，减小了大量的重复代码的使用，同时日后如果需要进行修改，只需要修改工厂中的代码即可，即工厂模式实现了对象的解耦。