Java 2.工厂模式学习

爱被打了一巴掌 2023-10-10 11:24 10阅读 0赞

#### 文章目录 ####

*   *   *  工厂模式
         *  简单工厂模式
         *   *  1.模式结构图
             *  2.模式的结构
             *  3.模式的实现
         *  工厂方法模式
         *   *  1.模式结构图
             *  2.模式的结构
             *  3.模式的实现

#### 工厂模式 ####

*  作用：  
    实现了创建者和调用者的分离（即调用只是调用，创建只是创建）
 *  详细分类：
    
    1.  简单工厂模式
    2.  工厂方法模式
    3.  抽象工厂模式
 *  核心本质：  
    实例化对象不使用new，用工厂方法代替；  
    将选择实现类，创建对象统一管理和控制。从而将调用者跟实现类解耦合。
 *  三种模式：
    
    1.  简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需求扩展已有的代码）
    2.  工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
    3.  抽象工厂模式：围绕一个超级工厂创建其他工厂。（该超级工厂又称为其他工厂的工厂）

#### 简单工厂模式 ####

##### 1.模式结构图 #####

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mdESuk0x-1596355201831)(F:/develop/Typora/img/CarFactory.jpg)\]][img-mdESuk0x-1596355201831_F_develop_Typora_img_CarFactory.jpg]

##### 2.模式的结构 #####

*  具体工厂（ConcreteFactory）：主要是完成具体产品的创建。
 *  抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
 *  具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来完成创建

##### 3.模式的实现 #####

*  抽象产品类：
    
        /**
         * 汽车抽象产品类 
         */
        public interface Car {
              
            void getCar();
        }
 *  具体产品类：
    
        /**
         * 汽车具体产品类：大众牌汽车 
         */
        public class DaZhong implements Car {
              
            @Override
            public void getCar() {
              
                System.out.println("大众");
            }
        }
        
        /* *************分割线************* */		
        
        /**
         * 汽车具体产品类：特斯拉牌汽车 
         */
        public class Tesla implements Car {
              
            public void getCar() {
              
                System.out.println("特斯拉");
            }
        }
        
        /* *************分割线************* */	
        
        /**
         * 汽车具体产品类：五菱宏光牌汽车 
         */
        public class WuLing implements Car {
              
            public void getCar() {
              
                System.out.println("五菱宏光");
            }
        }
 *  具体工厂类：
    
        /**
         * 简单工厂模式（静态工厂模式）： 
         *	 1.违背了开闭原则
         */
        public class CarFactory {
              
        
            /**
             * 方式一
             * 如果需要新增车辆品牌，就需要改动getCar方法才能实现新增
             *
             * @param carName
             * @return
             */
            public static Car getCar(String carName) {
              
                Car car = null;
                switch (carName) {
              
                    case "五菱宏光":
                        car = new WuLing();
                        break;
                    case "特斯拉":
                        car = new Tesla();
                        break;
                }
                return car;
            }
        
          // -------------------------------------------
        
            /**
             *  方式二不要改动原有方法，但是需要改动原有类
             */
            public static WuLing getWuLin() {
              
                return new WuLing();
            }
        
            public static Tesla getTesla() {
              
                return new Tesla();
            }
        
            /**
             * 工厂 新增大众品牌
             *
             * @return
             */
            public static DaZhong getDaZhong() {
              
                return new DaZhong();
            }
        
        }
 *  测试结果：
    
        /**
          	* 使用静态工厂方法：方式一
           	*/
           	@Test
           	public void testStaticFactor(){
              
               Car car1 = CarFactory.getCar("五菱宏光");
               Car car2 = CarFactory.getCar("特斯拉");
               Car car3 = CarFactory.getCar("大众");
        
               car1.getCar();
               car2.getCar();
               car3.getCar();
            }
        
            /**
                 * 使用静态工厂方法：方式二
                 */
            @Test
            public void testStaticFactor2(){
              
                Car wuLin = CarFactory.getWuLin();
                Car tesla = CarFactory.getTesla();
                Car daZhong = CarFactory.getDaZhong();
                wuLin.getCar();
                tesla.getCar();
                daZhong.getCar();
            }
         /*================= 输出结果================
         	五菱宏光
        	特斯拉
        	大众
           ================= 输出结果================*/

