Java设计模式之工厂模式

最新推荐文章于 2023-10-11 14:50:16 发布
最新推荐文章于 2023-10-11 14:50:16 发布
阅读量379 收藏
点赞数 3
分类专栏： 设计模式 文章标签： java 设计模式 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23585245/article/details/80759793
版权

工厂模式

  设计模式可以分为三大类：

   创建型模式（五种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。

   结构型模式（七种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。

   行为型模式（十一种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    设计模式要求我们应该针对接口编程，而不是针对实现编程，所谓的针对实现编程指的就是我们代码中利用new实例的对象,当对象有变动时，我们也需要修改对应的类，违反开闭原则，也会使我们代码的耦合度变高，工厂模式的作用就是将实例化对象的过程交由专门的工厂类来实现，我们要做的只是调用，不需要关心对象的生成过程。

    

工厂模式包含三种模式：简单工厂模式（静态工厂模式），工厂方法模式和抽象工厂模式。其中简单工厂不属于二十三种设计模式之中。

 

下面用具体例子分别说明这三种模式。

简单工厂模式：
结构：
工厂类角色：在java中对应具体的实现类
抽象产品： 在java’中对应抽象类或者接口
具体产品： java中对应具体的实现类


示例场景：
一个人有两辆车，一辆宝马，一辆奔驰，每次开车的都需要指定对应的车才能开车，用简单工厂方式进行改造。
*人需要关注只是开车这个动作，具体开什么车不关心
按照简单工厂的结构设计，抽象出一个汽车类，然后宝马，奔驰各自具体实现这个接口，还要设计一个驾驶工厂，用来生产具体的产品对象。

UML示意图:

 

具体代码：

car类：

package com.ljw.CarFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public interface Car {
    public void drive();
}

 

奔驰：

 

package com.ljw.CarFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("开奔驰");
    }
}

宝马：

package com.ljw.CarFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class BMWCar implements Car {
    @Override
    public void drive() {
        System.out.println("开宝马");
    }
}

工厂对象：（用了反射实例，避免使用new来进行对象的实例化）

