简单工厂方法与工厂方法

简单工厂

简单工厂模式的工厂类一般是使用静态方法，通过接受的参数的不同来返回不同的实例（一般情况下不修改代码的话，是无法扩展的）

图不是我画的，

Java实现代码

//IDataSource.java
public interface IDataSource {
	void LinkDataBase();
}

//MicroftSQL.java
public class MicrofSQL implements IDataSource {
	
	
	public MicrofSQL() {
		System.out.println("mssql Constructor");
	}

	@Override
	public void LinkDataBase() {
		System.out.println("lingking ms sql");
	}

}

//MysqlDB.java
public class MysqlDB implements IDataSource {

	
	
	public MysqlDB() {
		System.out.println("mysql Constructor");
	}

	@Override
	public void LinkDataBase() {
		System.out.println("linking mysql database!");
	}

}

//SqlFactory.java
public class SqlFactory {
	public static IDataSource LinkDB(String sqlname){//普通方法
		if ("MySQL".equalsIgnoreCase(sqlname))
			return new MysqlDB();
		if ("SQLSERVER".equalsIgnoreCase(sqlname))
			return new MicrofSQL();
		return null;
	}
	/**
	 * 
	 * @param 类名没有定义路径
	 * @return 实例对象
	 * @throws Exception
	 */
	public static IDataSource LinkDBByRefect(String classname) throws Exception{
		
//		return (IDataSource) Class.forName("org.test.simpleFactory."+classname).getConstructors().newInstance();
		return (IDataSource) Class.forName("org.test.simpleFactory."+classname).newInstance();
	}
}

//Test.java
public class Test {
	public static void main(String[] args) throws Exception {
		//普通方式
		IDataSource data = SqlFactory.LinkDB("MySQL");
		IDataSource data2 = SqlFactory.LinkDB("SQLServer");
		data.LinkDataBase();
		data2.LinkDataBase();
                //使用反射方法后，马上和工厂方法一个意思，从代码数量上，比工厂方法更加简便
		IDataSource data3 = SqlFactory.LinkDBByRefect("MicrofSQL");
		IDataSource data4 = SqlFactory.LinkDBByRefect("MysqlDB");
		data3.LinkDataBase();
		data4.LinkDataBase();
		
	}
}

工厂方法

    针对每一种产品提供一个工厂类，通过不同的工厂实例来创建不同的产品实例类图不是我画的

以下代码参照Head First的类图

//ILight.java
public interface ILight {//Product
	void TurnOn();
	void TurnOff();
}

//RegLight.java
public class RedLight implements ILight {//ProductA

	@Override
	public void TurnOn() {
		System.out.println("red light on");
	}

	@Override
	public void TurnOff() {
		System.out.println("red light off");
	}

}

//GreanLight.java
public class GreanLight implements ILight {//ProductB

	@Override
	public void TurnOn() {
		System.out.println("grean light on");
	}

	@Override
	public void TurnOff() {
		System.out.println("grean light off");
	}

}

//ICreator.java
public interface ICreator {//IFactory
	ILight factory();
}

//RedCreator.java
public class RedCreator implements ICreator {//FactoryA

	@Override
	public ILight factory() {
		return new RedLight();
	}

}

//GreanCreator.java
public class GreanCreator implements ICreator {//FactoryB

	@Override
	public ILight factory() {
		
		return new GreanLight();
	}

}
//Demo.java
public class Demo {
	public static void main(String[] args) {
		ICreator redc = new RedCreator();
		ICreator greanc = new GreanCreator();
		ILight redl = redc.factory();
		ILight greanl = greanc.factory();
		redl.TurnOn();
		redl.TurnOff();
		greanl.TurnOff();
		greanl.TurnOn();
	}
}

简单工厂在增加产品的时候需要改下simpleFactory和实现product

工厂方法再增加产品的时候需要实现FactoryMethod和Product（ICreator，ILight）

而在简单工厂加入了反射机制，在增加产品的时候只需要实现product就好,但是，Class.forName本身就是工厂方法..

简单工厂只有一个抽象类，IDataSource（IProduct）

工厂方法有两个抽象类，ICreator，ILight（FactoryMethod，Product）

/**引入别人的总结*/

工厂模式中重要的是工厂类，一般来说工厂制造方法只会返回一个类型，这个就是产品的抽象类，

简单工厂-生产同一等级结构中的任意产品（对增加新产品无能为力，反射机制除外）

工厂方法-生产同一等级结构中的固定产品（支持增加任意产品）

抽象工厂：用来生产不同产品蔟的全部产品（对增加新产品无能为力，支持产品簇

抽象工厂

应对产品簇的概念，如每个汽车公司可能要同时生产轿车火车水车客车，

不是我画的

代码不贴出来了，直接点击下载

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。


抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个