#### 工厂方法模式 ####

##### 1.模式结构图 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podXppY2M_size_16_color_FFFFFF_t_70][]

##### 2.模式的结构 #####

*  抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
 *  具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
 *  抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
 *  具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

##### 3.模式的实现 #####

*  抽象工厂：

/**
     * 抽象工厂
     */
    public interface CarFactory {
        
        Car getCar();
    }

*  具体工厂：

/**
     * 具体工厂：大众牌工厂类
     */
    public class DaZhongFactory implements CarFactory {
        
        @Override
        public Car getCar() {
        
            return new DaZhong();
        }
    }
    
      /* *************分割线************* */
    /**
     * 具体工厂：特斯拉牌工厂类
     */
    public class TeslaFactory implements CarFactory {
        
        @Override
        public Car getCar() {
        
            return new Tesla();
        }
    }
    
     /* *************分割线************* */
    /**
     * 具体工厂：五菱宏光牌工厂类
     */	
    public class WulingFactory implements CarFactory {
        
        @Override
        public Car getCar() {
        
            return new WuLing();
        }
    }

*  抽象产品：

/**
     *  汽车类
     */
    public interface Car {
        
        void getCar();
    }

*  具体产品：

/**
     *  大众汽车
     */
    public class DaZhong implements Car {
        
        @Override
        public void getCar() {
        
            System.out.println("大众");
        }
    }
    
      /* *************分割线************* */
    
    /**
     * 特斯拉汽车
     */
    public class Tesla implements Car {
        
        public void getCar() {
        
            System.out.println("特斯拉");
        }
    }
    
      /* *************分割线************* */
      
    /**
     * 五菱宏光汽车
     */
    public class WuLing implements Car {
        
        public void getCar() {
        
            System.out.println("五菱宏光");
        }
    }

*  测试结果：

public static void main(String[] args) {
        
         CarFactory daZhongFactory = new DaZhongFactory();
         CarFactory teslaFactory = new TeslaFactory();
         CarFactory wulingFactory = new WulingFactory();
     
         Car car = daZhongFactory.getCar();
         Car car1 = teslaFactory.getCar();
         Car car2 = wulingFactory.getCar();
     
         car.getCar();
         car1.getCar();
         car2.getCar();
     }
      /*================= 输出结果================
      	大众
       特斯拉
       五菱宏光
        ================= 输出结果================*/

> 小结

1.  简单工厂模式（静态工厂模式）:虽然某种程度上不符合设计原则，但实际使用最多！
2.  工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。
3.  抽象工厂模式：不可以增加产品，可以增加产品族！

> 应用场景

1.  JDK中的Calendar的getInstance方法
2.  JDBC中的Connection对象的获取
3.  Spring中IOC容器创建管理bean对象
4.  反射中Class对象的newInstance方法

> **简单工厂模式**和**工厂方法模式** 对比

1.  结构复杂度：简单工厂模式 < 工厂方法模式
2.  代码复杂度：简单工厂模式 < 工厂方法模式
3.  编程复杂度：简单工厂模式 < 工厂方法模式
4.  管理复杂度：简单工厂模式 < 工厂方法模式

**结论**：  
根据设计原则：应该使用工厂方法模式  
根据实际业务：应该使用简单工厂模式（实际中也是使用**简单工厂模式**偏多）

[img-mdESuk0x-1596355201831_F_develop_Typora_img_CarFactory.jpg]: https://img-blog.csdnimg.cn/20200802160234847.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podXppY2M=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podXppY2M_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200802160420421.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podXppY2M=,size_16,color_FFFFFF,t_70