抽象工厂模式：提供一个创建一系列相关对象的接口，而无需指定具体的类。工厂方法模式解决了简单工厂模式工厂类责任过重的问题，但是由于工厂方法模式只创建一类具体类的对象，会导致系统中工厂类过多，会增加系统开销。所以我们要考虑将一些相关的具体类组成一个“具体类族”，由一个工厂统一生产

    优点：
    便于交换产品系列，可以轻松改变产品配置

    实现：
    假设系统中用的是MySql数据库，众所周知，MySql的语法和Oracle语法有很多差别，如果语句是写死在系统中，甲方要求将MySql替换成Oracle，那么系统中所有的关联的地方都要改。如果我们使用工厂方法，则只用替换对应的抽象工厂类即可

    1、抽象数据库表（产品）

    1. /**
    2.  * 部门表
    3.  */
    4. public abstract class IDept {
    6.     /**
    7.      * 创建部门
    8.      */
    9.     public abstract void createDept();
    10. }
    12. /**
    13.  * 用户表
    14.  */
    15. public abstract class IUser {
    17.     /**
    18.      * 创建用户信息
    19.      */
    20.     public abstract void createUser();
    21. }

    2、MySql数据库表

    1. /**
    2.  * MySql部门
    3.  */
    4. public class MySqlDept extends IDept{
    6.     public void createDept(){
    7.         System.out.println("MySql创建部门");
    8.     }
    9. }
    11. /**
    12.  * MySql用户
    13.  */
    14. public class MySqlUser extends IUser{
    16.     /**
    17.      * 创建用户信息
    18.      */
    19.     public void createUser(){
    20.         System.out.println("MySql创建用户");
    21.     }
    22. }

    3、Oracle数据库表

    1. /**
    2.  * Oracle部门
    3.  */
    4. public class OracleDept extends IDept{
    6.     public void createDept(){
    7.         System.out.println("Oracle创建部门");
    8.     }
    9. }
    12. /**
    13.  * Oracle用户
    14.  */
    15. public class OracleUser extends IUser{
    17.     /**
    18.      * 创建用户信息
    19.      */
    20.     public void createUser(){
    21.         System.out.println("Oracle创建用户");
    22.     }
    23. }

    3、抽象工厂

    2. /**
    3.  * 抽象工厂
    4.  */
    5. public abstract class IFactory {
    7.     /**
    8.      * 创建用户信息
    9.      */
    10.     public abstract void createUser();
    12.     /**
    13.      * 创建部门
    14.      */
    15.     public abstract void createDept();
    16. }
    18. /**
    19.  * MySql工厂
    20.  */
    21. public class MySqlFactory extends IFactory{
    23.     /**
    24.      * 创建MySql用户
    25.      */
    26.     public void createUser(){
    27.         new MySqlUser().createUser();
    28.     }
    30.     /**
    31.      * 创建MySql部门
    32.      */
    33.     public void createDept(){
    34.         new MySqlDept().createDept();
    35.     }
    36. }
    38. /**
    39.  * Oracle工厂
    40.  */
    41. public class OracleFactory extends IFactory{
    43.     /**
    44.      * 创建Oracle用户
    45.      */
    46.     public void createUser(){
    47.         new OracleUser().createUser();
    48.     }
    50.     /**
    51.      * 创建Oracle部门
    52.      */
    53.     public void createDept(){
    54.         new OracleDept().createDept();
    55.     }
    56. }

    4、测试

    1. /**
    2.  * 测试抽象工厂模式
    3.  */
    4. public class TestAbstracFactory {
    6.     public static void main(String [] args){
    7.         IFactory factory = new OracleFactory();
    8.         factory.createUser();
    9.         factory.createDept();
    10.     }
    11. }

    测试结果：
    image.png

    对比抽象工厂模式和工厂方法模式的区别在于，工厂方法模式只创建一个具体类对象，而抽象工厂模式，是用于创建一组相关的类的对象。