JAVA架构师之路二：设计模式之工厂模式

我不是女神ヾ 2022-12-21 10:50 136阅读 0赞

[**JAVA架构师之路一：七大软件设计原则**][JAVA]

### 工厂模式 ###

*   *  1. 工厂模式的历史由来
     *  2. 简单工厂
     *  3. 工厂方法模式
     *  4. 抽象工厂模式

> **世界上本没有路，走的人多了，也便成了路。——鲁迅**

不用设计模式可以不可以？答案是可以。但是用好设计模式能帮助我们更好地解决实际问题，设计模式最重要的是解耦。学习设计模式，主要是总结经验的，把经验为自己所用，同时也是锻炼将业务需求转换技术实现的一种非常有效的方式。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center]

## 1. 工厂模式的历史由来 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 1]

## 2. 简单工厂 ##

定义

> 简单工厂模式是指一个工厂对象决定创建那种产品类的实例。  
> 属于创建型模式，但是不属于GOF 23种设计模式。

适用场景

> 工厂类负责创建的对象较少  
> 客户端只需传入工厂类的参数，对于如何创建工厂类的逻辑 不需要关心

优点

> 只需传入一个正确的参数就能获取你需要的对象，无须知道具体的细节

缺点

> 工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则。  
> 不易于扩展过于复杂的产品结构。

代码

public interface ICouse { 
    
        void record();
    }

public class JavaCouse implements ICouse { 
        @Override
        public void record() { 
            System.out.println("Java课程");
        }
    }

public class PythonCouse implements ICouse { 
        @Override
        public void record() { 
            System.out.println("Python课程");
        }
    }

public class CouseFactory { 
    
        /** * 版本1 * @param name * @return */
        public ICouse create1(String name) { 
            if ("java".equals(name)) { 
                return new JavaCouse();
            } else if ("python".equals(name)) { 
                return new PythonCouse();
            } else { 
                return null;
            }
        }
    
