设计模式_工厂模式

最新推荐文章于 2024-06-04 15:02:40 发布

HRX98

最新推荐文章于 2024-06-04 15:02:40 发布

阅读量103

点赞数

分类专栏： 23种设计模式文章标签： java

本文链接：https://blog.csdn.net/HRX98/article/details/124432114

版权

23种设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

设计模式_工厂模式

1. 概述

1.1 定义

工厂模式属于创建型模式，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

1.2 分类

简单工厂模式
工厂方法模式
抽象工厂模式

2. 简单工厂模式

简单工厂模式中创建实例的方法通常为静态（static）方法，又叫作静态工厂方法模式
简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

2.1 简单工厂模式的结构

简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

2.2 简单工厂模式的实现

1. 抽象类Car

public interface Car {
    void name();
}

2. 具体产品Bus

public class Bus implements Car{
    @Override
    public void name() {
        System.out.println("公交车");
    }
}

3. 具体产品Bike

public class Bike implements Car{
    @Override
    public void name() {
        System.out.println("自行车");
    }
}

4. 工厂类

//工厂类
public class CarFactory {
    //创建产品的方法
    public static Car getCar(String car){
        if ("公交车".equals(car)){
           return new Bus();
        }else if ("自行车".equals(car)){
           return new Bike();
        }else {
            return null;
        }
    }

5. 测试类

public class Test{
    public static void main(String[] args) {

        //直接调用工厂类创建产品的方法，不需要知道具体的细节，只需要知道产品名就行
        Car car = CarFactory.getCar("公交车");
        Car car1 = CarFactory.getCar("自行车");

        car.name();// 公交车
        car1.name();// 自行车
    }
}

在这里插入图片描述

2.3 简单工厂优缺点

1. 优点

工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类

2. 缺点

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

2.4 应用场景

对于产品种类较少的情况，考虑使用简单工厂模式。
使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

3. 工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

3.1 工厂方法模式的结构

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

3.2 工厂方法模式的实现

1. 抽象类Car

public interface Car {
    void name();
}

2. 具体产品Bus

public class Bus implements Car{
    @Override
    public void name() {
        System.out.println("公交车");
    }
}

3. 具体产品Bike

public class Bike implements Car{
    @Override
    public void name() {
        System.out.println("自行车");
    }
}

4. 抽象工厂类

///抽象工厂
public interface CarFactory {
    Car getCar();
}

5. 具体工厂

BusFactory

//具体工厂
public class BusFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Bus();
    }
}

BikeFactory

//具体工厂
public class BikeFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Bike();
    }
}

6. 测试类

public class Test{
    public static void main(String[] args) {
        //调用具体工厂，由具体工厂实现
        Car car = new BusFactory().getCar();
        Car car1 = new BikeFactory().getCar();

        car.name();// 公交车
        car1.name();// 自行车
    }
}

3.3 工厂方法模式的优缺点

1. 优点

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

2. 缺点

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度
抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

3.4 应用场景

客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
客户不关心创建产品的细节，只关心产品的品牌

4. 抽象工厂模式

抽象工厂模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

4.1 抽象工厂模式结构

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

4.2 实现

1. 抽象产品

//手机产品接口
public interface IPhoneProduct {
    void start();

    void shutdown();

    void callup();

    void sendSMS();
}

//路由器产品接口
public interface IRouterProduct {
    void start();

    void shutdown();

    void openWifi();

    void setting();
}

2. 抽象工厂

//抽象工厂
public interface IProductFactory {

    //手机是一个产品等级，路由器又是一个产品等级
    //生产手机
    IPhoneProduct iPhoneProduct();

    //生产路由器
    IRouterProduct iRouteProduct();
}

3. 具体工厂

//小米工厂，这是一个产品族
public class RedmiProduct implements IProductFactory{
    //下面是两个不同的产品等级
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new RedmiPhone();
    }

    @Override
    public IRouterProduct iRouteProduct() {
        return new RedmiRouter();
    }
}

//华为工厂，这又是一个产品族
public class HuaweiProduct implements IProductFactory{
    //下面是两个不同的产品等级
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct iRouteProduct() {
        return new HuaweiRouter();
    }
}

4. 具体产品

package com.cheng.factory.abstractFactory;

public class RedmiPhone implements IPhoneProduct{
    @Override
    public void start() {
        System.out.println("小米开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米关机");
    }

    @Override
    public void callup() {
        System.out.println("小米打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("小米发短信");
    }
}

package com.cheng.factory.abstractFactory;

public class RedmiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("小米路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米路由器关机");
    }

    @Override
    public void openWifi() {
        System.out.println("小米路由器开wifi");
    }

    @Override
    public void setting() {
        System.out.println("小米路由器设置");
    }
}

package com.cheng.factory.abstractFactory;

public class HuaweiPhone implements IPhoneProduct{
    @Override
    public void start() {
        System.out.println("华为开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为关机");
    }

    @Override
    public void callup() {
        System.out.println("华为打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("华为发短信");

    }
}

package com.cheng.factory.abstractFactory;

public class HuaweiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("华为路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器关机");
    }

    @Override
    public void openWifi() {
        System.out.println("华为路由器开wifi");
    }

    @Override
    public void setting() {
        System.out.println("华为路由器设置");
    }
}

5. 测试类

public class Consumer {
    public static void main(String[] args) {
        System.out.println("===========小米产品系列===========");
        RedmiProduct redmiProduct = new RedmiProduct();
        //生产小米手机
        IPhoneProduct iPhoneProduct = redmiProduct.iPhoneProduct();
        //生产小米路由器
        IRouterProduct iRouterProduct = redmiProduct.iRouteProduct();

        iPhoneProduct.start();//小米开机
        iRouterProduct.start();//小米路由器开机


        System.out.println("===========华为产品系列===========");
        HuaweiProduct huaweiProduct = new HuaweiProduct();
        //生产华为手机
        IPhoneProduct iPhoneProduct1 = huaweiProduct.iPhoneProduct();
        //生产华为路由器
        IRouterProduct iRouterProduct1 = huaweiProduct.iRouteProduct();

        iPhoneProduct1.start();//华为开机
        iRouterProduct1.start();//华为路由器开机

    }
}