Java设计模式之工厂模式案例详解

目录
  • 分类
  • 案例
    • 需求
    • 方案一:简单工厂模式
    • 方案二:工厂方法模式
    • 方案三:抽象工厂模式
  • 对比分析
  • 总结

分类

1.简单工厂模式

2.工厂方法模式

3.抽象工厂模式

案例

需求

根据蛋糕的不同口味,分别创建苹果味和香蕉味的蛋糕实例

方案一:简单工厂模式

定义蛋糕父类

/**
 * 蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class Cake {
}

定义苹果味的蛋糕

/**
 * 苹果蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class AppleCake extends Cake{
    public AppleCake(){
        System.out.println("创建了苹果蛋糕实例");
    }
}

定义香蕉味的蛋糕

/**
 * 香蕉蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class BananaCake extends Cake{
    public BananaCake(){
        System.out.println("创建了香蕉蛋糕实例");
    }
}

定义蛋糕工厂类

/**
 * 蛋糕工厂
 * @author:liyajie
 * @createTime:2022/2/14 10:16
 * @version:1.0
 */
public class CakeFactory {

    public Cake createCake(String type){
        if("apple".equals(type)){
            return new AppleCake();
        }else if("banana".equals(type)){
            return new BananaCake();
        }else {
            return null;
        }
    }
}

定义测试类

/**
 * 测试类
 * @author:liyajie
 * @createTime:2022/2/14 10:25
 * @version:1.0
 */
public class Test {
    public static void main(String[] args) {
        CakeFactory cakeFactory = new CakeFactory();
        cakeFactory.createCake("apple");
        cakeFactory.createCake("banana");
    }
}

查看结果:

方案二:工厂方法模式

定义蛋糕父类

/**
 * 蛋糕父类
 * @author:liyajie
 * @createTime:2022/2/14 10:44
 * @version:1.0
 */
public abstract class Cake {

}

定义苹果蛋糕

/**
 * 苹果蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class AppleCake extends Cake {
    public AppleCake(){
        System.out.println("创建了苹果蛋糕实例");
    }
}

定义香蕉蛋糕

/**
 * 香蕉蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class BananaCake extends Cake {
    public BananaCake(){
        System.out.println("创建了香蕉蛋糕实例");
    }
}

定义蛋糕工厂类 该类主要是定义了createCake抽象方法,并且在无参构造函数中进行调用,具体的实现是在子类里进行实例化的

/**
 * 蛋糕工厂类
 * @author:liyajie
 * @createTime:2022/2/14 11:55
 * @version:1.0
 */
public abstract class CakeFactory {

    abstract Cake createCake();

    public CakeFactory() {
        createCake();
    }
}

定义苹果蛋糕工具类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 11:58
 * @version:1.0
 */
public class AppleCakeFactory extends CakeFactory{

    @Override
    public Cake createCake() {
        return new AppleCake();
    }
}

定义香蕉蛋糕工具类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 11:58
 * @version:1.0
 */
public class BananaCakeFactory extends CakeFactory{
    @Override
    public Cake createCake() {
        return new BananaCake();
    }
}

定义测试类

/**
 * 测试类
 * @author:liyajie
 * @createTime:2022/2/14 12:02
 * @version:1.0
 */
public class Test {
    public static void main(String[] args) {
        AppleCakeFactory appleCakeFactory = new AppleCakeFactory();

        BananaCakeFactory bananaCakeFactory = new BananaCakeFactory();
    }
}

查看结果

方案三:抽象工厂模式

定义蛋糕父类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 10:44
 * @version:1.0
 */
public abstract class Cake {

}

定义苹果蛋糕

/**
 * 苹果蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class AppleCake extends Cake {
    public AppleCake(){
        System.out.println("创建了苹果蛋糕实例");
    }
}

定义香蕉蛋糕

/**
 * 香蕉蛋糕
 * @author:liyajie
 * @createTime:2022/2/14 10:17
 * @version:1.0
 */