        /** * 版本2 * @param className * @return */
        public ICouse create2(String className) { 
            if (!(null == className || "".equals(className))) { 
                try { 
                    return (ICouse) Class.forName(className).newInstance();
                } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) { 
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        public ICouse create3(Class<? extends ICouse> clazz) { 
            if (null != clazz) { 
                try { 
                    return clazz.newInstance();
                } catch (InstantiationException | IllegalAccessException e) { 
                    e.printStackTrace();
                }
            }
            return null;
        }
    }

public class Test { 
    
        public static void main(String[] args) { 
            ICouse couse1 = new CouseFactory().create1("java");
            couse1.record();
            ICouse couse2 = new CouseFactory().create2("com.test.factory.JavaCouse");
            couse2.record();
            ICouse couse3 = new CouseFactory().create3(JavaCouse.class);
            couse3.record();
        }
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 2]  
JDK工厂模式简单应用  
Calendar.java 的 getInstance()方法的初始化用到的简单工厂模式。根据不同的Local时区，创建不同的Calendar对象。

if (aLocale.hasExtensions()) { 
       String caltype = aLocale.getUnicodeLocaleType("ca");
       if (caltype != null) { 
           switch (caltype) { 
           case "buddhist":
           cal = new BuddhistCalendar(zone, aLocale);
               break;
           case "japanese":
               cal = new JapaneseImperialCalendar(zone, aLocale);
               break;
           case "gregory":
               cal = new GregorianCalendar(zone, aLocale);
               break;
           }
       }
    }

## 3. 工厂方法模式 ##

定义

> 定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。  
> 属于创建型设计模式。

适用场景

> 创建对象需要大量的重复代码。  
> 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。  
> 一个类通过其子类来指定创建哪个对象。

优点

> 用户只需要关心所需产品对应的工厂，无需关键创建细节。  
> 加入新产品符合开闭原则，提高系统的可扩展性。

缺点

> 类的个数容易过多，增加了代码结构的复杂度。  
> 增加了系统的抽象性和理解难度。

代码

public interface ICouseFactory { 
    
        ICouse create();
    }

public class JavaCouseFactory implements ICouseFactory { 
        @Override
        public ICouse create() { 
            return new JavaCouse();
        }
    }

public class PythonCouseFactory implements ICouseFactory { 
        @Override
        public ICouse create() { 
            return new PythonCouse();
        }
    }

public class Test1 { 
    
        public static void main(String[] args) { 
            ICouseFactory couseFactory1 = new JavaCouseFactory();
            ICouse couse1 = couseFactory1.create();
            couse1.record();
    
            ICouseFactory couseFactory2 = new PythonCouseFactory();
            ICouse couse2 = couseFactory2.create();
            couse2.record();
        }
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 3]

## 4. 抽象工厂模式 ##

定义

> 是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类。  
> 属于创建型设计模式。

适用场景

> 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节  
> 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量复用的代码。  
> 提供一个产品类库，所有的产品以同样的接口形式出现，从而使客户端不依赖于具体实现。

优点

> 具体产品在应用层代码隔离，无须关心创建细节  
> 将一个系列的产品族统一到一起创建

缺点

> 规定了所有可能被创建的产品集合，产品族中扩展新的产品  
> 困难，需要修改抽象工厂的接口  
> 增加了抽象工厂的抽象性和理解难度

代码

public abstract class CouseFactory { 
    
        public void init() { 
            System.out.println("初始化基础数据");
        }
    
        protected abstract INote createNote();
    
        protected abstract IVideo createVideo();
    }

public class JavaCouseFactory extends CouseFactory { 
        @Override
        protected INote createNote() { 
            super.init();
            return new JavaNote();
        }
    
        @Override
        protected IVideo createVideo() { 
            super.init();
            return new JavaVideo();
        }
    }

public class PythonCouseFactory extends CouseFactory { 
        @Override
        protected INote createNote() { 
            super.init();
            return new PythonNote();
        }
    
        @Override
        protected IVideo createVideo() { 
            super.init();
            return new PythonVideo();
        }
    }

public interface INote { 
    
        void edit();
    }

public interface IVideo { 
    
        void record();
    }

public class JavaNote implements INote { 
        @Override
        public void edit() { 
            System.out.println("java note");
        }
    }

public class JavaVideo implements IVideo { 
        @Override
        public void record() { 
            System.out.println("java video");
        }
    }

public class PythonNote implements INote { 
        @Override
        public void edit() { 
            System.out.println("python note");
        }
    }

public class PythonVideo implements IVideo { 
        @Override
        public void record() { 
            System.out.println("python video");
        }
    }

public class Test { 
        public static void main(String[] args) { 
            CouseFactory couseFactory1 = new JavaCouseFactory();
            couseFactory1.createNote().edit();
            couseFactory1.createVideo().record();
    
            CouseFactory couseFactory2 = new PythonCouseFactory();
            couseFactory2.createNote().edit();
            couseFactory2.createVideo().record();
        }
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 5]  
**感谢您阅读本文，如果您觉得文章写的对您有用的话，请您点击上面的“关注”，点个赞，这样您就可以持续收到《JAVA架构师之路》的最新文章了。文章内容属于自己的一点点心得，难免有不对的地方，欢迎在下方评论区探讨，你们的关注是我创作优质文章的动力。**

[**JAVA架构师之路三：设计模式之单例模式**][JAVA 1]

[JAVA]: https://blog.csdn.net/cuixhao110/article/details/109473148
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/16c27d7b1f6644b1ada49005c75cdea4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/27a88c2958634e5caf47c40d839f9fc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/094326a95baf4540b1db0a499ecd1f8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/69b49f76961e42699ae35b5b093b9f59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/abaf5205bc7b44b886f0d1e9f1d55d3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/8876e699f9de4c83b0dc904a3f875cbc.png
[JAVA 1]: https://blog.csdn.net/cuixhao110/article/details/109723891