Java设计模式之工厂模式

最新推荐文章于 2024-04-20 16:25:45 发布
最新推荐文章于 2024-04-20 16:25:45 发布
阅读量680 收藏 2
点赞数
分类专栏： Java程序语言 文章标签： 设计模式 工厂模式 简单工厂 工厂方法 抽象工厂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhliro/article/details/47116379
版权

Java设计模式之工厂模式

1. 引子

在介绍这篇内容之前，先以一个小故事开头。

话说有一个暴发户，他家有三辆轿车（奔驰、宝马、奥迪），还雇了司机为他开车。不过，暴发户每次坐车时总是这样：上奔驰车后跟司机说“开奔驰车！”，坐上宝马后他说“开宝马车！”，坐上奥迪后他说“开奥迪车！”。

也许你会说：这人有病吧！直接说开车不就行了？！非得多此一举是要表明自己是壕了吗？这是病，得治。

其实像这样的行为放到程序中来实现时，在面向过程的语言中暴发户一直是通过这种方式来坐车的。

幸运的是，这种病在面向对象的语言中有得治了。那如何来治病，下面我们开始今天的主题：工厂模式。

2. 工厂模式简介

工厂模式主要是为创建对象提供过渡接口，专门负责将大量有共同接口的类实例化，而且不必事先知道每次是要实例化哪一个类的模式，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

一般工厂模式可以分为三类：

  1. 简单工厂模式
  2. 工厂方法模式
  3. 抽象工厂模式

这三种模式从上到下逐步抽象，并且更具一般性。

2.1 简单工厂模式

简单工厂模式又称静态工厂方法模式，从命名上就可以看出这个模式很简单。它存在的目的很简单：定义一个用于创建对象的接口。

1

这个模式本身很简单而且使用在业务较简单的情况下，一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。

它主要由三种角色组成：

抽象产品角色：它一般是具体产品继承的父类或者实现的接口，由接口或者抽象类来实现。

具体产品角色：工厂类所创建的对象就是此角色的实例，在java中由一个具体类实现。

工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。

下面我们来给那个暴发户治病：在使用了简单工厂模式后，现在暴发户只需要坐在车里对司机说句：“开车”就可以了。来看看怎么用代码实现的：

package com.demo;

/**
 * 简单工厂测试类
 * 
 * @author 小明
 *
 */
public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 从工厂中创建具体产品对象
        // 比如老板说今天要坐奔驰，司机去仓库取车
        Car car = CarFactory.createCar("benz");
        car.setName("大奔");
        car.setPrice(798000);
        // 老板说开车，司机开着车出发
        car.drive();
    }
}

/**
 * 轿车类，抽象产品角色
 * 
 * @author 小明
 *
 */
abstract class Car {
    private String name; // 名字
    private double price; // 价格

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 启动
     */
    public abstract void drive();
}

/**
 * 奔驰车，具体产品角色
 * 
 * @author 小明
 *
 */
class Benz extends Car {

    @Override
    public void drive() {
        System.out.println("身份的象征：" + this.getName() + "启动......");
    }
}

/**
 * 宝马车，具体产品角色
 * 
 * @author 小明
 *
 */
class Bmw extends Car {

    @Override
    public void drive() {
        System.out.println("就是这么滴拽：" + this.getName() + "启动......");
    }
}

/**
 * 奥迪车，具体产品角色
 * 
 * @author 小明
 *
 */
class Audi extends Car {

    @Override
    public void drive() {
        System.out.println("不差钱：" + this.getName() + "启动......");
    }
}

/**
 * 工厂类角色，用于产生具体的产品对象
 * 
 * @author 小明
 *
 */
class CarFactory {
    /**
     * 公有静态方法，产生具体产品对象
     * 
     * @param carType
     *            车型字符串形式
     * @return 具体产品对象
     */
    public static Car createCar(String carType) {
        Car car = null; // 具体产品对象的引用
        /* 根据传递参数值创建不同的具体产品对象 */
        if ("benz".equals(carType))
            car = new Benz();
        else if ("bmw".equals(carType))
            car = new Bmw();
        else if ("audi".equals(carType))
            car = new Audi();

        return car; // 返回具体产品对象
    }
}

