Java设计模式【工厂模式】

Java设计模式【工厂模式】

前言

三种工厂模式:简单工厂模式、工厂方法模式、抽象工厂模式;

  • 创建型设计模式
  • 封装对象的创建过程,将对象的创建和使用分离开,从而提高代码的可维护性和可扩展性

简单工厂模式

概述:将对象的创建过程封装在一个工厂类中,客户端通过工厂类来创建对象。

特点:

  • 一个工厂类+多个产品类
  • 添加新的产品类时,就必须修改工厂类的代码,这违反了开闭原则
java 复制代码
package com.qiangesoft.design.creational.factory.simple;

/**
 * 简单工厂模式
 */
public class SimpleFactory {
    public static void main(String[] args) {
        // 奔驰车
        Car benz = CarFactory.buildCar("benz");
        benz.running();

        // 宝马车
        Car bmw = CarFactory.buildCar("bmw");
        bmw.running();

        // 奥迪车
        Car audi = CarFactory.buildCar("audi");
        audi.running();
    }
}

/**
 * 1.工厂类
 */
class CarFactory {
    public static Car buildCar(String type) {
        if ("benz".equals(type)) {
            return new Benz();
        } else if ("bmw".equals(type)) {
            return new BMW();
        } else if ("audi".equals(type)) {
            return new Audi();
        } else {
            throw new IllegalArgumentException("Illegal argument for type: " + type);
        }
    }
}

/**
 * 2.抽象产品接口
 */
interface Car {
    void running();
}

/**
 * 3.产品实现类
 * 奔驰、宝马、奥迪
 */
class Benz implements Car {
    @Override
    public void running() {
        System.out.println("奔驰车在路上跑!");
    }
}

class BMW implements Car {
    @Override
    public void running() {
        System.out.println("宝马车在路上跑!");
    }
}

class Audi implements Car {
    @Override
    public void running() {
        System.out.println("奥迪车在路上跑!");
    }
}

工厂方法模式

概述:定义一个工厂接口和多个具体工厂类来实现对象的创建。每个具体工厂类都实现了工厂接口,并负责创建一类产品对象。

特点:

  • 一个工厂接口+多个具体工厂类
  • 具体的产品类和工厂类都可以在运行时动态切换,符合开闭原则
java 复制代码
package com.qiangesoft.design.creational.factory.method;

/**
 * 工厂方法模式
 */
public class FactoryMethod {
    public static void main(String[] args) {
        // 奔驰车
        CarFactory benzFactory = new BenzFactory();
        Car benzCar = benzFactory.buildCar();
        benzCar.running();

        // 宝马车
        CarFactory bmwFactory = new BMWFactory();
        Car bmwCar = bmwFactory.buildCar();
        bmwCar.running();

        // 奥迪车
        CarFactory audiFactory = new AudiFactory();
        Car audiCar = audiFactory.buildCar();
        audiCar.running();
    }
}

/**
 * 1.抽象工厂接口
 */
interface CarFactory {
    Car buildCar();
}

/**
 * 2.工厂实现类
 * 奔驰工厂、宝马工厂、奥迪工厂
 */
class BenzFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new Benz();
    }
}

class BMWFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new BMW();
    }
}

class AudiFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new BMW();
    }
}

/**
 * 3.抽象产品接口
 */
interface Car {
    void running();
}

/**
 * 4.产品实现类
 * 奔驰、宝马、奥迪
 */
class Benz implements Car {
    @Override
    public void running() {
        System.out.println("奔驰车在路上跑!");
    }
}

class BMW implements Car {
    @Override
    public void running() {
        System.out.println("宝马车在路上跑!");
    }
}

class Audi implements Car {
    @Override
    public void running() {
        System.out.println("奥迪车在路上跑!");
    }
}

抽象工厂模式

概述:工厂方法模式的升级版,它定义了多个工厂接口和多个产品族接口,每个工厂接口负责创建一类产品族对象,每个产品族接口负责定义一类产品对象。具体工厂类实现工厂接口并负责创建一类产品族对象,具体产品类实现产品族接口并负责创建一类产品对象。