public class BananaCake extends Cake {
    public BananaCake(){
        System.out.println("创建了香蕉蛋糕实例");
    }
}

定义蛋糕工厂类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 11:55
 * @version:1.0
 */
public interface CakeFactory {

    Cake createCake();
}

定义苹果蛋糕工厂类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 11:58
 * @version:1.0
 */
public class AppleCakeFactory implements CakeFactory {

    @Override
    public Cake createCake() {
        return new AppleCake();
    }
}

定义香蕉蛋糕工厂类

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 11:58
 * @version:1.0
 */
public class BananaCakeFactory implements CakeFactory {
    @Override
    public Cake createCake() {
        return new BananaCake();
    }
}

定义蛋糕工厂生成器

/**
 * @desc:
 * @author:liyajie
 * @createTime:2022/2/14 17:46
 * @version:1.0
 */
public class FactoryProducter {

    CakeFactory cakeFactory;

    public FactoryProducter(CakeFactory cakeFactory){
        setCakeFactory(cakeFactory);
    }

    public void setCakeFactory(CakeFactory cakeFactory){
        this.cakeFactory = cakeFactory;
        cakeFactory.createCake();
    }
}

定义测试类

/**
 * 测试类
 * @author:liyajie
 * @createTime:2022/2/14 12:02
 * @version:1.0
 */
public class Test {
    public static void main(String[] args) {
        new FactoryProducter(new AppleCakeFactory());
        new FactoryProducter(new BananaCakeFactory());
    }
}

查看结果

对比分析

  • 方案一:简单工厂模式,工厂类是只有一个,只需要改动这一个地方 避免了业务逻辑的代码和创建对象的代码大量耦合,降低耦合 让代码更加条理清晰,更加优雅
  • 方案二:工厂方法模式是简单工厂模式的衍生,定义一个创建对象的抽象方法,由子类决定要实例化的类,将对象实例化延迟到子类,实现了可扩展,层次结构更复杂,可以应用到更复杂的场合
  • 方案三:抽象工厂模式,定义一个接口来用于创建相关的或者具有依赖关系的对象簇,将实例化对象的细节提取出来,放到工厂角色,由工厂角色负责具体的创建细节,解耦合,提高项目可扩展性和可维护性

总结

通过以上三个案例,对比分析我们明确了三种工厂模式实现的方式,也对比分析了各个工厂模式的优点。但是切记,实际开发过程中,不要盲目的使用,一定要结合具体的业务,实际分析后才去使用。

