设计模式之工厂系列

最新推荐文章于 2024-09-15 16:31:23 发布
最新推荐文章于 2024-09-15 16:31:23 发布
阅读量146 收藏
点赞数
分类专栏： Java 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengchanmin/article/details/113525411
版权

修真者想要修炼只需要吃灵药和仙露就可以升级，那么他并不需要知道这种能令自己升级的东西是怎么创造出来的，只需要去对应的商店购买就好了。这个时候就需要一个商店，工厂类就是这样的一个存在。购买者根据不同的需求获得不同的物品。

1.简单工厂模式

创建一个工厂类，对同一方法的一些类进行实例化的创建返回，这种简单工厂的可扩展性不好。
package com.zcm.factory.simple;

import com.zcm.factory.*;

/**
 * @program: demo
 * @ClassName：SimpleVehicleFactory
 * @Description：简单工厂：创建一个工厂类，对同一方法的一些类进行实例化的创建返回，这种简单工厂的可扩展性不好。
 * @Author：zcm
 * @Date：2021/2/1 16:37
 */
public class SimpleFactory {

    public Food createFood(int type) {
        Food food = null;
        switch (type) {
            default:
                food = new Elixir();
                break;
            //灵药
            case 1:
                food = new Elixir();
                break;
            //仙露
            case 2:
                food = new Xianlu();
                break;
        }
        return food;
    }

    public static void main(String[] args) {
        System.out.println("修真者用什么修炼：");
        new SimpleFactory().createFood(1).eat();
        new SimpleFactory().createFood(2).eat();
    }
}

2.工厂方法

提供多个⼯厂⽅法，分别创建相应的对象或者接口实现返回。

package com.zcm.factory.factorymethod;

import com.zcm.factory.*;

/**
 * @program: demo
 * @ClassName：XianluFactory
 * @Description：工厂方法:提供多个⼯厂⽅法，分别创建相应的对象或者接口实现返回
 * @Author：zcm
 * @Date：2021/2/1 16:57
 */
public class FoodFactory {
    /**
     * @Description:灵药
     * @Author: zcm
     * @Version：v.2.7.1
     * @Date:2021/2/1 17:16
     */
    public Food createElixir() {
        System.out.println("灵药是怎么生长的？");
        System.out.println("需要日月精华日积月累灌溉十万年最终长成灵药~");
        return new Elixir();
    }

    /**
     * @Description:仙露，随意制作仙露过程
     * @Author: zcm
     * @Version：v.2.7.1
     * @Date:2021/2/1 17:16
     */
    public Food createXianlu() {
        System.out.println("仙露是怎么制成的？");
        System.out.println("1.需要仙山雨露经过层层提炼最后制成仙露~");
        return new Xianlu();
    }

    public static void main(String[] args) {
        System.out.println("修真世界的人可以吃的食物有：");
        new FoodFactory().createElixir().eat();
        new FoodFactory().createXianlu().eat();
    }
}

3.静态工厂方法

将多个工厂⽅法置为静态的，不需要创建⼯厂实例，直接调⽤即可；
package com.zcm.factory.factorymethod;

import com.zcm.factory.*;

/**
 * @program: demo
 * @ClassName：FoodStaticFactory
 * @Description：静态⼯厂⽅法模式：将多个工厂⽅法置为静态的，不需要创建⼯厂实例，直接调⽤即可；
 * @Author：zcm
 * @Date：2021/2/1 17:37
 */
public class FoodStaticFactory {

    /**
     * @Description:灵药
     * @Author: zcm
     * @Version：v.2.7.1
     * @Date:2021/2/1 17:16
     */
    public static Food createElixir() {
        System.out.println("灵药是怎么生长的？");
        System.out.println("需要日月精华日积月累灌溉十万年最终长成灵药~");
        return new Elixir();
    }

    /**
     * @Description:仙露
     * @Author: zcm
     * @Version：v.2.7.1
     * @Date:2021/2/1 17:16
     */
    public static Food createXianlu() {
        System.out.println("仙露是怎么制成的？");
        System.out.println("1.需要仙山雨露经过层层提炼最后制成仙露~");
        return new Xianlu();
    }

