• 设计模式02----工厂设计模式(3种)


    工厂设计模式分为3种:简单工厂、工厂方法、抽象工厂。

    一. 什么是工厂设计模式

    工厂设计模式,顾名思义,就是用来生产对象的,在java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则,如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦
     

    二.简单工厂

    定义一个工厂方法,依据传入的参数,生成对应的产品对象;
    角色

    • 1、抽象产品
    • 2、具体产品
    • 3、具体工厂
    • 4、产品使用者

    使用说明:先将产品类抽象出来,比如,苹果和梨都属于水果,抽象出来一个水果类Fruit,苹果和梨就是具体的产品类,然后创建一个水果工厂,分别用来创建苹果和梨;代码如下:

    水果接口

    public interface Fruit {
        void whatIm();
    }
    

    具体类 苹果

    public class Apple implements Fruit {
        @Override
        public void whatIm() {
            //苹果
        }
    }
    

    具体类 梨

    public class Pear implements Fruit {
        @Override
        public void whatIm() {
            //梨
        }
    }
    

    具体工厂 水果工厂

    public class FruitFactory {
    
        public Fruit createFruit(String type) {
    
            if (type.equals("apple")) {//生产苹果
                return new Apple();
            } else if (type.equals("pear")) {//生产梨
                return new Pear();
            }
    
            return null;
        }
    }
    

    产品使用

     FruitFactory mFactory = new FruitFactory();
     Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果
     Pear pear = (Pear) mFactory.createFruit("pear");//获得梨

    还可以进行改造,采用反射:
     public Fruit createFruit(Class<? extends Fruit>fruit){
    
                try {
                    if(fruit!=null){
                        return fruit.newInstance();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
             return null;
        }

    就这样,一个非常简单的工厂设计模式就完成了,但是有没有发现什么问题呢?
    对,那就是如果我想吃香蕉,想吃橘子呢,我万一什么都想吃呢??所以,以上的这种方式,每当我想添加一种水果,就必然要修改工厂类,这显然违反了开闭原则,亦不可取;所以简单工厂只适合于产品对象较少,且产品固定的需求,对于产品变化无常的需求来说显然不合适;所以我们来看下一种方式;

    note:开闭原则:开闭原则(OCP)是面向对象设计中“可复用设计”的基石,是面向对象设计中最重要的原则之一,其它很多的设计原则都是实现开闭原则的一种手段。对于扩展是开放的,对于修改是关闭的,这意味着模块的行为是可以扩展的。当应用的需求改变时,我们可以对模块进行扩展,使其具有满足那些改变的新行为。也就是说,我们可以改变模块的功能。对模块行为进行扩展时,不必改动模块的源代码或者二进制代码。模块的二进制可执行版本,无论是可链接的库、DLL或者.EXE文件,都无需改动。

    三.工厂方法

    定义:将工厂提取成一个接口或抽象类,具体生产什么产品由子类决定;
    角色

    • 抽象产品类
    • 具体产品类
    • 抽象工厂类
    • 具体工厂类(区别简单工厂)

    使用说明:和上例中一样,产品类抽象出来,这次我们把工厂类也抽象出来,生产什么样的产品由子类来决定;
    代码如下:
    水果接口 苹果类和梨类 代码和上例一样

    工厂接口

    public interface FruitFactory {
        Fruit createFruit();//生产水果
    }
    

    苹果工厂

    public class AppleFactory implements FruitFactory {
        @Override
        public Fruit createFruit() {
            return new Apple();
        }
    }
    

    梨工厂

    public class PearFactory implements FruitFactory {
        @Override
        public Fruit createFruit() {
            return new Pear();
        }
    }
    

    使用

    AppleFactory appleFactory = new AppleFactory();
    PearFactory pearFactory = new PearFactory();
    Apple apple = (Apple) appleFactory.createFruit();//获得苹果
    Pear pear = (Pear) pearFactory.createFruit();//获得梨
    

    以上这种方式,虽然解耦了,也遵循了开闭原则,但是问题根本还是没有解决啊,换汤没换药,如果我需要的产品很多的话,需要创建非常多的工厂,所以这种方式的缺点也很明显;

    四.抽象工厂

    定义:为创建一组相关或者是相互依赖的对象提供的一个接口,而不需要指定它们的具体类。
    角色:和工厂方法一样
    抽象工厂和工厂方法的模式基本一样,区别在于,工厂方法是生产一个具体的产品,而抽象工厂可以用来生产一组相同,有相对关系的产品;重点在于一组,一批,一系列

    举个例子:

    假设目前你的程序里面有两个对象,苹果(apple)和香蕉(banana),那么你使用工厂模式就已经足够了,因为她们属于同一个品类,都属于水果,如果在添加一个菠萝产品,也只需要把菠萝加入到你的

    水果工厂里面就够了。

    但是如果你程序里面有四个对象,苹果汁,苹果派,香蕉汁,香蕉派,这四个对象正好有明确的层级关系,可以抽象为两个层级,苹果,香蕉,或者果汁,派。这时候你怎么来创建这些对象呢?这时候工厂模式明显已经不适用了,因为工厂模式是对象都实现了同一个接口,这时候就可以使用抽象工厂模式了。

    具体怎么做呢?

    就是把对象抽象一下,把这四个对象抽象为两个接口,一个果汁接口,一个派的接口。

    然后再设计一个抽象的工厂(抽象类)abstractFactory,里面生产抽象的对象(也就是接口)Juice,Pie,单看这个结构就是一个工厂模式,但是我们要用生产的是对象而不是接口。

    所以我们还需要两个具体工厂:

    一个AppleFactory继承abstractFactory,实现生成Pie的方法和生成Juice的方法,实际上就是生成对象AppleJuice和ApplePie,

    一个BananaFactory继承abstractFactory,实现生成Pie的方法和生成Juice的方法,实际上就是生成对象BananaJuice和BananaPie,

    这样的话,对于调用者来说,我在开发过程中,只需要知道我操作的对象是Pie或者是Juice就够了,这样降低了耦合。

    下面看下代码,首先是调用点。

    package abstractFactory;
    
    /**
     * Created by songjian on 3/30/2016.
     */
    public class Test {
        public  static void main(String args[]){
            AbstractFactory factory1 = new AppleFactory();
            factory1.createJuice().desc();
            factory1.createPie().desc();
            //假设我们之前需要的是applePie和appleJuice对象,现在需要换成bananaPie和BananaJuice对象
            //我们只需要替换对应的实现工厂(把new AppleFactory换成new BananFactory就可以了,耦合比较低)
            AbstractFactory factory2 = new BananaFactory();
            factory2.createJuice().desc();
            factory2.createPie().desc();
     
        }
    }

    下面是抽象工厂,生产对象的抽象。

    package abstractFactory;
    
    /**
     * Created by songjian on 3/29/2016.
     */
    public abstract class AbstractFactory {
        abstract Juice createJuice();
        abstract Pie createPie();
    }

    下面是具体工厂两个

    package abstractFactory;
    
    /**
     * Created by songjian on 3/29/2016.
     */
    public class AppleFactory extends AbstractFactory{
    
        @Override
        Juice createJuice() {
            return new AppleJuice();
        }
    
        @Override
        Pie createPie() {
            return new ApplePie();
        }
    }
    package abstractFactory;
    
    /**
     * Created by songjian on 3/29/2016.
     */
    public class BananaFactory extends  AbstractFactory{
        @Override
        Juice createJuice() {
            return new BananaJuice();
        }
    
        @Override
        Pie createPie() {
            return new BananaPie();
        }
    }

    下面是对象抽象出来的接口两个

    package abstractFactory;
    
    /**
     * Created by songjian on 3/29/2016.
     */
    public interface Juice {
        public void desc();
    }
    package abstractFactory;
    
    /**
     * Created by songjian on 3/29/2016.
     */
    public interface  Pie {
        public void desc();
    }
    package abstractFactory;
    
    /**
     * Created by ken on 1/29/2016.
     */
    public class AppleJuice implements Juice {
    
        @Override
        public void desc() {
            System.out.println("苹果汁.");
        }
    }
    package abstractFactory;
    
    /**
     * Created by ken on 1/29/2016.
     */
    public class ApplePie implements Pie {
        @Override
        public void desc() {
            System.out.println("苹果派");
        }
    }
    package abstractFactory;
    
    /**
     * Created by ken on 1/29/2016.
     */
    public class BananaJuice implements Juice {
        @Override
        public void desc() {
            System.out.println("香蕉汁.");
        }
    }
    package abstractFactory;
    
    /**
     * Created by ken on 1/29/2016.
     */
    public class BananaPie implements Pie {
        @Override
        public void desc() {
            System.out.println("香蕉派");
        }
    }

    五. 总结对比

    三种工厂方式总结:
    1、对于简单工厂和工厂方法来说,两者的使用方式实际上是一样的,如果对于产品的分类和名称是确定的,数量是相对固定的,推荐使用简单工厂模式;
    2、抽象工厂用来解决相对复杂的问题,适用于一系列、大批量的对象生产;
     
     
    参考文献:
    https://www.jianshu.com/p/38493eb4ffbd
    https://www.cnblogs.com/my-king/p/5338603.html
  • 相关阅读:
    不要对春运抱有幻想
    初识HTTP消息头(一)
    java中ArrayList 、LinkList区别以及速度对比
    jar包和war包的区别
    LUA 日期处理
    NGINXLUA——变量浅谈
    JDK和JRE的区别
    理解HTTP消息头 (五)——使用multipart/formdata上传文件
    安装Jetty
    TOMCATJARWAR事例讲解
  • 原文地址:https://www.cnblogs.com/Hermioner/p/9989902.html
Copyright © 2020-2023  润新知