到此这篇关于Java设计模式之工厂模式案例详解的文章就介绍到这了,更多相关Java工厂模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java中常用的设计模式之工厂模式详解

    目录 优点 缺点 使用场景 一.实现方式 1.定义一个接口 2.定义两个接口实现类 3.定义一个工厂类 二.测试 总结 优点 1.一个调用者想创建一个对象,只要知道其名称就可以了. 2.扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以. 3.屏蔽产品的具体实现,调用者只关心产品的接口. 缺点 1.每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖.这并不是什么好事. 使用场景 1.日志记录器:记录

  • 深入理解Java设计模式之抽象工厂模式

    目录 一.什么是抽象工厂模式 二.抽象工厂模式的应用场景 三.抽象工厂模式和工厂方法模式对比 四.抽象工厂模式的优缺点 五.抽象工厂模式的实现 六.总结 一.什么是抽象工厂模式 为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类. 抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态.抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式. 抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象. 根据里氏替换原则,任

  • java设计模式--三种工厂模式详解

    目录 简单工厂 代码: 1.产品接口 2.产品接口实现子类 3.简单工厂类 4.调用工厂 5.测试 工厂方法 代码: 1.工厂接口 2.工厂实现子类 3.产品接口 4.产品实现子类 5.调用 6.测试 1.产品接口 2.产品抽象子类-普通产品 抽象工厂 3.1产品抽象子类-魔法产品 4.工厂接口 5.工厂实现子类-普通工厂 6.工厂实现子类-魔法工厂 7.调用 8.测试 总结 简单工厂 简单工厂模式是属于创建型模式,是工厂模式的一种.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.定义

  • Java设计模式之抽象工厂模式详解

    一.什么是抽象工厂模式 为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类,这称之为抽象工厂模式(Abstract Factory).我们并不关心零件的具体实现,而是只关心接口(API).我们仅使用该接口(API)将零件组装称为产品. 二.示例程序   1.抽象的零件:Item类 package com.as.module.abstractfactory; /** * 抽象的零件 * @author Andy * @date 2021/4/29 23:16 */ public

  • Java 深入理解创建型设计模式之抽象工厂模式

    1.什么是抽象工厂模式? 抽象工厂模式:  定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合. 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象). 将工厂抽象成两层,AbsFactory(抽象工厂))和具体实现的工厂子类.程序员可以根据创建对象类型使用对应的工厂子类.这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展. 我们仍然以上一篇文章的案例为主,画出抽象工厂模式下的类图

  • 深入理解Java设计模式之简单工厂模式

    目录 一.什么是简单工厂模式 二.简单工厂模式的结构 三.简单工厂模式的应用场景 四.简单工厂模式和工厂方法模式区别 五.简单工厂模式和策略模式的异同 六.简单工厂模式的优缺点 七.简单工厂模式的实现 八.总结 一.什么是简单工厂模式 简单工厂模式又称为静态工厂模式,实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例.简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例. 其实就是将一个具体类的实例化交给一个静态工厂方法来执

  • Java设计模式之工厂模式案例详解

    目录 分类 案例 需求 方案一:简单工厂模式 方案二:工厂方法模式 方案三:抽象工厂模式 对比分析 总结 分类 1.简单工厂模式 2.工厂方法模式 3.抽象工厂模式 案例 需求 根据蛋糕的不同口味,分别创建苹果味和香蕉味的蛋糕实例 方案一:简单工厂模式 定义蛋糕父类 /** * 蛋糕 * @author:liyajie * @createTime:2022/2/14 10:17 * @version:1.0 */ public class Cake { } 定义苹果味的蛋糕 /** * 苹果蛋糕

  • java设计模式之工厂模式实例详解

    本文实例讲述了java设计模式之工厂模式.分享给大家供大家参考,具体如下: 工厂模式(factory) 涉及到4个角色:抽象工厂类角色,具体工厂类角色,抽象产品类角色和具体产品类角色. 抽象工厂类角色使用接口或者父类来描述工厂的行为, 具体工厂类角色负责创建某一类型的产品对象. 抽象产品类可以使用接口或者父类来描述产品对象的行为特征. 具体产品类就是某一具体的对象. 工厂模式不同于静态工厂模式的地方: 工厂模式在工厂类也实现了多态,而不仅仅是在产品对象上实现多态. 它可以应对不同类型的产品对应一

  • Java设计模式之策略模式案例详解

    目录 优缺点 Spring中哪里使用策略模式 策略模式设计图 代码案例 为什么使用策略模式? 答:策略模式是解决过多if-else (或者switch-case)代码块的方法之一,提高代码的可维护性.可扩展性和可读性. 优缺点 优点 算法可以自由切换(高层屏蔽算法,角色自由切换). 避免使用多重条件判断(如果算法过多就会出现很多种相同的判断,很难维护) 扩展性好(可自由添加取消算法而不影响整个功能). 缺点 策略类数量增多(每一个策略类复用性很小,如果需要增加算法,就只能新增类).所有的策略类都

  • Java设计模式之外观模式示例详解

    目录 定义 案例 需求 方案:外观模式实现 分析 总结 定义 外观模式为多个复杂的子系统,提供了一个一致的界面,使得调用端只和这个接口发生调用,而无须关系这个子系统内部的细节 案例 需求 看电影的时候需要进行一系列的操作,比如打开播放器,放下屏幕,打开投影仪,打开音响等,这个要怎么进行管理呢 方案:外观模式实现 定义播放器类 public class Player { private static Player player = new Player(); private Player(){}

  • Java设计模式之策略模式示例详解

    目录 定义 结构 UML类图 UML序列图 深入理解策略模式 策略和上下文的关系 策略模式在JDK中的应用 该策略接口有四个实现类 策略模式的优点 策略模式的缺点 策略模式的本质 在讲策略模式之前,我们先看一个日常生活中的小例子: 现实生活中我们到商场买东西的时候,卖场往往根据不同的客户制定不同的报价策略,比如针对新客户不打折扣,针对老客户打9折,针对VIP客户打8折... 现在我们要做一个报价管理的模块,简要点就是要针对不同的客户,提供不同的折扣报价. 如果是有你来做,你会怎么做? 我们很有可

  • Java设计模式中桥接模式应用详解

    目录 1.桥接(Bridge)设计模式定义 2.桥接设计模式优点以及不足 3.桥接设计的实现思路 4.桥接设计模式示例 5.桥接模式的应用场景 6.桥接设计模式和适配器设计模式对比 编程是一门艺术,大批量的改动显然是非常丑陋的做法,用心的琢磨写的代码让它变的更美观. 显示生活中有物品具有多个维度的属性,比如文字有颜色和字体两个维度的差别,汽车有颜色和牌子两个维度的属性等.如果用继承方式,不但对应的子类很多,而且扩展困难.如果用桥接模式就能很好地解决这些问题. 1.桥接(Bridge)设计模式定义

  • Java设计模式之监听器模式实例详解

    本文实例讲述了Java设计模式之监听器模式.分享给大家供大家参考,具体如下: 监听器模式有三个要素--事件源.事件对象.监听器. 事件源:顾名思义,事件发生的源头,比如点击的按钮,属于被监听的对象: 事件对象:这个经常和事件源混淆,它经常被用来包装事件源,切记,它毕竟是个事件,比如点击事件,和事件源的区别自己感受,木有栗子: 监听器:这个是监听器模式的核心,定义事件发生后的动作,通常事件对象作为监听器中定义的函数入参. 下面举个简单的栗子: 故事背景是,小明是个不讲卫生的孩子,他妈妈很担心他的健

  • Java设计模式之桥接模式实例详解

    本文实例讲述了Java设计模式之桥接模式.分享给大家供大家参考,具体如下: 概念: 桥接模式(Bridge Pattern):将抽象部分与它的实现部分分离,使它们都可以独立地变化. 桥接模式将继承关系转换为关联关系,从而降低了类与类之间的耦合,减少了代码编写量. 什么情况下会用桥接模式? 简单的说就是我们在抽象对象的特征时,对象的特征属性又很抽象,不得不把属性再次抽象. 否则的话,具体子类的数量将会成几何增长,而且不易扩展.没办法维护现有代码. 举例,我们在抽象手机这二个对象时,它的几个属性,如

  • Java设计模式之建造者模式实例详解

    本文实例讲述了Java设计模式之建造者模式.分享给大家供大家参考,具体如下: 建造者模式(builder)可以将部件和其组装过程分开.一步一步创建一个复杂的对象. 用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节. 什么情况下会用到建造者模式? 个人理解,当我们创建的对象在创建时需要逻辑的时候. 比如,一个简单的pojo对象,我们想要创建,直接就可以new出来,没有什么逻辑. 当有一个复杂的对象,你想要创建它时,它的各个属性之间是有逻辑关系的. 一个属性赋值取值依赖于

  • java 单例模式和工厂模式实例详解

    单例模式根据实例化对象时机的不同分为两种:一种是饿汉式单例,一种是懒汉式单例. 私有的构造方法 指向自己实例的私有静态引用 以自己实例为返回值的静态的公有的方法 饿汉式单例 public class Singleton { private static Singleton singleton = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return singleton; } } 懒

随机推荐