package com.ljw.CarFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class DriveFactory {

    public  static <T extends Car> T createDriver(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试类：

package com.ljw.CarFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class TestCarFactory {
    public static void main(String[] args) {
        DriveFactory factory = new DriveFactory();
        Car car = factory.createDriver(BenzCar.class);
        car.drive();
    }
}

 

运行结果：

 

 

上述代码中工厂类中的方法使用了static修饰符进行修饰，也就是我们所说的静态工厂模式。这边不使用static修饰符，代码也是完全没有问题的，那为什么要这样写呢？
使用静态工厂模式的好处有三个：（与构造器比较）
        1.具名
            区别与构造器只有参数不同的情况，静态工厂方法哟具体的名称，完全可以通过名称区分方法的作用；
        2.环保
            使用构造器每次都会有新的对象产生，静态工厂方法可以重复使用对象；
        3.多子 

            使用构造期只能返回一种类型的对象，而静态工厂方法可以根据需要返回原返回类型的任意子对象类型。

 

 

工厂方法模式：
结构：
抽象工厂对象：对应java中的抽象类或者接口类
具体工厂对象：对应java中的具体实现类，包含具体的业务逻辑
抽象产品对象：对应java中的抽象类或者接口类
具体产品对象：对应java中具体的实现类


适用条件：
1. 用户不需要了解创建的具体过程；
2. 有多个具体产品产生。



换一个例子来说明工厂方法的使用场景，生产手机，三星公司生产三星手机，华为公司生产华为手机。 
分析：如果还是简单工厂来实现的话，在工厂类中的逻辑处理会随着产品的增多变得越发庞大，使用工厂方法来设计可以解决这个问题。

 

UML示意图：

 

代码示例：

抽象工厂类：

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public interface PhoneFactory {
    public <T extends IPhone> T createPhone(Class<T> clazz);
}

不同产品的具体工厂实现类：

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class HuaweiPhoneFactory implements PhoneFactory {
    @Override
    public <T extends IPhone> T createPhone(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }
}

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class SumsangPhoneFactory implements PhoneFactory {
    @Override
    public <T extends IPhone> T createPhone(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;    }
}

抽象产品类：

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public interface IPhone {

    public void callin();

    public void callout();
}

不同产品的具体实现类：

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class HuweiPhone implements IPhone {
    @Override
    public void callin() {
        System.out.println("用华为手机打进");
    }

    @Override
    public void callout() {
        System.out.println("用华为手机打出");
    }
}

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class SumsangPhone implements IPhone {
    @Override
    public void callin() {
        System.out.println("用三星手机打进");
    }

    @Override
    public void callout() {
        System.out.println("用三星手机打出");
    }
}

测试类：

package com.ljw.CellPhoneFactory;

/**
 * Created by liujiawei on 2018/6/20.
 */
public class TestFactory {
    public static void main(String[] args) {
        PhoneFactory factory = new SumsangPhoneFactory();
        IPhone phone =  factory.createPhone(HuweiPhone.class);
        phone.callin();
        phone.callout();
    }
}

运行结果：

 

 

    首先可以看到上述代码是成功实现了我们的目的，手机的产生我们并不需要自己去操作，只需要通过对应的工厂就可生产出需要的手机。


    大家可以注意到，上面虽然有两个具体工厂类，但是里面的代码确是一模一样的，这里面用到了反射方面的知识，通过类的反射获取实例，正常的写法则是在对应的具体工厂类中 return new xx()，通过构造器这种方式来获取对象。其实也是违背了避免面向实现编程，所以这里直接换成了反射来实现，事实上很多框架都是这样结合起来使用的。


 

    可以看到工厂方法模式解决了简单工厂模式中上帝类的存在，如果又有了一个新的产品，比如中兴手机，我们只需要在创建一个中兴手机的具体产品类和一个生产中兴手机的具体工厂类即可，但是他也有自己的缺点。那就是没办法解决产品族和产品等级结构的问题。也就是说具体工厂类只能生产一类产品，没法生产多类产品。

 

 

*这里补充下产品族和产品等级结构的概念。（copy网上）
(1) 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
  (2) 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中，海尔电视机、海尔电冰箱构成了一个产品族。

       产品等级结构与产品族示意图如图所示：

                          产品族与产品等级结构示意图

 

        了解了上面两个概念，接下来在上面的场景中，增加一些条件，现在增加了路由器这个产品，原有的手机工厂中只能生产手机产品，路由器该通过什么方式生产呢？

    抽象工厂模式由此诞生。抽象工厂模式的用意就是为客户端提供接口，可以创建多个产品族的对象。
结合上面的条件，也就是说不再有手机工厂，而是对应的产品族工厂，这个工厂可以生产一系列产品，手机，路由器，以后新加入的也都在这里进行生产。


抽象工厂模式结构和工厂方法模式相同。

 

看下UML示意图：

代码示例：

抽象产品类：

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public interface IPhone {
    public void callin();

    public void callout();
}

 

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public interface IRouter {
    public void getRoute();
}

具体产品类：

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class SumsangPhone implements IPhone {
    @Override
    public void callin() {
        System.out.println("用三星手机打进");
    }

    @Override
    public void callout() {
        System.out.println("用三星手机打出");
    }
}

 

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class HuaweiPhone implements IPhone {
    @Override
    public void callin() {
        System.out.println("用华为手机打进");
    }

    @Override
    public void callout() {
        System.out.println("用华为手机打出");
    }
}
package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class SumsangRouter implements IRouter {
    @Override
    public void getRoute() {
        System.out.println("三星路由器发射信号");
    }
}

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class HuaweiRouter implements IRouter {
    @Override
    public void getRoute() {
        System.out.println("华为路由器发射信号");
    }
}

抽象工厂类：

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public interface EqpFactory {
    public <T extends IPhone> T createPhone(Class<T> clazz);

    public <T extends IRouter> T createRouter(Class<T> clazz);

}

具体工厂类：

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class HuaweiFactory implements EqpFactory {
    @Override
    public <T extends IPhone> T createPhone(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;    }

    @Override
    public <T extends IRouter> T createRouter(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;    }
}

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class SumsangFactory implements EqpFactory {
    @Override
    public <T extends IPhone> T createPhone(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public <T extends IRouter> T createRouter(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;    }
}

测试类：

package com.ljw.EqpFactory;

/**
 * Created by liujiawei on 2018/6/21.
 */
public class TestEqpFactory {

    public static void main(String[] args) {
        EqpFactory sumsangFactory = new SumsangFactory();
        IPhone phone = sumsangFactory.createPhone(SumsangPhone.class);
        IRouter router = sumsangFactory.createRouter(SumsangRouter.class);
        phone.callin();
        phone.callout();
        router.getRoute();
    }
}

运行结果：

可以看到，通过三星工厂，我们生产出了三星的一系列产品。

 

总结：抽象工厂和工厂方法的不同在于，工厂方法中工厂是生产一类产品，而抽象工厂是生产一系列产品（产品族），但是它的缺点在于如果要扩展产品族的话，从接口处进行改动，所有子类都需要重写。（结合反射可以进行优化，类似上面）

 

三种设计模式总结：
    1. 简单工厂模式，工厂方法模式和抽象工厂方法模式，实现难度递增，适用于不同复杂度的业务场景；
    2. 将对象的实例化过程交给了对应的工厂类，实体和业务解耦，符合开闭原则，方便扩展；
    3. 抽象工厂里面又使用了一个个工厂方法来具体实现工厂。
    4.工厂方法是依赖倒置原则的经典实现模式。也就是不论高层组件和低层组件都应该依赖于抽象，而不是具体实现类。

 

理解不到位之处，多请见谅。

 

loveNY啊
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之工厂模式（三种工厂模式）
m0_65260253的博客
11-17 1万+
JAVA设计模式之工厂模式（三种工厂模式）
Java工厂模式（随笔）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-01 3685
三大工厂都是哪些？简单工厂模式工厂模式抽象工厂模式特殊工厂都是哪些？容器工厂模式超级工厂模式准确的来说工厂模式一共只有三种；但在我们程序员这里不止三种，还有两种，我们把它叫 ‘容器工厂模式’ 和 ‘超级工厂模式为什么它们没有增加到三大模式呢？因为它们都是基于‘简单工厂模式’扩展开辟出来的，解决了简单工厂模式存在违反开闭原则等弊端。Java简单工厂模式是一种创建型设计模式，它提供了一个工厂类，用于根据传入的参数来决定创建哪种类的实例；
Java设计模式——工厂设计模式，详解
08-22 2869
工厂模式是一种创建对象的设计模式，它提供了一种方式来封装对象的创建逻辑，并根据不同的需求，返回相应的对象实例。工厂模式使得客户端代码与具体对象的创建过程解耦将代码中的关联性和依赖性降低，使得各个模块之间的耦合度减少），提高了代码灵活性和可维护性。总结：工厂模式是 通过封装对象创建的过程，提供了一种统一的接口来创建对象。它隐藏了对象的具体实现细节，提供了灵活性、可扩展性，并提高了代码的可读性和可维护性。工厂模式的主要目的是。
Java23种设计模式之第三弹-工厂模式
weixin_44735933的博客
11-26 1824
简单工厂也称为静态工厂。是一种创建型模式。在简单工厂中，可以根据传入参数的不同返回不同类的对象实例。简单工厂是一个专门的工厂类，用来创建不同其他类的实例对象。这些实例对象通常他们的父类是同一个抽象类或者接口。相当于加了一层。在一个工厂类中生产各种产品，对单一产品的修改又或者增加产品都可能会影响到之前创建其他产品的逻辑。所以我们要加一层将创建产品的过程移至子类生产，每个工厂子类对应一个产品的生产。产品的增加和删除不会影响到其他产品的产出单个产品逻辑修改只需要在对应的工厂类修改即可，不需要动其他的工厂。
Java设计模式 - 工厂模式
三丰的专栏
10-10 1255
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 工厂模式在《Java与模式》中分为三类： 1）简单工厂模式（Simple Factory）：不利于产生系列产品； 2）工厂方法模式（Factory Method）：又称为多形性工厂； 3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品
Java设计模式之工厂模式（Factory模式）介绍
09-03
主要介绍了Java设计模式之工厂模式（Factory模式）介绍,本文讲解了为何使用工厂模式、工厂方法、抽象工厂、Java工厂模式举例等内容,需要的朋友可以参考下
Java设计模式之工厂模式实现方法详解
08-28
主要介绍了Java设计模式之工厂模式实现方法,结合实例形式较为详细的分析了工厂模式的分类、原理、实现方法与相关注意事项,需要的朋友可以参考下
java设计模式之工厂模式实例详解
08-29
主要介绍了java设计模式之工厂模式,结合具有实例形式分析了java工厂模式的概念、原理、实现与使用方法,需要的朋友可以参考下
java设计模式之工厂模式.pptx
10-14
给同学上课时做的ppt
【Java开发】设计模式 02：工厂模式
尹煜的博客
03-11 1304
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式（上）：我为什么说没事不要随便用工厂模式创建对象？
zhujiangtaotaise的专栏
12-02 409
一般情况下，工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。不过，在 GoF 的《设计模式》一书中，它将简单工厂模式看作是工厂方法模式的一种特例，所以工厂模式只被分成了工厂方法和抽象工厂两类。实际上，前面一种分类方法更加常见，所以，在今天的讲解中，我们沿用第一种分类方法。 在这三种细分的工厂模式中，简单工厂、工厂方法原理比较简单，在实际的项目中也比较常用。而抽象工厂的原理稍微复杂点，在实际的项目中相对也不常用。所以，我们今天讲解的重点是前两种工厂模式。对于抽象工厂，你稍微了解一下即可。 除此之
2022-15-Java 设计模式-抽象工厂模式
zzhangwa的博客
05-11 3272
在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。 在介绍抽象工厂模式前，我们先厘清两个概念： 产品等级结构：产品等级结构指的是产品的继承结构，例如一个空调抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个空调抽象类和他的子类就构成了一个产品等级结构。 产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调、海尔冰
JAVA设计模式之工厂模式
bernardGao94的博客
07-03 291
设计模式 设计模式(Design Pattern)是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、...
【Java】设计模式（1）—工厂模式
weixin_42043946的博客
05-08 555
总体来说设计模式分为三大类：、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。这里我们先来聊聊工厂方法模式。
Java设计模式之---工厂模式介绍
呋喃的博客
03-31 1086
工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的最佳实践，将对象的创建过程封装到一个单独的类中，从而将对象的使用代码与具体对象的实现代码解耦。简单工厂模式工厂方法模式和抽象工厂模式。简单工厂模式：简单工厂模式是最基本的工厂模式，它定义了一个工厂类，根据客户端的需求创建不同的产品对象。工厂方法模式：工厂方法模式通过定义一个工厂接口和多个具体的工厂实现类，实现了客户端与具体产品类的解耦。
JAVA设计模式-工厂模式（Factory Pattern）
qq_45443475的博客
10-11 433
JAVA设计模式-工厂模式（Factory Pattern）
java工厂模式详解
qq_50278146的博客
11-14 2009
工厂模式，抽象工厂，工厂方法，简单工厂，工厂模式详解
《设计模式详解》创建型模式 - 工厂模式
萌宅鹿的技术小屋
01-05 1630
《设计模式详解》4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.3 优缺点4.2.2.4 扩展 - 静态工厂4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4.2.4.4 使用场景4.2.5 扩展：简单工厂 + 配置文件4.2.6 JDK源码 - Collection.iterator
java设计模式抽象工厂
最新发布
10-18
抽象工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式。该模式围绕一个超级工厂创建其他工厂，这个超级工厂又称为其他工厂的工厂。抽象工厂模式的各个角色和工厂方法与工厂方法模式如出一辙，包括抽象工厂...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值