    public static void main(String[] args) {
        System.out.println("修真世界的人可以吃的食物有：");
        FoodStaticFactory.createElixir().eat();
        FoodStaticFactory.createXianlu().eat();

    }

}

4.关系图

 5.适⽤用场景：

凡是出现了⼤量不同种类的产品需要创建，并且具有共同的接口时，可以通过⼯厂⽅法模式进⾏创建。在以上的三种模式 中，第⼀种如果传⼊的类型不对，不能创建自己想要的对象，第三种相对于第二种，不需要实例化⼯厂类，多数情况下，我们会选⽤用第三种静态⼯⼚⽅法模式。

6.抽象工厂

工厂模式只能让修真者修炼上提升，那么万一在我修炼的时候，被我的敌人偷袭了怎么办？我能不能搞点东西加个防御啥的？在搞个武器放在身边防身？

1.食物

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName Food
 * @Description：任意定制食物继承Food
 * @Author zcm
 * @Date 2021/1/26 17:35
 * @Version V1.0
 */
public abstract class Food {
    public abstract void eat();
}

1.1 灵药

 

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName Elixir
 * @Description
 * @Author zcm
 * @Date 2021/1/26 17:55
 * @Version V1.0
 */
public class Elixir extends Food {
    @Override
    public void eat() {
        System.out.println("吃灵药....");
    }
}

1.2 仙露

package com.zcm.factory;

/**
 * @program: demo
 * @ClassName：Xianlu
 * @Description：
 * @Author：zcm
 * @Date：2021/2/1 16:49
 */
public class Xianlu extends Food {
    @Override
    public void eat() {
        System.out.println("喝仙露...");
    }
}

1.3面包

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName Bread
 * @Description
 * @Author zcm
 * @Date 2021/1/26 17:43
 * @Version V1.0
 */
public class Bread extends Food {
    @Override
    public void eat() {
        System.out.println("吃面包.....");
    }
}

2.服装

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName Clothes
 * @Description:任意定制服装继承Clothes
 * @Author zcm
 * @Date 2021/1/26 17:35
 * @Version V1.0
 */
public abstract class Clothes {
    /**
     * @Description:服装
     * @Author: zcm
     * @Version：v.2.3.0
     * @Date:2021/1/26 17:37
     */
    public abstract void clothes();

}

2.1道袍

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName TaoRobe
 * @Description
 * @Author zcm
 * @Date 2021/1/26 17:52
 * @Version V1.0
 */
public class TaoRobe extends Clothes {
    @Override
    public void clothes() {
        System.out.println("穿天尊道袍.....");
    }
}

2.2 连衣裙

package com.zcm.factory;

/**
 * @program: DemoZCM
 * @ClassName Dress
 * @Description
 * @Author zcm
 * @Date 2021/1/26 18:00
 * @Version V1.0
 */
public class Dress extends Clothes {
    @Override
    public void clothes() {
        System.out.println("穿连衣裙....");
    }
}

3.武器

package com.zcm.factory;

/**
 * @program: demo
 * @ClassName：Arms
 * @Description：
 * @Author：zcm
 * @Date：2021/2/2 10:00
 */
public abstract class Arms {
    public abstract void  arms();
}

3.1 枪【M416】

 

package com.zcm.factory;

/**
 * @program: demo
 * @ClassName：Gun
 * @Description：
 * @Author：zcm
 * @Date：2021/2/2 10:03
 */
public class Gun extends Arms {
    @Override
    public void arms() {
        System.out.println("拿M416");
    }
}

 3.2剑【诛仙剑】

package com.zcm.factory;

/**
 * @program: demo
 * @ClassName：Sword
 * @Description：
 * @Author：zcm
 * @Date：2021/2/2 10:02
 */
public class Sword extends Arms {
    @Override
    public void arms() {
        System.out.println("持诛仙剑");
    }
}

4.抽象工厂：制作食物，制作服装，制作武器。

package com.zcm.factory.abstractfactory;

import com.zcm.factory.*;

/**
 * @program: DemoZCM
 * @ClassName AbstractFactory
 * @Description
 * @Author zcm
 * @Date 2021/1/26 17:12
 * @Version V1.0
 */
