1. 首页
  2. 文章中心
  3. 23种设计模式

23设计模式之 --------- 工厂模式????1.工厂模式简介

93 阅读 0 评论
我是靠谱客的博主 微笑导师，这篇文章主要介绍23设计模式之 --------- 工厂模式????1.工厂模式简介，现在分享给大家，希望可以做个参考。

工厂模式

  • ????1.工厂模式简介
    • 1.1简单工厂模式：
    • 1.2工厂方法模式
    • 1.3 抽象工厂模式
    • 1.4 总结

????1.工厂模式简介

在这里插入图片描述
有三种工厂的模式：

1.1简单工厂模式：

在这里插入图片描述

在这里插入图片描述

常见常见消费者需要什么就去new 什么：
在这里插入图片描述

简单工厂模式实现了不需要直接new而是直接联系工厂即可

在这里插入图片描述
具体代码实现如下：

Car

复制代码
1
2
3
4
5
6
7
public interface Car {

void name();

}

Tesla

复制代码
1
2
3
4
5
6
7
8
public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

WuLing

复制代码
1
2
3
4
5
6
7
public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

工厂代码

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//此模式如果持续增加的话 会影响到开闭模式（简单工厂也可以称之为静态工厂模式）
public class CarFactory {

    public static Car getConfig(String car){
        //方法一
        if (car.equals("五菱")){
            return new WuLing();
        }if (car.equals("特")){
            return new Tesla();
        }else {
            return null;
        }



    }
    //方法二
public static Car getWuling(String WuLing){

        return new WuLing();
}

public static Car getTesla(String Tesla){

        return new Tesla();
    }


}

控制台 Consumer

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Consumer {


    public static void main(String[] args) {
        //1.普通方法
        Car  wuLing = new WuLing();
        Car tesla = new Tesla();


        wuLing.name();
        tesla.name();

     //   ------------------------
     //2.工厂模式
    Car le = CarFactory.getConfig("特");
    Car les = CarFactory.getConfig("五菱");

    le.name();
    les.name();

    }
}

简单模式直接去new对象了然后获取他们的值展示出啦的；
在这里插入图片描述
工厂模式而是直接去调用工厂的代码，进行实现
他的弊端是：影响了开闭原则不应该在新增的时候去修改工厂的代码；

在这里插入图片描述
在这里插入图片描述

1.2工厂方法模式

在这里插入图片描述
WuLing

复制代码
1
2
3
4
5
6
7
8
public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

WuLingFactory

复制代码
1
2
3
4
5
6
7
8
public class WuLingFactory implements CarFactory{
    @Override
    public Car getcar() {
        return new WuLing();
    }
}

Tesla

复制代码
1
2
3
4
5
6
7
8
public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

TeslaFactory

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class TeslaFactory implements CarFactory {

    @Override
    public Car getcar() {
        return new Tesla();
    }
}

```java
**BaoMa** 
```java
public class BaoMa implements Car {
    @Override
    public void name() {
        System.out.println("宝马骑骑车");
    }
}

BaoMaFactory

复制代码
1
2
3
4
5
6
7
8
public class BaoMaFactory implements CarFactory {

    @Override
    public Car getcar() {
        return new BaoMa();
    }
}

Car 每个车都会实现这个方法

复制代码
1
2
3
4
5
6
7
//工厂模式
public interface Car {
    
void name();

}

CarFactory 每个车的方法都会实现这个方法

复制代码
1
2
3
4
5
6
7
8
9
//方法工厂方法模式
public interface CarFactory {

    Car getcar();


}

Consumer 控制台调用方法实现

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Consumer {


    public static void main(String[] args) {
        //1.工厂方法
         Car car = new WuLingFactory().getcar();

         Car car2 = new TeslaFactory().getcar();

        Car car3 = new BaoMaFactory().getcar();

         car.name();
         car2.name();
         car3.name();
    }
}

运行结果如下：

在这里插入图片描述
（他完美的避免了开闭原则，但是他的实现类方法会不断增多也是一种不友好的用户的体验）

我们来看下实现图来更好的对他进行一个理解

在这里插入图片描述
两接口：一个代表车，一个代表车仓；每新增一种车就会新增一个车仓；

我们可以对比分析下：

简单工厂和方法工厂的对比

复制代码
1
2
3
4
5
6
7
8
结构复杂度：简单工厂模式
代码复杂度：简单工厂模式
编程复杂度：简单工厂模式
管理复杂度：简单工厂模式

根据设计原则：工厂方法模式比较好（不会扰乱程序）
根据实际业务：简单工厂模式

1.3 抽象工厂模式

在这里插入图片描述

在这里插入图片描述

Creator: 定义了产品生产的一系列行为；
ConcreteCreator1: 工厂1
ConcreteCreator2:工厂2
不同的工厂生产不同的东西；

ProductA: 抽象接口方法
ProductB:抽象接口方法

ProductA1:
ProductA2:
ProductB1:
ProductB2:

