设计模式之工厂模式和抽象工厂模式

工厂模式（实现创建者和调用者的分离，实现解耦）
　　本质：实例化对象，用工厂方法代替new()操作；

　　　　　将选择实现类、创建对象统一管理和控制；从而实现将调用者和实现类解耦；

　　分类：

　　　　　简单工厂：用来生产统一等级结构中的任何产品（对于增加新的产品，需要修改已有的代码）

　　　　　工厂方法：用来生产同一等级中的固定产品（对于增加新的产品，不需要修改已有的代码）

　　　　　抽象工厂模式：用来生产不同产品族的全部产品（对于增加新的产品无能为力，但是支持增加产品族）

 

　　记得之前参与过的一个产品，根据不同的公司的需求，我们需要通过修改配置文件，从而连接到不同的数据库，支持DB2，mysql，Orical，那个实现就是用简单工厂来实现。现在简单来模拟一下：

　简单工厂：

　　简单工厂的缺点在于：如果我需要添加支持DB2的数据库，需要修改原有的代码！

/**
* <p>
* Database 实体接口
* <p>*/
public interface Database {
void getDatabase();
}

/**
* <p>
* MysqlDB Mysql数据库连接实体
* <p>*/
public class MysqlDB implements Database{
@Override
public void getDatabase() {
System.out.println("连接到mysql数据库");
}
}

/**
* <p>
* OricalDB Orical数据库连接实体
* <p>
*/
public class OricalDB implements Database {
@Override
public void getDatabase() {
System.out.println("连接到orical数据库");
}
}

/**
* <p>
* DBFactory 数据库连接工厂类
* <p>*/
public class DBFactory {
/**
* 创建mysql连接实体
* @return
*/
public static Database connectionMysql(){
return new MysqlDB();
}
/**
* 创建orical连接实体
* @return
*/
public static Database connectionOrical(){
return new OricalDB();
}
}

/**
* <p>
* Client 测试类
* <p>
*/
public class Client {
public static void main(String[] args) {
Database orical = DBFactory.connectionOrical();
Database mysql = DBFactory.connectionMysql();
orical.getDatabase();
mysql.getDatabase();
}
}

　工厂方法　

　  工厂方法模式和简单工厂模式最大的区别在于，简单工厂只有一个工厂类，但是工厂方法模式有一组实现了相同接口的工厂类，从而保证添加新产品，只需要通过增加新类即可，不需要修改原有代码！现在我们用工厂方法模式实现上面的需求：

　　首先添加如上三个类：Database、MysqlDB、OricalDB。再添加如下类：

/**
* <p>
* DBFactory 工厂类接口
* <p>
*/
public interface DBFactory {
Database connectionDB();
}

/**
* <p>
* MysqlDBFactory mysql工厂类接口类现类
* <p>
*/
public class MysqlDBFactory implements DBFactory {
@Override
public Database connectionDB() {
return new MysqlDB();
}
}

/**
* <p>
* OricalDBFactory Orical工厂类接口类现类
* <p>
*/
public class OricalDBFactory implements DBFactory{
@Override
public Database connectionDB() {
return new OricalDB();
}
}

/**
* <p>
* Client 工厂方法 实现工厂模式测试类
* <p>*/
public class Client {
public static void main(String[] args) {
Database orical = new OricalDBFactory().connectionDB();
Database mysql = new MysqlDBFactory().connectionDB();

orical.getDatabase();
mysql.getDatabase();
}
}

　抽象工厂模式

　　抽象工厂模式是工厂方法的升级版本，在多个业务品种、业务分类（即不同产品族）时，通过抽象工厂模式生产需要的对象是一种非常好的解决办法。

　　所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。比如：汽车有高档、低档之分，具体来说是高档车配备了高端的引擎、高端轮胎...，而低档车配备了低端的引擎、低端的轮胎；那么轮胎、引擎就是两个产品族。

　　工厂类生产出高档车就应该配备高端引擎和轮胎；低档车就应该配备低端的引擎和轮胎。下面我们来试试这个例子：

　　

/**
* Engine 引擎接口*/
public interface Engine {
void run();
}
/**
* 高端引擎
*/
class HighEngine implements Engine{
@Override
public void run() {
System.out.println("高端发动机，跑的就是快...");
}
}
/**
* 低端引擎
*/
class LowEngine implements Engine{
@Override
public
aedf
void run() {
System.out.println("低端发动机，跑的好慢...");
}
}

/**
* 轮胎类接口
*/
public interface Tyre {
void skidproof();
}
/**
* 高端轮胎
*/
class HighTyre implements Tyre{
@Override
public void skidproof() {
System.out.println("高端轮胎就是防滑的...");
}
}
/**
* 低端轮胎
*/
class LowTyre implements Tyre{
@Override
public void skidproof() {
System.out.println("低端轮胎是不防滑的...");
}
}

/**
* 汽车工厂接口
*/
public interface CarFactory {
//创建引擎
Engine creatEnginer();
//创建轮胎
Tyre createTyre();
}
/**
* 高端汽车工厂
*/
class HighCarFactory implements CarFactory{
@Override
public Engine creatEnginer() {
return new HighEngine();
}
@Override
public Tyre createTyre() {
return new HighTyre();
}
}
/**
* 低端汽车工厂
*/
class LowCarFactory implements CarFactory{
@Override
public Engine creatEnginer() {
return new LowEngine();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}

/**
* 抽象工厂测试类
*/
public class Client {

public static void main(String[] args) {
CarFactory highCarFactory = new HighCarFactory();
Engine engine = highCarFactory.creatEnginer();
Tyre tyre = highCarFactory.createTyre();
engine.run();
tyre.skidproof();
}
}