JAVA设计模式—工厂模式笔记

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

案例1：在蛋糕店下单买蛋糕，可以选择不同口味的蛋糕。比如奶油蛋糕，巧克力蛋糕。

1. 传统方式

public abstract class Cake {
    public static final String CREAM_CAKE = "cream";
    public static final String CHOCOLATE_CAKE = "choc";
    private String name;

    public abstract void ready();

    public void make() {
        System.out.println(name + " 正在制作~~");
    }

    public void bake() {
        System.out.println(name + " 正在烘培~~");
    }

    public void pack() {
        System.out.println(name + " 正在打包~~");
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class ChocolateCake extends Cake{

    @Override
    public void ready() {
        System.out.println("准备制作巧克力蛋糕的材料~~");
    }
}
public class CreamCake extends Cake{

    @Override
    public void ready() {
        System.out.println("准备制作奶油蛋糕的材料~~");
    }
}
public class CakeOrder {

    public CakeOrder () {
        Cake cake = null;
        do {
            String cakeType = getCakeType();
            if (cakeType.equals(Cake.CREAM_CAKE)) {
                cake = new CreamCake();
                cake.setName("奶油蛋糕");
            } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
                cake = new ChocolateCake();
                cake.setName("巧克力蛋糕");
            } else {
                System.out.println("输入的蛋糕类型不存在，下单失败！");
                break;
            }
            System.out.println("下单成功！");
            cake.ready();
            cake.make();
            cake.bake();
            cake.pack();
            System.out.println("骑手正在派送！");
        } while (true);
    }

    private String getCakeType() {
        System.out.println("请输入蛋糕类型：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}


public class CakeStore {
    public static void main(String[] args) {
        new CakeOrder();//传统的实现方式
    }
}

说明：

  1. 传统的方式代码实现简单，但是扩展性差，如果新增其他口味的蛋糕，代码改动很大。
  2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

2. 工厂模式

2.1 简单工厂模式

简介：

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
  2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
public abstract class Cake {
    public static final String CREAM_CAKE = "cream";
    public static final String CHOCOLATE_CAKE = "choc";
    private String name;

    public abstract void ready();

    public void make() {
        System.out.println(name + " 正在制作~~");
    }

    public void bake() {
        System.out.println(name + " 正在烘培~~");
    }

    public void pack() {
        System.out.println(name + " 正在打包~~");
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class ChocolateCake extends Cake{

    @Override
    public void ready() {
        System.out.println("准备制作巧克力蛋糕的材料~~");
    }
}

public class CreamCake extends Cake{

    @Override
    public void ready() {
        System.out.println("准备制作奶油蛋糕的材料~~");
    }
}
//简单工厂模式工厂类
public class SimpleFactory {

    //也可以将该方法直接写成静态方法
    public Cake createCake(String cakeType) {
        Cake cake = null;
        if (cakeType.equals(Cake.CREAM_CAKE)) {
            cake = new CreamCake();
            cake.setName("奶油蛋糕");
        } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
            cake = new ChocolateCake();
            cake.setName("巧克力蛋糕");
        } else {
            System.out.println("输入的蛋糕类型不存在。");
        }
        return cake;
    }
}
public class CakeOrderBySimple {
    private SimpleFactory sf;

    public CakeOrderBySimple(SimpleFactory sf) {
        this.sf = sf;
        createOrder();
    }

    private void createOrder() {
        Cake cake = null;
        do {
            String cakeType = getCakeType();
            cake = sf.createCake(cakeType);
            if (cake != null) {
                System.out.println("下单成功！");
                cake.ready();
                cake.make();
                cake.bake();
                cake.pack();
                System.out.println("骑手正在派送！");
            } else {
                System.out.println("下单失败！");
                break;
            }
        } while (true);
    }

    private String getCakeType() {
        System.out.println("请输入蛋糕类型：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}
public class CakeStoreBySimple {
    public static void main(String[] args) {
        new CakeOrderBySimple(new SimpleFactory());//简单工厂模式
    }
}

 

案例2：在蛋糕店下单买蛋糕，可以在不同地域的蛋糕店，选择不同口味的蛋糕。比如在北京买奶油蛋糕，巧克力蛋糕，也可以在南京买奶油蛋糕，巧克力蛋糕。

2.2 工厂方法模式

简介：

定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

将蛋糕项目的实例化功能抽象成抽象方法，在不同的口味子类中具体实现。

public abstract class Cake {
    public static final String CREAM_CAKE = "cream";
    public static final String CHOCOLATE_CAKE = "choc";
    private String name;

    public abstract void ready();

    public void make() {
        System.out.println(name + " 正在制作~~");
    }

    public void bake() {
        System.out.println(name + " 正在烘培~~");
    }

    public void pack() {
        System.out.println(name + " 正在打包~~");
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class BJChocolateCake extends Cake {

    @Override
    public void ready() {
        System.out.println("准备制作北京巧克力蛋糕的材料~~");
    }
}

public class BJCreamCake extends Cake {

    @Override
    public void ready() {
        System.out.println("准备制作北京奶油蛋糕的材料~~");
    }
}

public class NJChocolateCake extends Cake{
    @Override
    public void ready() {
        System.out.println("准备制作南京奶油蛋糕的材料~~");
    }
}
public class NJCreamCake extends Cake{

    @Override
    public void ready() {
        System.out.println("准备制作南京奶油蛋糕的材料~~");
    }
}

 

public abstract class CakeOrderByMethod {

    public CakeOrderByMethod() {
        Cake cake = null;
        do {
            String cakeType = getCakeType();
            cake = createCake(cakeType);
            if (cake != null) {
                System.out.println("下单成功！");
                cake.ready();
                cake.make();
                cake.bake();
                cake.pack();
                System.out.println("骑手正在派送！");
            } else {
                System.out.println("下单失败！");
                break;
            }
        } while (true);
    }

    public abstract Cake createCake(String cakeType);//抽象方法，功能在子类中实现

    private String getCakeType() {
        System.out.println("请输入蛋糕类型：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}
public class BJCakeOrder extends CakeOrderByMethod{

    @Override
    public Cake createCake(String cakeType) {
        Cake cake = null;
        if (cakeType.equals(Cake.CREAM_CAKE)) {
            cake = new BJCreamCake();
            cake.setName("北京奶油蛋糕");
        } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
            cake = new BJChocolateCake();
            cake.setName("北京巧克力蛋糕");
        } else {
            System.out.println("你输入的蛋糕类型不存在！！");
        }
        return cake;
    }
}
public class NJCakeOrder extends CakeOrderByMethod{

    @Override
    public Cake createCake(String cakeType) {
        Cake cake = null;
        if (cakeType.equals(Cake.CREAM_CAKE)) {
            cake = new NJCreamCake();
            cake.setName("南京奶油蛋糕");
        } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
            cake = new NJChocolateCake();
            cake.setName("南京巧克力蛋糕");
        } else {
            System.out.println("你输入的蛋糕类型不存在！！");
        }
        return cake;
    }
}
public class CakeStoreByMethod {
    public static void main(String[] args) {
        //工厂方法
        String local = getLocal();
        if (local.equalsIgnoreCase("BJ")) {
            new BJCakeOrder();
        } else if (local.equalsIgnoreCase("NJ")) {
            new NJCakeOrder();
        } else {
            System.out.println("输入的地址有误!");
        }
    }

    private static String getLocal() {
        System.out.println("请输入您的地址：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}

2.3 抽象工厂模式

简介：

抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类

抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

使用抽象工厂模式完成案例2：

public abstract class Cake {
    public static final String CREAM_CAKE = "cream";
    public static final String CHOCOLATE_CAKE = "choc";
    private String name;

    public abstract void ready();

    public void make() {
        System.out.println(name + " 正在制作~~");
    }

    public void bake() {
        System.out.println(name + " 正在烘培~~");
    }

    public void pack() {
        System.out.println(name + " 正在打包~~");
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class BJChocolateCake extends Cake {

    @Override
    public void ready() {
        System.out.println("准备制作北京巧克力蛋糕的材料~~");
    }
}
public class BJCreamCake extends Cake {

    @Override
    public void ready() {
        System.out.println("准备制作北京奶油蛋糕的材料~~");
    }
}

public class NJChocolateCake extends Cake {
    @Override
    public void ready() {
        System.out.println("准备制作南京奶油蛋糕的材料~~");
    }
}

public class NJCreamCake extends Cake {

    @Override
    public void ready() {
        System.out.println("准备制作南京奶油蛋糕的材料~~");
    }
}
public interface AbsFactory {
    public abstract Cake createCake(String cakeType);
}
public class BJFactory implements AbsFactory {

    @Override
    public Cake createCake(String cakeType) {
        Cake cake = null;
        if (cakeType.equals(Cake.CREAM_CAKE)) {
            cake = new BJCreamCake();
            cake.setName("北京奶油蛋糕");
        } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
            cake = new BJChocolateCake();
            cake.setName("北京巧克力蛋糕");
        } else {
            System.out.println("你输入的蛋糕类型不存在！！");
        }
        return cake;
    }
}
public class NJFactory implements AbsFactory {

    @Override
    public Cake createCake(String cakeType) {
        Cake cake = null;
        if (cakeType.equals(Cake.CREAM_CAKE)) {
            cake = new NJCreamCake();
            cake.setName("南京奶油蛋糕");
        } else if (cakeType.equals(Cake.CHOCOLATE_CAKE)) {
            cake = new NJChocolateCake();
            cake.setName("南京巧克力蛋糕");
        } else {
            System.out.println("你输入的蛋糕类型不存在！！");
        }
        return cake;
    }
}

public class CakeOrderByABS {
    private AbsFactory factory;

    public CakeOrderByABS(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        this.factory = factory;
        Cake cake = null;
        do {
            String cakeType = getCakeType();
            cake = this.factory.createCake(cakeType);
            if (cake != null) {
                System.out.println("下单成功！");
                cake.ready();
                cake.make();
                cake.bake();
                cake.pack();
                System.out.println("骑手正在派送！");
            } else {
                System.out.println("下单失败！");
                break;
            }
        } while (true);
    }

    private String getCakeType() {
        System.out.println("请输入蛋糕类型：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}
public class CakeStoreByABS {
    public static void main(String[] args) {
        //工厂方法
        String local = getLocal();
        if (local.equalsIgnoreCase("BJ")) {
            new CakeOrderByABS(new BJFactory());
        } else if (local.equalsIgnoreCase("NJ")) {
            new CakeOrderByABS(new NJFactory());
        } else {
            System.out.println("输入的地址有误!");
        }
    }

    private static String getLocal() {
        System.out.println("请输入您的地址：");
        Scanner sc = new Scanner(System.in);
        return sc.next();
    }
}

3.总结

  1. 工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
  3. 设计模式的依赖抽象原则
  • 创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。
  • 不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)
  • 不要覆盖基类中已经实现的方法。
心碎de梦魇
关注
专栏目录
Java设计模式笔记之抽象工厂代码示例
08-28
"Java设计模式笔记之抽象工厂代码示例" Java设计模式笔记之抽象工厂代码示例主要介绍了Java设计模式笔记之抽象工厂代码示例，见解独到，代码详细，具有一定参考价值，需要的朋友可以了解下。抽象工厂模式实际上就是...
韩顺平_java设计模式笔记
11-07
Java设计模式是软件开发中的一种最佳实践，它们是为了解决特定场景下的设计问题而发展起来的。23种设计模式被广泛应用于提高代码的可重用性、可读性、可维护性和灵活性。韩顺平老师的Java设计模式课程通过生活中的...
Java 设计模式-抽象工厂模式
精神小牛马
07-31 1041
抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式
Java设计模式 | 抽象工厂模式
但行好事，莫问前程
03-20 1133
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级（种类）的产品。要点+demo！
Java设计模式-工厂模式
热门推荐
Java厂长
08-06 1万+
Java设计模式-工厂模式 什么是工厂模式？ 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 简单编写一个类： 1、简单工厂模式 interface IFruit{ public void eat(); //吃水果 } class Apple implements IFruit{ public voi
java设计模式之抽象工厂模式
J_Newbie的博客
09-07 467
java设计模式之抽象工厂模式
Java设计模式之抽象工厂模式（Abstract Factory）笔记
qq_52231740的博客
09-24 1085
如果您的产品对象可以分为不同的族群，每个族群都有一组相关的产品，例如不同操作系统下的界面元素、不同风格的家具等，抽象工厂模式是一个有用的设计模式。：如果您的应用程序需要支持多个不同的产品族，并且这些产品族之间的切换要求是相对频繁的，抽象工厂模式可以提供一种灵活的方式来支持这种切换。：当您的应用程序需要同时创建多个相关的对象，这些对象通常一起使用，并且具有一定的关联性，抽象工厂模式可以帮助您管理这些对象的创建。：确保创建的产品对象都满足一组共同的接口，创建的对象在整个系统中保持一致性，属于同一产品族。
黑马程序员java设计模式笔记
Vashon的博客
12-11 1746
分类 创建者模式 结构型模式 行为型模式 2 类图 UML 2.1 类图概述 显示了模型的静态结构 2.2 类图表示法 2.2.1 类的表示方式 Demo + age:int + method(args 1):int +:public -:private #:protected 属性完整表示 可见性 名称：类型 方法完整表示： 可见性 名称（参数列表）[:返回类型] 2.2.2 类与类之间关系的表示方式 2.2.2.1 关联关系 1.单向关联 一个顾客有一个地址 2.双向.
设计模式——工厂模式
vincewm的博客
04-29 1907
工厂模式介绍、静态简单工厂模式、工厂方法模式、抽象工厂模式、JDK 源码分析
java设计模式笔记
penanut的博客
04-20 1439
根据黑马程序员的课程资料整理所得，仅用于学习使用，如有侵权，请联系删除。 1，设计模式概述 1.1 软件设计模式的产生背景 "设计模式"最初并不是出现在软件设计中，而是被用于建筑领域的设计中。 1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大（Christopher Alexander）在他的著作《建筑模式语言：城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。 1990年软件工程界开始研讨设
黑马-设计模式-笔记（未完）
一个记录积累的地方
04-25 865
自己的笔记，大佬勿喷
学习笔记：java的23种设计模式总结
m0_63246220的博客
07-10 1386
学习笔记
图解java设计模式_学习笔记_java开发
03-09
这份"图解java设计模式_学习笔记"是针对Java开发者深入理解和应用设计模式的重要资源。在这里，我们将深入探讨Java设计模式的核心概念、分类以及它们在实际开发中的应用。 设计模式分为三大类：创建型、结构型和...
韩顺平_Java设计模式笔记.docx
01-16
Java设计模式内容介绍 ##### 1.1.1 先看几个经典的面试题 - **原型设计模式问题** - **UML类图**：原型模式的核心在于定义了一个`Prototype`接口，该接口声明了一个`clone()`方法用于复制当前对象。实现`...
图解Java设计模式笔记总结word版本.rar
06-29
Java设计模式是软件开发中的重要概念，它是一种在特定情境下解决问题的经验总结，可以提高代码的可重用性、可维护性和灵活性。本资料“图解Java设计模式笔记总结word版本”聚焦于通过图文并茂的方式，深入浅出地解析...
C++设计模式——State状态模式
CoderZZ_2024的博客
09-11 797
状态模式是一种行为型设计模式，状态模式允许对象在内部状态发生切换时改变它自身的行为。状态模式的主要目的是将复杂的状态切换逻辑抽象化为一组离散的状态类，使代码结构更加清晰和易于维护。状态模式将对象的行为封装到不同的状态类中，从而在应用程序的状态发生改变时，会自动切换到对应的状态类。状态模式使得状态的切换被表现为类对象的切换。交通信号灯：交通信号灯有红灯、绿灯等多种状态。每个状态都定义了不同的行驶规则。购物流程：用户在购物流程中有多种状态，例如浏览商品、添加购物车、填写收货地址等。
设计模式应用
m0_64201189的博客
09-09 541
JDK Proxy、CGLIB 动态代理。JDK 动态代理基于接口实现，CGLIB代理通过继承目标类来实现。Spring中的Bean默认是单例的，方便不同组件共享一个对象。约定了模板，用户通过实现接口来制定具体的功能。SpringAOP 日志、事务、监控。
设计模式】Listener模式和Visitor模式的区别
最新发布
tr6666的博客
09-11 1178
在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详细解释这两种模式，并通过Java和Go语言的代码示例展示它们的实现，最后总结它们的区别和适用场景。Listener模式（监听器模式）是一种行为设计模式，主要用于事件驱动的编程。它允许一个对象（监听器）注册到另一个对象（事件源），以便在特定事件发生时接收通知。
结构者设计模式
m0_68570169的博客
09-10 1236
结构者模式帮助我们以不同的方式组织和构建系统中的类和对象，从而提高系统的灵活性和可维护性。通过合理选择和应用这些模式，可以有效地管理和扩展系统的复杂性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值