具体的抽象的方法（也就是具体的产品）他们是工厂创建的（ConcreteCreator）

在这里插入图片描述

产品等级和产品族如图上会帮助大家更好的理解；

小米手机和华为属于同一的产品等级结构；
小米手机和小米路由器属于同一家族；

在这里插入图片描述
相对固定的产品族可以考虑使用使用抽象工厂的模式经常变动的话就并不推荐了;

在这里插入图片描述
按照图形逻辑我们来实现下：

代码结构如下：
在这里插入图片描述
IphoneProduct

复制代码
1
2
3
4
5
6
7
8
9
10
//手机产品接口
public interface IphoneProduct {

     void start();//开机
     void shutdown();//关机
     void callup();//打电话
     void sendms();//发短信

}

XiaomiIphone

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class XiaomiIphone 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 sendms() {
        System.out.println("小米手机发短信");
    }
}

HuweiIphone

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class HuweiIphone 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 sendms() {
        System.out.println("华为手机发短信");
    }
}

IRouterProduct

复制代码
1
2
3
4
5
6
7
8
9
10
11
public interface IRouterProduct {

    void start();//开机
    void shutdown();//管家
    void callup();//开机
    void seeting();//设置


}

HuweiRouter

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class HuweiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("华为路由器开机");
    }

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

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

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

XiaomiRouter

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class XiaomiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("小米路由器开机");
    }

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

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

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

IProductFactory 抽象产品工厂

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
//抽象产品工厂
public interface IProductFactory {

    //手机工厂
    IphoneProduct IphoneProduct();

   //路由器工厂
    IRouterProduct IRouterProduct();

}

HuaweiFactory

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HuaweiFactory implements IProductFactory{

    @Override
    public IphoneProduct IphoneProduct() {
        return new HuweiIphone();
    }

    @Override
    public IRouterProduct IRouterProduct() {
        return new HuweiRouter();
    }
}

XiaomiFactory

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class XiaomiFactory implements IProductFactory{

    @Override
    public IphoneProduct IphoneProduct() {
        return new XiaomiIphone();
    }

    @Override
    public IRouterProduct IRouterProduct() {
        return new XiaomiRouter();
    }
}

Client 控制台

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Client {

    public static void main(String[] args) {

        System.out.println("-----------------------小米产品----------------------");

         XiaomiFactory xiaomiFactory = new XiaomiFactory();

         IphoneProduct iphoneProduct = xiaomiFactory.IphoneProduct();

          iphoneProduct.start();
          iphoneProduct.callup();
          iphoneProduct.sendms();

         IRouterProduct iRouterProduct = xiaomiFactory.IRouterProduct();

         iRouterProduct.seeting();
         iRouterProduct.shutdown();
         iRouterProduct.start();



        System.out.println("-----------------------华为产品----------------------");


        HuaweiFactory huaweiFactory = new HuaweiFactory();

        IphoneProduct iphoneProduct1 = huaweiFactory.IphoneProduct();

        iphoneProduct1.start();
        iphoneProduct1.callup();
        iphoneProduct1.sendms();

        IRouterProduct iRouterProduct2 = huaweiFactory.IRouterProduct();

        iRouterProduct2.seeting();
        iRouterProduct2.shutdown();
        iRouterProduct2.start();


    }
}

运行结果如下：
在这里插入图片描述

在这里插入图片描述
其实写完代码；我个人对抽象接口的理解就是一个接口一个实现；老子管儿子，儿子管孙子这么一个概念；接口不断的封装继续；其实大型项目结构稳定的使用是ok的经常变化的你今天加几个接口明天加几个也很麻烦，根据自己的业务逻辑自行判断吧；

1.4 总结

在这里插入图片描述

设计模式只是一种思想；

设计模式总目录：https://blog.csdn.net/qq_42055933/article/details/126613801?spm=1001.2014.3001.5501（查看其他章节请点击）

最后

以上就是微笑导师最近收集整理的关于23设计模式之 --------- 工厂模式????1.工厂模式简介的全部内容，更多相关23设计模式之内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(62)

相关文章

9000+字，唠唠架构中的设计模式
9000+字，唠唠架构中的设计模式
设计模式原则的核心思想设计原则的核心思想
设计模式原则的核心思想设计原则的核心思想
设计模式的目的与原则设计模式的目的设计模式的原则
设计模式的目的与原则设计模式的目的设计模式的原则
Java设计模式七大原的核心思想
Java设计模式七大原的核心思想
23设计模式之 --------- 工厂模式????1.工厂模式简介
23设计模式之 --------- 工厂模式????1.工厂模式简介
Java设计模式 - 单例模式一、什么是单例模式二、饿汉式示例三、懒汉式示例四、登记式/静态内部类示例
Java设计模式 - 单例模式一、什么是单例模式二、饿汉式示例三、懒汉式示例四、登记式/静态内部类示例
写博客的目的
写博客的目的
使用设计模式的目的
使用设计模式的目的

评论列表共有 0 条评论

立即
投稿
返回
顶部