这便是简单工厂模式了，它符合现实中的情况，并且客户免除了直接创建产品对象的责任，而仅仅负责“消费”产品（正如暴发户所为）。

当暴发户增加了一辆车的时候，只要符合抽象产品角色的特点，就可以通知工厂类知道，然后让工厂类创建具体角色对象就可以被客户使用了。对于具体产品角色部分来说，它是符合开闭原则的；但是工厂类就不太理想，因为每增加一辆车，都要在工厂类中增加相应的业务逻辑，即需要修改工厂类的代码，这显然是违背开闭原则的。

正如前面提到的简单工厂模式适用于业务简单的情况下或者具体产品很少扩展的情况，而对于复杂的业务环境可能不太适应了，这时我们就可以考虑使用工厂方法模式了。

2.2 工厂方法模式

当暴发户生意越做越大，自己的车也越来越多，司机开始抱怨，因为对司机师傅来说，什么车他都要记得、维护，而且也都要经过他来使用！于是暴发户说：我给你分配几个助手，你只要管好他们就可以了！这时，工厂方法模式就出现了。

2

工厂方法涉及的角色：

  1. 抽象工厂角色： 这是工厂方法模式的核心，是具体工厂角色必须实现的接口或者必须继承的父类。
  2. 具体工厂角色：它含有和具体业务逻辑有关的代码，由应用程序调用以创建对应的具体产品的对象。
  3. 抽象产品角色：它是具体产品角色继承的父类或者是实现的接口。
  4. 具体产品角色：具体工厂角色所创建的对象是此角色的实例。

一个抽象产品角色派生出多个具体产品角色，一个抽象工厂角色派生出多个具体工厂角色。每个具体工厂角色只能创建一个具体产品角色的实例，即定义一个创建对象的接口（即抽象工厂接口），让其实现（具体工厂类）决定实例化哪一个类（具体产品类）的对象。

下面我们来帮司机师傅减轻工作压力：

package com.demo6;

/**
 * 工厂方法测试
 * 
 * @author 小明
 *
 */
public class FactoryMethodTest {
    public static void main(String[] args) {

        // 司机师傅找到管理宝马的助手
        CarFactory factory = new BmwFactory();
        // 司机让助手去取车
        Car car = factory.createCar();
        car.setName("宝马");
        car.setPrice(698000);
        // 老板说开车
        car.drive();
    }
}

/**
 * 轿车类，抽象产品角色
 * 
 * @author 小明
 *
 */
abstract class Car {
    private String name; // 名字
    private double price; // 价格

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 启动
     */
    public abstract void drive();
}

/**
 * 奔驰车，具体产品角色
 * 
 * @author 小明
 *
 */
class Benz extends Car {

    @Override
    public void drive() {
        System.out.println("身份的象征：" + this.getName() + "启动......");
    }
}

/**
 * 宝马车，具体产品角色
 * 
 * @author 小明
 *
 */
class Bmw extends Car {

    @Override
    public void drive() {
        System.out.println("就是这么滴拽：" + this.getName() + "启动......");
    }
}

/**
 * 奥迪车，具体产品角色
 * 
 * @author 小明
 *
 */
class Audi extends Car {

    @Override
    public void drive() {
        System.out.println("不差钱：" + this.getName() + "启动......");
    }
}

/**
 * 抽象工厂角色
 * 
 * @author 小明
 *
 */
interface CarFactory {
    /**
     * 创建具体产品角色对象的方法
     * 
     * @return 具体产品角色对象的引用，通过父类引用
     */
    Car createCar();
}

/**
 * 具体工厂角色，创建奔驰车的工厂
 * 
 * @author 小明
 *
 */
class BenzFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Benz();
    }
}

/**
 * 具体工厂角色，创建宝马车的工厂
 * 
 * @author 小明
 *
 */
class BmwFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Bmw();
    }
}

/**
 * 具体工厂角色，创建奥迪车的工厂
 * 
 * @author 小明
 *
 */
class AudiFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Audi();
    }
}

当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的规则来扩展，那么就可以被客户使用，而不必去修改任何已有的代码。即当有新产品时，只要创建一个具体产品类并继承抽象产品的类，创建一个具体工厂类继承抽象工厂的类，不用修改任何一个已有类。工厂方法模式是完全符合开闭原则的！

2.3 抽象工厂模式

抽象工厂模式是一种比较常用的模式，其定义是：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

3

抽象工厂模式的各个角色和工厂方法的如出一辙，抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

来认识一个概念，产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。比如对于轿车来说有跑车家族，那么不管是宝马的跑车，还是奔驰的跑车，我们都可以放到跑车这个产品家族中。

抽象工厂模式的用意为：给客户提供一个接口，可以创建多个产品族中的产品对象。

下面我们来看抽象工厂模式的通用源码格式：

package com.demo7;

/**
 * 抽象工厂模式测试
 * 
 * @author 小明
 *
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        // 老板要坐宝马跑车
        CarFactory factory = new SportsCarFactory();
        BmwCar car = factory.createBmwCar();
        car.setName("宝马");
        car.setPrice(698000);
        car.drive();
    }
}

/**
 * 奔驰轿车类，抽象产品角色
 * 
 * @author 小明
 *
 */
abstract class BenzCar {
    private String name; // 名字
    private double price; // 价格

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 启动
     */
    public abstract void drive();
}

/**
 * 奔驰跑车，具体产品角色
 * 
 * @author 小明
 *
 */
class BenzSportsCar extends BenzCar {

    @Override
    public void drive() {
        System.out.println("轰轰轰...：" + this.getName() + "跑车启动......");
    }
}

/**
 * 奔驰商务车，具体产品角色
 * 
 * @author 小明
 *
 */
class BenzBusinessCar extends BenzCar {

    @Override
    public void drive() {
        System.out.println("身份的象征：" + this.getName() + "商务车启动......");
    }
}

/**
 * 宝马轿车类，抽象产品角色
 * 
 * @author 小明
 *
 */
abstract class BmwCar {
    private String name; // 名字
    private double price; // 价格

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 启动
     */
    public abstract void drive();
}

/**
 * 宝马跑车，具体产品角色
 * 
 * @author 小明
 *
 */
class BmwSportsCar extends BmwCar {

    @Override
    public void drive() {
        System.out.println("轰...：" + this.getName() + "跑车启动......");
    }
}

/**
 * 宝马商务车，具体产品角色
 * 
 * @author 小明
 *
 */
class BmwBusinessCar extends BmwCar {

    @Override
    public void drive() {
        System.out.println("商务专用：" + this.getName() + "商务车启动......");
    }
}

/**
 * 抽象工厂角色
 * 
 * @author 小明
 *
 */
interface CarFactory {
    /**
     * 创建奔驰车对象，创建具体产品角色对象的方法
     * 
     * @return 具体产品角色对象的引用，通过父类引用
     */
    BenzCar createBenzCar();

    /**
     * 创建宝马车对象，创建具体产品角色对象的方法
     * 
     * @return 具体产品角色对象的引用，通过父类引用
     */
    BmwCar createBmwCar();
}

/**
 * 具体工厂角色，创建跑车的工厂
 * 
 * @author 小明
 *
 */
class SportsCarFactory implements CarFactory {

    @Override
    public BenzCar createBenzCar() {
        return new BenzSportsCar();
    }

    @Override
    public BmwCar createBmwCar() {
        return new BmwSportsCar();
    }

}

/**
 * 具体工厂角色，创建商务车的工厂
 * 
 * @author 小明
 *
 */
class BusinessCarFactory implements CarFactory {

    @Override
    public BenzCar createBenzCar() {
        return new BenzBusinessCar();
    }

