java 设计模式（工厂模式）

最近看了[设计模式那点事]设计模式-工厂模式这篇文章写得个人感觉非常好
【copy】工厂模式：http://www.blogjava.net/jzgl-ever/archive/2008/07/26/217704.html

简单工厂模式：
总的来说简单的工厂模式就是把所有的实例化对象放到工厂里面！有工厂来创建！你给工厂一个名字他就给你创建一个对象出来！

好处：
打个比方我们原来数据库用的是mysql，你写了一个mysql链接的关闭的类来做这些事情！
类名称：MysqlConnect.java
你在业务中使用mysql数据库的时候就要这么写 MysqlConnect mysql=new MysqlConnect（）
接着做处理！

有一天你老大说了我们mysql数据库满足不了我们的业务了需要改成oracle数据库！mysql数据库还保留着
那么我们会创建一个OracleConnect.java
在业务调用数据库的地方我们会把所有Mysql数据库的地方全部改成Oracle！
这么一来我们会改动很多的地方！对我们的业务处理做改动一不小心改了别的业务麻烦就打了客户就会说改个数据库业务不能正常运行了？
简单工厂模式会解决这个问题

public interface DbConnect {

	public abstract void connect();
	
	public abstract void close();
}

public class MysqlConnect implements DbConnect {

	public void connect() {
		System.out.println("... mysql connect..");

	}

	public void close() {
		System.out.println("... mysql close....");

	}

}

public class OracleConnect implements DbConnect {

	public void connect() {
		System.out.println("... oracle connect...");
	}

	public void close() {
		System.out.println("....oracle close.....");
	}

}

创建链接的工厂
public class Factory {

	public static DbConnect createConnect(String carName) {

		if (carName.equals("Mysql")) {
			return new OracleConnect();
		} else if (carName.equals("Oracle")) {
			return new MysqlConnect();
		}
		return null;
	}

}


测试类！ 相当于我们业务处理
public class TestMain {

	public static void main(String[] args) {

		DbConnect connect = Factory.createConnect("Mysql");
		connect.connect();
		connect.close();
		
	}

}

简单工厂模式的缺点就是，每次增加一个具体产品实现类，工厂类就一定要重新修改。工厂方法模式主要是针对简单工厂模式的该问题
工厂方法模式：

①抽象工厂
②具体工厂
③抽象方法
④具体方法
具体工厂里面的返回类型  ← 抽象方法

【copy】http://www.cnblogs.com/java-my-life/archive/2012/03/25/2416227.html

现在需求变了Mysql从1版本可能使用到N版本都没有满足需求接着修改使用Oracle数据库从1到N版本那么我们的工厂就十分庞大了，工厂承担的任务很多！
我们呢创建一个抽象工厂创建一个DB，DB的类型的叫具体工厂来实现，Mysql的实现工厂来创建Mysql的对象！Oracle的实现工厂来创建Oracle的对象！修改起来就方便很多了！

抽象工厂创建DB
public interface DbFactory {

	DbConnect createDb(String type);
}

具体的实现工厂
public class MysqlFactory implements DbFactory {

	@Override
	public DbConnect createDb(String type) {
		if (type.equals("Mysql1")) {
			return new Mysql1();
		} else {
			return new Mysql2();
		}

	}

}

public class OracleFactory implements DbFactory {

	@Override
	public DbConnect createDb(String type) {
		if (type.equals("Oracle1")) {
			return new Oracle1();
		} else {
			return new Oracle2();
		}
	}
}


数据库链接的抽象类
public interface DbConnect {

	public abstract void connect();

	public abstract void close();
}

数据库连接的实现类
public class Mysql1 implements DbConnect {

	@Override
	public void close() {
		System.out.println(".....mysql1 colse.........");
	}

	@Override
	public void connect() {
		System.out.println(".....mysql1 connect.........");

	}

}


public class Mysql2 implements DbConnect {


	@Override
	public void close() {
		System.out.println(".....mysql2 colse.........");
		
	}

	@Override
	public void connect() {
		System.out.println(".....mysql2 colse.........");
		
	}

}


public class Oracle1 implements DbConnect {

	@Override
	public void close() {
		System.out.println(".....oracle1 colse.........");

	}

	@Override
	public void connect() {
		System.out.println(".....oracle2 connect.........");

	}

}


public class Oracle2 implements DbConnect {