public abstract class AbstractFactory {
    /**
     * @Description:食物
     * @Author: zcm
     * @Version：v.2.3.0
     * @Date:2021/1/26 17:13
     */
    public abstract Food createFood();

    /**
     * @Description:服装
     * @Author: zcm
     * @Version：v.2.3.0
     * @Date:2021/1/26 17:27
     */
    public abstract Clothes createClothes();


    /**
     * @Description:武器
     * @Author: zcm
     * @Version：v.2.3.0
     * @Date:2021/1/26 17:27
     */
    public abstract Arms createArms();

}

4.1 具体工厂【修真世界的工厂】

 

package com.zcm.factory.abstractfactory;

import com.zcm.factory.*;
import com.zcm.factory.abstractfactory.*;

/**
 * @program: DemoZCM
 * @ClassName FoodFactory
 * @Description:修真世界的人
 * @Author zcm
 * @Date 2021/1/26 17:33
 * @Version V1.0
 */
public class ComprehensionFactory extends AbstractFactory {
    @Override
    public Food createFood() {
        System.out.println("灵药生长过程：");
        System.out.println("需要日月精华日积月累灌溉十万年最终长成灵药~");
        return new Elixir();
    }

    @Override
    public Clothes createClothes() {
        System.out.println("道袍制作过程：");
        System.out.println("天蚕丝和防御宝石缝制七天最终制成天尊道袍");
        return new TaoRobe();
    }

    @Override
    public Arms createArms() {
        System.out.println("诛仙剑制作过程：");
        System.out.println("玄光铁10斤，环心沙10斤，极影铜10斤，心头血一碗....在炼器炉中经过九九八十一日破炉而出，在经过天劫锤炼而成~");
        return new Sword();
    }
}

4.2 具体工厂【现代世界的工厂】

 

package com.zcm.factory.abstractfactory;

import com.zcm.factory.*;
import com.zcm.factory.abstractfactory.*;

/**
 * @program: DemoZCM
 * @ClassName modernFactory
 * @Description
 * @Author zcm
 * @Date 2021/1/26 17:59
 * @Version V1.0
 */
public class ModernFactory extends AbstractFactory {
    @Override
    public Food createFood() {
        System.out.println("面包制作过程：");
        System.out.println("烤箱烤出来的~");
        return new Bread();
    }

    @Override
    public Clothes createClothes() {
        System.out.println("连衣裙制作过程：");
        System.out.println("天蚕丝手缝数来的~");
        return new Dress();
    }

    @Override
    public Arms createArms() {
        System.out.println("M416制作过程：");
        System.out.println("工程师制成的~");
        return new Gun();
    }
}

5.开始使用

package com.zcm.factory.abstractfactory;

import com.zcm.factory.*;
import com.zcm.factory.abstractfactory.*;

/**
 * @program: DemoZCM
 * @ClassName Main
 * @Description
 * @Author zcm
 * @Date 2021/1/26 18:01
 * @Version V1.0
 */
public class TestMain {
    public static void main(String[] args) {
        //修真世界的人
        System.out.println("修真世界的人----------------");
        AbstractFactory factory = new ComprehensionFactory();
        factory.createClothes().clothes();
        factory.createFood().eat();
        factory.createArms().arms();
        System.out.println("------------------------------");
        //现代世界的人
        System.out.println("现代世界的人------------------");
        factory = new ModernFactory();
        factory.createClothes().clothes();
        factory.createFood().eat();
        factory.createArms().arms();
        System.out.println("------------------------------");
    }
}

6.关系图 

7.效果如下： 

总结：

工厂模式： 

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

1.每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。耦合性太高。

抽象工厂：

优点：

1.当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

但是抽象工厂想要扩展其中某一个产品，既要在food,clothes,arm加代码，又要再具体实现里加代码，很麻烦。

但是springIOC和Bean工厂可以很好的规避这个问题。

 

 

 

 

 

 