    @Override
    public BmwCar createBmwCar() {
        return new BmwBusinessCar();
    }
}

抽象工厂模式具有很好的封装性，高层模块只关心接口、抽象类，它不关心对象是如何创建出来，因为对象的创建由工厂类负责，只要知道工厂类是谁，我就能创建出一个需要的对象，省时省力。

抽象工厂模式的最大缺点就是产品族扩展非常困难。如果要增加一个产品（奥迪），看看我们的程序有多大改动吧！抽象类CarFactory要增加一个方法createAudiCar()，然后，两个实现类都要修改，想想看，这在项目中的话，还怎么让人活！这严重违反了开闭原则，而且我们说抽象类和接口是一个契约，改变契约，所有与契约有关系的代码都要修改！

江湖人称小明
关注
专栏目录
Java创建型设计模式-工厂模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1082
工厂设计模式中的超类可以是接口抽象类或普通 Java 类。对于我们的工厂设计模式示例，我们有一个抽象超类，其中重写了 toString()方法以用于测试目的。@Override假设我们的计算机Computer有两个子类PC和Server。PC类的实现@Override@Override@OverrideServer类的实现@Override@Override@Override关于工厂设计模式方法的一些要点是；我们可以保留工厂类。
java设计模式之工厂模式
u010197591的专栏
03-08 1196
现在，不管是华为也好，小米也好，他们已不满足于只生产手机了，他们也开始造车了，现在有一个“组”的概念了，或者说族。一个工厂既代工生产华为手机也生产小米手机。抽象工厂，定义既能生产手机，也是生产汽车。一个生产手机的工厂接口类。具体生产华为手机的工厂。具体生产小米手机的工厂。
Java 设计模式之工厂模式详解
最新发布
m0_73581119的博客
04-20 1372
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而不需要暴露对象的创建逻辑。简单来说，工厂模式就是将对象的创建过程封装起来，客户端不需要关心对象是如何创建的，只需要通过工厂来获取所需的对象即可。工厂模式是一种常用的设计模式，它可以帮助我们更好地管理对象的创建过程，降低代码的耦合度，提高代码的复用性和扩展性。在实际项目中，根据不同的需求可以选择不同类型的工厂模式来创建对象，从而更好地满足项目的需求。
JAVA设计模式之工厂模式（三种工厂模式）
m0_65260253的博客
11-17 2万+
JAVA设计模式之工厂模式（三种工厂模式）
Java设计模式之工厂模式详解
IAMZTDSF的博客
04-24 5952
1.什么是工厂模式？ 工厂模式的主要解决的问题是，将原来分布在各个地方的对象创建过程单独抽离出来，交给工厂类负责创建。其他地方想要使用对象直接找工厂（即调用工厂的方法）获取对象。 2.作用： 实现类创建者和调用者的分离 3.核心本质： 实例化对象不使用new,用工厂方法代替 将选择实现类，创建对象统一管理和控制。从而将调用者和我们的实现类解耦 4.详细分类： 1.简单工厂模式/静态工厂模式 用来生产同一等级结构中的任意产品 2.工厂方法模式 用来生产同一等..
【Java 设计模式】创建型之抽象工厂模式
好久不见的流星
01-17 1342
抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式将一组相关的产品组合成一个工厂，客户端通过工厂接口创建一系列产品。这有助于实现产品族的概念，其中产品族是指一组相关的产品，例如不同品牌的汽车。抽象工厂模式是一种常见且实用的设计模式，它通过定义一个工厂接口，将一系列相关或相互依赖的对象的创建延迟到具体工厂的实现类中，从而实现了客户端和具体类的解耦。在实际开发中，抽象工厂模式常用于创建一系列相关的产品，如美食店中的可乐、汉堡包等。
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
【Java 设计模式】创建型之工厂方法模式
好久不见的流星
01-15 2092
工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是将对象的实例化延迟到子类中。这样，在实际使用时，客户端代码不需要关心具体实例是哪个类，只需通过工厂方法获取对象即可。工厂方法模式通过解耦了客户端和具体类的关系，使系统更加灵活。工厂方法模式是一种常见且实用的设计模式，它通过定义一个工厂方法接口，将对象的实例化延迟到子类中，从而实现了客户端和具体类的解耦。在实际开发中，工厂方法模式常用于创建复杂对象、管理对象的生命周期等场景。通过灵活使用工厂方法模式，可以使系统更容易扩展和维护。
Java设计模式之---工厂模式介绍
呋喃的博客
03-31 1196
工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的最佳实践，将对象的创建过程封装到一个单独的类中，从而将对象的使用代码与具体对象的实现代码解耦。简单工厂模式工厂方法模式和抽象工厂模式。简单工厂模式：简单工厂模式是最基本的工厂模式，它定义了一个工厂类，根据客户端的需求创建不同的产品对象。工厂方法模式：工厂方法模式通过定义一个工厂接口和多个具体的工厂实现类，实现了客户端与具体产品类的解耦。
Java设计模式之工厂模式（Factory模式）介绍
09-03
工厂模式之所以被广泛采用，原因在于它能够带来以下好处： 1. **封装变化**：当需要创建的对象发生变化时，如新增或修改类，只需要修改工厂类，而无需改动使用这些对象的客户端代码。 2. **提高灵活性**：通过工厂...
Java设计模式之工厂模式实现方法详解
08-28
Java设计模式之工厂模式实现方法详解 工厂模式是 Java 设计模式中的一种重要模式，它提供了一种创建对象的接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式主要有三种：简单工厂模式、...
java设计模式之工厂模式实例详解
08-29
Java设计模式之工厂模式实例详解 Java设计模式之工厂模式是软件设计中的一种经典模式，它主要用于解决对象创建问题。工厂模式的主要思想是将对象的创建和使用分离，使得对象的创建更加灵活和灵活。下面我们将通过...
Java Graphics2D类的绘图方法
小明的专栏
05-11 3万+
Java Graphics2D类的绘图方法Graphics2D继承自Graphics，它扩展了Graphics的绘图功能，拥有更强大的二维图形处理能力，提供对几何形状、坐标转换、颜色管理以及文字布局等更精确的控制。Graphics2D定义了几种方法，用于添加或改变图形的状态属性。可以通过设定和修改状态属性，指定画笔宽度和画笔的连接方式，设定平移、旋转、缩放或修剪变换图形，以及设定填充图形的颜色和图案
Java Graphics类的绘图方法
小明的专栏
05-07 2万+
Graphics类提供基本绘图方法，Graphics类提供基本的几何图形绘制方法，主要有：画线段、画矩形、画圆、画带颜色的图形、画椭圆、画圆弧、画多边形、画字符串等。画线段在窗口中画一条线段，可以使用Graphics类的drawLine()方法：/** * 在此图形上下文的坐标系中，使用当前颜色在点 (x1, y1) 和 (x2, y2) 之间画一条线 * * @param x1 *
Java Swing图形化用户界面编程
小明的专栏
04-27 1万+
GUI概述 早期计算机系统中，电脑向用户提供的是单调、枯燥、纯字符状态的“命令行界面（CLI）”。就是到现在，我们还可以依稀看到它们的身影：在Windows中开个DOS窗口，就可看到历史的足迹。 后来，Apple公司率先在电脑的操作系统中实现了图形化的用户界面（Graphical User Interface，简称GUI），但由于Apple公司封闭的市场策略，自己完成电脑硬件、操作系统、应用软
常用JDBC驱动与连接字符串整理
小明的专栏
05-03 1万+
常用JDBC驱动与连接字符串MySQLdriver：com.mysql.jdbc.Driverurl：jdbc:mysql://localhost:3306/mydbMySQL url格式：jdbc:mysql://[host:port]/[database][?参数名1][=参数值1][&参数名2][=参数值2]… 参数名称 参数说明 缺省值 最低版本要求 user 数据库用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值