	@Override
	public void close() {
		System.out.println(".....oracle2 colse.........");
		
	}

	@Override
	public void connect() {
		System.out.println(".....oracle2 connect.........");
		
	}

}


public class TestMain {
	public static void main(String[] args) {

		DbFactory factory = new MysqlFactory();
		DbConnect connect = factory.createDb("Mysql1");
		connect.connect();
		connect.close();
	}
}

抽象工厂模式:
工厂方法模式的局限性在于具体实现工厂只能生产一类对象，MysqlFactory只能生产mysql不能同时生产Oracle。所以会产生抽象工厂模式

抽象工厂
public interface DbFactory {

	DbConnect createMysqlDb();

	DbConnect createOracleDb();
}

具体实现工厂
版本1的工厂可以同时生产mysql，oracle
public class Version1Factory implements DbFactory {

	@Override
	public DbConnect createMysqlDb() {
		return new Mysql1();
	}

	@Override
	public DbConnect createOracleDb() {
		return new Oracle2();
	}


}
版本2的工厂可以同时生产mysql，oracle
public class Version2Factory implements DbFactory {

	@Override
	public DbConnect createMysqlDb() {
		return new Mysql2();
	}

	@Override
	public DbConnect createOracleDb() {
		return new Oracle2();
	}

}

抽象产品
public interface DbConnect {

	public abstract void connect();

	public abstract void close();
}

具体实现产品
public class Mysql1 implements DbConnect {

	@Override
	public void close() {
		System.out.println(".....mysql1 colse.........");
	}

	@Override
	public void connect() {
		System.out.println(".....mysql1 connect.........");

	}

}
public class Mysql2 implements DbConnect {


	@Override
	public void close() {
		System.out.println(".....mysql2 colse.........");
		
	}

	@Override
	public void connect() {
		System.out.println(".....mysql2 colse.........");
		
	}

}
public class Oracle1 implements DbConnect {

	@Override
	public void close() {
		System.out.println(".....oracle1 colse.........");

	}

	@Override
	public void connect() {
		System.out.println(".....oracle2 connect.........");

	}

}
public class Oracle2 implements DbConnect {


	@Override
	public void close() {
		System.out.println(".....oracle2 colse.........");
		
	}

	@Override
	public void connect() {
		System.out.println(".....oracle2 connect.........");
		
	}

}

测试类：
public class TestMain {

	public static void main(String[] args) {

		DbFactory factory = new Version1Factory();

		DbConnect connectMysql = factory.createMysqlDb();
		DbConnect connectOracle = factory.createOracleDb();

		connectMysql.connect();
		connectMysql.close();

		connectOracle.connect();
		connectOracle.close();
	}
}

现在要增加一个version3的mysql和oracle。工厂方法模式呢就要增加两个具体实现工厂mysql，oracle，
抽象工厂模式呢就需要增加一个具体实现工厂


工厂模式的优点：
1.简单工厂模式：
  打个比方：数据库的移植问题，mysql向oracle移植，使用简单工厂模式避免了修改业务逻辑只要修改工厂类就可以了！
------------
当产品类具有复杂的多层次等级结构时，工厂类只有它自己。以不变应万变，是其缺点。
这个工厂类集中了所有产品创建逻辑，形成了一个无所不知的全能类（也称上帝类），如果此类出问题了，整个应用都受大影响。
当产品有多个接口时，判断在什么条件下创建什么产品类实例会很困难。
对于工厂来说，增加新的产品时一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户提供它们。换言之，接纳新的产品意味着修改这个工厂角色的源代码。简单工厂只在有限的程度上支持“开－闭”原则。
由于简单工厂模式使用静态方法作为工厂方法，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。这一缺点会在工厂方法模式中得到克服。


核心式工厂类，工厂类决定在什么情况下创建哪一种产品类的实例。而客户端则可以免除直接创建产品对象的责任，而仅仅是“消费”产品。简单工厂模式通过这种做法实现了对责任的分割。

2.工厂方法模式：
在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做。这个核心工厂则变为抽象工厂角色，仅负责给出具工厂子类必须实现的接口，而不接触哪一产品创建的细节。
    这种抽象的结果，使这种工厂方法模式可以用来允许系统不修改具体工厂角色的情况下引进新产品，这一特点无疑使得工厂模式具有超过简单工厂模式的优越性。