清风醉晚霞
关注
专栏目录
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
设计模式--工厂系列
qq_lindy的博客
06-20 73
定义： 工厂方法在产品上扩展是很方便的， 而抽象工厂在具体的产品一族（食物， 武器， 交通工具）的扩展是方便的 Spring 的bean工厂是更好的解决方案。 简单工厂 随便一个方法，create一个新东西就是简单工厂。 静态工厂 单例就是个静态工厂。 静态方法的产生。 工厂方法： 在产品维度上扩展很方便。 抽象工厂： 在具体产品一族上扩展很方便。 Spring IOC ...
设计模式：工厂系列：总结
weixin_30617797的博客
12-06 86
Design & Pattern : Factory Series : Generalization简单工厂模式（Simply Factory Pattern）,工厂方法模式（Factory Method Pattern）,抽象工厂模式（Abstract Factory Pattern）想把这3个模式的特点和关联总结一下。 Pattern Name 工厂 Factroy ...
设计模式之抽象工厂模式
最新发布
一个老Java开发的自白
09-15 1456
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。在抽象工厂模式中，客户端不依赖于产品类实例如何被创建、组合和表达的细节，这是通过使用一个共同的接口来指向新的或现有的产品类。
设计模式之工厂模式
weixin_64366370的博客
04-30 1572
本文简要介绍了工厂模式，其中包含了23种设计模式中的“工厂方法模式”和“抽象工厂模式”。
Java 设计模式之工厂模式详解
m0_73581119的博客
04-20 1347
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而不需要暴露对象的创建逻辑。简单来说，工厂模式就是将对象的创建过程封装起来，客户端不需要关心对象是如何创建的，只需要通过工厂来获取所需的对象即可。工厂模式是一种常用的设计模式，它可以帮助我们更好地管理对象的创建过程，降低代码的耦合度，提高代码的复用性和扩展性。在实际项目中，根据不同的需求可以选择不同类型的工厂模式来创建对象，从而更好地满足项目的需求。
C# 设计模式之抽象工厂模式
鲤籽鲲的博客
08-01 1189
C# 设计模式之抽象工厂模式
C++ 设计模式——工厂模式
qq_68194402的博客
08-17 1733
工厂模式是一种创建对象的设计模式，主要用于将对象的创建与使用分离。它提供了一种接口来创建对象，但由子类决定实例化哪个类。工厂模式有几种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。
C#设计模式——工厂模式
m0_46549858的博客
11-18 1405
​
设计模式——工厂模式
热门推荐
XHY的博客
10-12 2万+
1. 工厂模式定义 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 2. 作用 通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系 3. 类图 这里的工厂与产品为一对一的关系，属于简单工厂 .
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
C# 设计模式系列教程-抽象工厂模式
12-26
当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。 2.　抽象工厂模式中的角色  2.1 抽象工厂（AbstractFactory）：担任这个角色的是工厂方法模式的核心，它是与...
Android设计模式系列之工厂方法模式
01-20
工厂方法模式是面向对象设计模式的一种，主要用于解决对象创建的问题。在Android开发中，它被广泛应用，尤其是在需要根据条件或动态地创建不同类型的对象时。本文将深入探讨工厂方法模式的概念、结构、目的以及在...
org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflection.Reflecti
浮生未歇的博客
04-05 1万+
今天遇到一个问题：org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'param1' in 'class java.lang.String' ...
ES must、filter、should一起使用，导致的should语句失效
浮生未歇的博客
02-06 6158
当使用should查询时，如果包含了must或者filter查询，那么should的查询语句就不是或者【OR】的意思了,而是有或者没有都行的含义。 filter和should语句组合查询，会导致should语句失效 GET zx_album/album/_search { "query": { "bool": { "filter": [ { "term": { "userId"
微信公众号Java开发：自动回复文字及图片，第三方接口
浮生未歇的博客
04-28 2468
代码结构 pom.xml <!--微信公众号--> <dependency> <groupId>com.github.binarywang</groupId> <artifactId>weixin-java-mp</artifactId>...
小数据的导出 最大只能65536条
浮生未歇的博客
11-17 1443
@SuppressWarnings("unused") @RequestMapping(params = "excelExport") public void excelExport(@RequestParam HashMap paramMap, HttpServletRequest request,HttpServletResponse response) { response.setCo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值