特点:

  • 多个工厂接口+多个产品族接口
  • 具体的产品族和工厂类都可以在运行时动态切换,符合开闭原则
java 复制代码
package com.qiangesoft.design.creational.factory.abstractf;

/**
 * 抽象工厂模式
 */
public class AbstractFactory {
    public static void main(String[] args) {
        // 奔驰车
        CarFactory benzFactory = new BenzFactory();
        Engine benzEngine = benzFactory.createEngine();
        Transmission benzTransmission = benzFactory.createTransmission();
        System.out.println("奔驰汽车:" + benzEngine.getName() + "+" + benzTransmission.getName());

        // 宝马车
        CarFactory bmwFactory = new BMWFactory();
        Engine bmwEngine = bmwFactory.createEngine();
        Transmission bmwTransmission = bmwFactory.createTransmission();
        System.out.println("宝马汽车:" + bmwEngine.getName() + "+" + bmwTransmission.getName());

        // 奥迪车
        CarFactory audiFactory = new AudiFactory();
        Engine audiEngine = audiFactory.createEngine();
        Transmission audiTransmission = audiFactory.createTransmission();
        System.out.println("奥迪汽车:" + audiEngine.getName() + "+" + audiTransmission.getName());
    }
}

/**
 * 1.抽象工厂接口
 */
interface CarFactory {
    Engine createEngine();

    Transmission createTransmission();
}

/**
 * 2.具体工厂类
 * 奔驰工厂、宝马工厂、奥迪工厂
 */
class BenzFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new BenzEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new BenzTransmission();
    }
}

class BMWFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new BMWEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new BmwTransmission();
    }
}

class AudiFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new AudiEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new AudiTransmission();
    }
}

/**
 * 3.产品接口1:发动机
 */
interface Engine {
    String getName();
}

/**
 * 4.产品实现类1:发动机
 */
class BenzEngine implements Engine {
    @Override
    public String getName() {
        return "奔驰发动机";
    }
}

class BMWEngine implements Engine {
    @Override
    public String getName() {
        return "宝马发动机";
    }
}

class AudiEngine implements Engine {
    @Override
    public String getName() {
        return "奥迪发动机";
    }
}

/**
 * 5.产品接口2:变速箱
 */
interface Transmission {
    String getName();
}

/**
 * 6.产品实现类2:变速箱
 */
class BenzTransmission implements Transmission {
    @Override
    public String getName() {
        return "奔驰变速箱";
    }
}

class BmwTransmission implements Transmission {
    @Override
    public String getName() {
        return "宝马变速箱";
    }
}

class AudiTransmission implements Transmission {
    @Override
    public String getName() {
        return "奥迪变速箱";
    }
}

总结

  • 简单工厂模式适用于创建单一类型的产品对象
  • 工厂方法模式适用于创建多种类型的产品对象
  • 抽象工厂模式适用于创建多个产品族的对象
相关推荐
YuTaoShao3 分钟前
【LeetCode 热题 100】240. 搜索二维矩阵 II——排除法
java·算法·leetcode
考虑考虑1 小时前
JDK9中的dropWhile
java·后端·java ee
想躺平的咸鱼干1 小时前
Volatile解决指令重排和单例模式
java·开发语言·单例模式·线程·并发编程
hqxstudying1 小时前
java依赖注入方法
java·spring·log4j·ioc·依赖
·云扬·2 小时前
【Java源码阅读系列37】深度解读Java BufferedReader 源码
java·开发语言
Bug退退退1233 小时前
RabbitMQ 高级特性之重试机制
java·分布式·spring·rabbitmq
小皮侠3 小时前
nginx的使用
java·运维·服务器·前端·git·nginx·github
Zz_waiting.3 小时前
Javaweb - 10.4 ServletConfig 和 ServletContext
java·开发语言·前端·servlet·servletconfig·servletcontext·域对象
全栈凯哥3 小时前
02.SpringBoot常用Utils工具类详解
java·spring boot·后端
兮动人3 小时前
获取终端外网IP地址
java·网络·网络协议·tcp/ip·获取终端外网ip地址