• java面试题----工厂模式大整理(面试问的较多)


    在一次面试中了解到工厂模式在实际应用中的重要性,可以说工厂模式的应用随处可见,以下是百度百科对工厂模式的介绍

        工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性尽量少的修改量

        在看了几篇写工厂模式的文章后,看见一篇我认为比较容易理解的代码说明:

    一.简单(静态)工厂模式

    1,首先建立一个产品的抽象类

    需要生产什么产品(实例对象)就需要首先建立一个相应产品的抽象类

    public abstract class INoodles {
        /**
         * 描述每种面条啥样的
         */
        public abstract void desc();
    }

    2.再建立几种具体的产品类如:

    这里建立了三个产品类:兰州拉面,泡面,干扣面(没吃过)

    public class LzNoodles extends INoodles {
        @Override
        public void desc() {
            System.out.println("兰州拉面");
        }
    }
    public class PaoNoodles extends INoodles {
        @Override
        public void desc() {
            System.out.println("泡面");
        }
    }
    public class GankouNoodles extends INoodles {
        @Override
        public void desc() {
            System.out.println("干扣面");
        }
    }

    3.在建立完这些产品后就可以建立(造面的)工厂了:

        工厂里面包含了我们可以生产的产品(面)

    public class SimpleNoodlesFactory {
        public static final int TYPE_LZ = 1;//兰州拉面
        public static final int TYPE_PM = 2;//泡面
        public static final int TYPE_GK = 3;//干扣面
    
        public static INoodles createNoodles(int type) {
            switch (type) {
                case TYPE_LZ:
                    return new LzNoodles();
                case TYPE_PM:
                    return new PaoNoodles();
                case TYPE_GK:
                default:
                    return new GankouNoodles();
            }
        }
    }

    4.开始根据客人的要求生产产品

    如下代码是生产干扣面(真心不知道这名字是怎么来的)的过程。

    INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK);
     noodles.desc();

    该设计模式只可以生产工厂能生产的产品,如需要增加产品,需要在工厂类中增加相应的静态变量。

    特点

    1 它是一个具体的类,非接口 抽象类。有一个重要的create()方法,利用if或者 switch创建产品并返回。

    2 create()方法通常是静态的,所以也称之为静态工厂

    缺点

    1 扩展性差(我想增加一种面条,除了新增一个面条产品类,还需要修改工厂类方法)

    2 不同的产品需要不同额外参数的时候 不支持。

     二、另一种简单工厂(反射):

    利用反射Class.forName(clz.getName()).newInstance()实现的简单工厂:

    public class StaticNoodlesFactory {
        /**
         * 传入Class实例化面条产品类
         *
         * @param clz
         * @param <T>
         * @return
         */
        public static <T extends INoodles> T createNoodles(Class<T> clz) {
            T result = null;
            try {
                result = (T) Class.forName(clz.getName()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    }

    特点

    1 它也是一个具体的类,非接口 抽象类。但它的create()方法,是利用反射机制生成对象返回,好处是增加一种产品时,不需要修改create()的代码

    缺点

    这种写法粗看牛逼,细想之下,不谈reflection的效率还有以下问题:

    1 个人觉得不好,因为Class.forName(clz.getName()).newInstance()调用的是无参构造函数生成对象,它和new Object()是一样的性质,而工厂方法应该用于复杂对象的初始化 ,当需要调用有参的构造函数时便无能为力了,这样像为了工厂而工厂。

    2 不同的产品需要不同额外参数的时候 不支持

    三、 多方法工厂(常用)

    使用方法二 三实现的工厂,都有一个缺点:不同的产品需要不同额外参数的时候 不支持。

    而且如果使用时传递的type、Class出错,将不能得到正确的对象,容错率不高。

    而多方法的工厂模式为不同产品,提供不同的生产方法,使用时 需要哪种产品就调用该种产品的方法,使用方便、容错率高

    工厂如下:

    public class MulWayNoodlesFactory {
    
        /**
         * 模仿Executors 类
         * 生产泡面
         *
         * @return
         */
        public static INoodles createPm() {
            return new PaoNoodles();
        }
    
        /**
         * 模仿Executors 类
         * 生产兰州拉面
         *
         * @return
         */
        public static INoodles createLz() {
            return new LzNoodles();
        }
    
        /**
         * 模仿Executors 类
         * 生产干扣面
         *
         * @return
         */
        public static INoodles createGk() {
            return new GankouNoodles();
        }
    }
    这种我比较青睐,增加一个新面条,只要去增加一个static方法即可,也不修改原方法逻辑

    查看java源码:java.util.concurrent.Executors类便是一个生成Executor 的工厂 ,其采用的便是 多方法静态工厂模式

    例如ThreadPoolExecutor类构造方法有5个参数,其中三个参数写法固定,前两个参数可配置,如下写。

        public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

    又如JDK想增加创建ForkJoinPool类的方法了,只想配置parallelism参数,便在类里增加一个如下的方法:

        public static ExecutorService newWorkStealingPool(int parallelism) {
            return new ForkJoinPool
                (parallelism,
                 ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                 null, true);
        }

    这个例子可以感受到工厂方法的魅力了吧:方便创建 同种类型的 复杂参数 对象

    四 普通工厂

    普通工厂就是把简单工厂中具体的工厂类,划分成两层:抽象工厂层+具体的工厂子类层。(一般->特殊)

    面条工厂(抽象工厂类),作用就是生产面条:

    public abstract class NoodlesFactory {
        public abstract INoodles create();
    }

    兰州拉面工厂 (具体工厂子类):

    public class LzFactory extends NoodlesFactory {
        @Override
        public INoodles create() {
            return new LzNoodles();
        }
    }

    泡面工厂 (具体工厂子类):

    public class PaoFactory extends NoodlesFactory {
        @Override
        public INoodles create() {
            return new PaoNoodles();
        }
    }

    最爱的干扣面工厂 (具体工厂子类):

    public class GankouFactory extends NoodlesFactory {
        @Override
        public INoodles create() {
            return new GankouNoodles();
        }
    }

    使用时:

            /**
             * 普通工厂方法:
             */
            System.out.println("===========================普通工厂方法==============================" +
                    "
     这种要多写一个类,不过更面向对象");
            NoodlesFactory factory1 = new GankouFactory();
            INoodles gk3 = factory1.create();
            gk3.desc();

    普通工厂与简单工厂模式的区别:

    可以看出,普通工厂模式特点:不仅仅做出来的产品要抽象, 工厂也应该需要抽象

    工厂方法使一个产品类的实例化延迟到其具体工厂子类.

    工厂方法的好处就是更拥抱变化。当需求变化,只需要增删相应的类,不需要修改已有的类

    而简单工厂需要修改工厂类的create()方法,多方法静态工厂模式需要增加一个静态方法。

    六 抽象工厂:

    以上介绍的工厂都是单产品系的。抽象工厂是多产品系 (貌似也有产品家族的说法)。

    举个例子来说,每个店(工厂)不仅仅卖面条,还提供饮料卖。
    提供饮料卖,饮料是产品,先抽象一个产品类,饮料:

    public abstract class IDrinks {
        /**
         * 描述每种饮料多少钱
         */
        public abstract void prices();
    }

    然后实现两个具体产品类:
    可乐:

    public class ColaDrinks extends IDrinks {
        @Override
        public void prices() {
            System.out.println("可乐三块五");
        }
    }

    屌丝还是多喝水吧:

    public class WaterDrinks extends IDrinks {
        @Override
        public void prices() {
            System.out.println("和我一样的穷鬼都喝水,不要钱~!");
        }
    }

    抽象饭店,无外乎吃喝(抽象工厂类):

    public abstract class AbstractFoodFactory {
        /**
         * 生产面条
         *
         * @return
         */
        public abstract INoodles createNoodles();
    
        /**
         * 生产饮料
         */
        public abstract IDrinks createDrinks();
    }

    兰州大酒店(具体工厂类):

    public class LzlmFoodFactory extends AbstractFoodFactory {
        @Override
        public INoodles createNoodles() {
            return new LzNoodles();//卖兰州拉面
        }
    
        @Override
        public IDrinks createDrinks() {
            return new WaterDrinks();//卖水
        }
    }

    KFC(具体工厂类):

    public class KFCFoodFactory extends AbstractFoodFactory {
        @Override
        public INoodles createNoodles() {
            return new PaoNoodles();//KFC居然卖泡面
        }
    
        @Override
        public IDrinks createDrinks() {
            return new ColaDrinks();//卖可乐
        }
    }

    使用:

            /**
             * 抽象工厂方法:
             */
            System.out.println("==============================抽象方法==============================" )
                    
            AbstractFoodFactory abstractFoodFactory1 = new KFCFoodFactory();
            abstractFoodFactory1.createDrinks().prices();
            abstractFoodFactory1.createNoodles().desc();
    
            abstractFoodFactory1= new LzlmFoodFactory();
            abstractFoodFactory1.createDrinks().prices();
            abstractFoodFactory1.createNoodles().desc();

    输出:

    ==============================抽象方法==============================
    可乐三块五
    泡面
    和我一样的穷鬼都喝水,不要钱~!
    兰州拉面

    小结:

    将工厂也抽象了,在使用时,工厂和产品都是面向接口编程,OO(面向对象)的不得了。

    六 个人总结和使用场景

    一句话总结工厂模式:方便创建 同种产品类型的 复杂参数 对象

    工厂模式重点就是适用于 构建同产品类型(同一个接口 基类)的不同对象时,这些对象new很复杂,需要很多的参数,而这些参数中大部分都是固定的,so,懒惰的程序员便用工厂模式封装之。
    (如果构建某个对象很复杂,需要很多参数,但这些参数大部分都是“不固定”的,应该使用Builder模式)

    为了适应程序的扩展性,拥抱变化,便衍生出了 普通工厂、抽象工厂等模式。

    本文参考的文章的作者更偏向于使用多方法工厂,但我认为普通工厂和抽象工厂使用范围更广,而且更好理解。

    学习参考

    https://blog.csdn.net/zxt0601/article/details/52798423

  • 相关阅读:
    解决Error: Cannot find module 'node-sass'问题
    SourceTree免登录使用
    git commit之后,想撤销commit
    vue生命周期
    Azure DevOps Azure Repos Git How-to Guides Use SSH key authentication
    FlagsAttribute Class
    serilog Debugging and Diagnostics
    Configuration error of serilog
    Serilog settings appsetting 配置的加载
    Kibana Query Language
  • 原文地址:https://www.cnblogs.com/xuxinstyle/p/9128865.html
Copyright © 2020-2023  润新知