栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

设计模式 ② 23种设计模式

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

设计模式 ② 23种设计模式

目录
  • 前言
  • 一、设计模式介绍
  • 二、设计模式有 23 种
  • 三、单例模式
    • (1) 单例模式有 8 种
    • (2) 饿汉式(静态常量)
    • (3) 饿汉式(静态代码块)
    • (4) 懒汉式(线程不安全)
    • (5) 懒汉式(线程安全 - 同步方法)
    • (6) 懒汉式(线程安全 - 同步代码块)
    • (7) 双重检查(推荐使用)
    • (8) 静态内部类【极度推荐】
    • (9) 枚举【推荐使用】
    • (10) JDK 中 的 Runtime 类就是单例模式
    • (11) 单例模式使用在...
  • 四、简单工厂设计模式
    • (1) 项目介绍
    • (2) 传统方式
    • (3) 使用简单工厂模式
  • 五、工厂方法模式
  • 六、抽象工厂模式
  • 七、原型模式

前言

每一种设计模式都是基于七大设计原则而存在的。需掌握设计模式七大原则(迪米特法则、里氏替换原则原则、依赖倒置原则、开闭原则、接口隔离原则、单一职责原则、合成复用原则)后再看下面的内容。

一、设计模式介绍

① 软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
② 设计模式的本质提高软件的维护性,通用性和扩展性,并降低软件的复杂度。
③ 1994 年,Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 四人合著出版了一本名为 Design Patterns - Elements of Reusable Object-Oriented Software(中文译名:设计模式 - 可复用的面向对象软件元素) 的书。该书首次提到了软件开发中的设计模式的概念。


④ 设计模式并不局限于某种语言。Java、php、Python、C++ 等各种编程语言都有设计模式的概念。

二、设计模式有 23 种


上图分类罗列了设计模式的类型和 23 种设计模式的名称。为了板式好看,有些设计模式是横着排版的。

三、单例模式

作用:实现在整个软件系统运行过程中,某个类始终永远只能存在一个对象实例。
Demo:
① SqlSessionFactory 是一个可以从中获得 SqlSession 的实例的工厂类。从 SqlSessionFactory 中获取的 SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。SqlSessionFactory 在整个应用运行期间应该一直存在。下图是 MyBatis 官方文档对 SqlSessionFactory 的描述。

② Hibernate 框架的 SessionFactory 充当数据存储源的代理,并负责创建 Session 对象。SessionFactory 并不是轻量级的,一个项目只需要一个 SessionFactory。此时就可使用单例模式。

(1) 单例模式有 8 种

① 饿汉式(静态常量)
② 饿汉式(静态代码块)
③ 懒汉式(线程不安全)
④ 懒汉式(线程安全,同步方法)
⑤ 懒汉式(线程安全,同步代码块)
⑥ 双重检查
⑦ 静态内部类
⑧ 枚举

(2) 饿汉式(静态常量)
public class Singleton01 {
    // 所谓饿汉式,Singleton01 一被加载 Singleton01 实例就被创建(有点饥渴)
    private static final Singleton01 INSTANCE = new Singleton01();

    // 构造方法私有化
    private Singleton01() {

    }

    
    public static Singleton01 getInstance() {
        return INSTANCE;
    }
}

总结:① 构造方法私有化(单例模式的作用是:让某个类的实例在整个应用运行过程中永远只有一个。因此不能提供公共的构造方法来实例化对象)
② 在类的内部创建(new)唯一的该类的实例
③ 向外提供一个静态的公共的方法返回该类唯一的实例

所谓饿汉式,就是该类比较饥渴、比较饿。只要 Singleton01 被加载,它的实例就被创建。

饿汉式(静态常量)单例模式的优缺点:
① 优点: 类装载,唯一的对象实例就被创建。避免了线程同步问题。
② 缺点:在类装载的时候就完成实例化,没有实现懒加载(Lazy Load)。如果从始至终从未使用过该实例,则会造成内存浪费。

解释:该方式基于类加载(ClassLoader)机制避免了多线程的同步问题。但 INSTANCE 在类装载时就实例化可能造成内存浪费。在单例模式中,一般是调用 getInstance 方法导致类装载,进而创建唯一的对象实例。但导致类装载的方式不止一种,因此不能确定是否有其他的方式导致类装载。如果有,会导致内存方法。

触发类加载的方式:
① 调用静态成员时(静态常量、静态方法)
② 第一次 new 对象的时候
③ 子类加载会导致父类先被加载

(3) 饿汉式(静态代码块)
public class Singleton02 {
    private static Singleton02 instance;

    static { // 在静态代码块中实例化 Singleton02 对象
        instance = new Singleton02();
    }

    // 构造方法私有化
    private Singleton02() {
    }

    
    public static Singleton02 getInstance() {
        return instance;
    }
}

说明:该方式和静态常量饿汉式类似。区别是:将类实例化的过程放在了静态代码块中。由于也是在类装载的时候执行静态代码块中的代码,进行实例的创建。所以,可避免线程同步问题(优点),可能造成内存浪费(缺点)。

(4) 懒汉式(线程不安全)
public class LazySingleton01 {
    private static LazySingleton01 instance;

    private LazySingleton01() {

    }

    
    public static LazySingleton01 getInstance() {
        if (instance == null) {
            instance = new LazySingleton01();
        }
        return instance;
    }
}

优缺点:
① 优点:相比饿汉式,该方式有懒加载(Lazy Load)的效果,可以避免内存浪费。
② 缺点:可能有线程安全问题。如果在多线程环境下,一个线程进入了 if (instance== null) 判断语句,且还未来得及往下执行。此时另一个线程也进入了 if (instance== null) 判断语句,次时便会产生多个实例,因此也就没有实现单例模式的功能了。

结论:该写法在多线程环境下不可使用,开发中也不这样写。

(5) 懒汉式(线程安全 - 同步方法)
public class LazySingleton02 {
    private static LazySingleton02 instance;

    private LazySingleton02() {

    }

    
    public static synchronized LazySingleton02 getInstance() {
        if (instance == null) {
            instance = new LazySingleton02();
        }
        return instance;
    }
}

优缺点:
① 线程安全、和饿汉式比不浪费内存(优点)
② 同步方法效率太低。 每个线程需要获得类实例的时候都得执行 getInstance() 方法,都要执行线程同步操作。线程同步操作(有 synchronized 效率是会降低的)。实际上,实例化对象的代码只需要执行一次即可,之后若想获得该类实例直接 return 即可。

(6) 懒汉式(线程安全 - 同步代码块)

该方式并未解决线程同步问题。

public class LazySingleton03 {
    private static LazySingleton03 instance;

    private LazySingleton03() {

    }

    
    public static LazySingleton03 getInstance() {
        if (instance == null) {
            // 同步代码块
            synchronized (LazySingleton03.class) {
                instance = new LazySingleton03();
            }
        }
        return instance;
    }
}

【说明】该方式本来是想对【懒汉式(线程安全 - 同步方法)】的代码进行改进,提高其效率。但该写法并不能起到线程同步的作用。假如一个线程进入了 if (instance== null) 判断语句,还未来得及往下执行。此时,另一个线程也进行了 if (instance== null) 判断语句,此时便会产生多个实例(哪就不是单例模式了)

(7) 双重检查(推荐使用)

volatile 是 Java 提供的一种轻量级的同步机制。
当多个线程同时访问同一个变量时,若某个线程修改了该变量的值,其他线程能够立即看到该变量被修改的值。

在多线程环境下,某个线程对共享变量的操作(修改)对其他线程是不可见的。Java 提供了 volatile 关键字来保证可见性(当一个变量被 volatile 修饰后,表示线程本地内存无效。当一个线程修改共享变量后,共享变量的值会被立即更新到主内存中。其他线程读取共享变量时,会直接从主内存读取。)

public class DoubleCheckSingleton {
    // volatile:假如某个线程修改了 instance 的值,其他线程能够立刻知道
    private static volatile DoubleCheckSingleton instance;

    private DoubleCheckSingleton() {

    }

    public static DoubleCheckSingleton getInstance() {
        if (instance == null) { // 第一层检查
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) { // 第二层检查
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

【优点】
① 线程安全
② 懒加载
③ 实例化代码只执行一次,之后再调用 getInstance 方法的时候,依然会判断 instance 是否为 null。如果不为 null,直接 return 即可
④ 避免反复进行线程同步操作

实际开发和编程中,推荐双重检查的方式实现单例模式。

(8) 静态内部类【极度推荐】
public class Test {
    
    private static class StaticInner {
        private static String name = "顾清兒";
    }

    public static String getName() {
        return StaticInner.name;
    }
}

静态内部类特点:以上面的代码为例。① 当 Test 类被装载的时候,StaticInner 类不会被装载。
② 调用 Test 类的 getName 方法(getName 内部使用 StaticInner 静态内部类)会导致 StaticInner 类被装载(只装载一次),类被装载的时候线程是安全的。

下面代码的作用:证明静态内部类的特点

public class Test {
    // 当 Test 类被装载的时候,静态代码块的代码会被执行
    static {
        System.out.println("Test - 静态代码块");
    }

    
    static class StaticInner {
        static String name = "顾清兒";

        static { // 当 StaticInner 被加载的时候,静态代码块的代码会被执行
            System.out.println("StaticInner - 静态代码块");
        }
    }

    public static void getName() {
        // 使用 StaticInner 里面的 静态属性会导致 StaticInner 类的装载
        String goodName = StaticInner.name;
    }
}

使用静态内部类的特点编写单例模式。

public class SingletonStaticInner {
    private SingletonStaticInner() {

    }

    
    private static class StaticInnerClass {
        private static final SingletonStaticInner INSTANCE =
                new SingletonStaticInner();
    }

    public static SingletonStaticInner getInstance() {
        return StaticInnerClass.INSTANCE;
    }
}

【说明】
① 该方式通过类装载机制保证初始化实例时只有一个线程。
② 静态内部类在 SingletonStaticInner 类被装载时不会被装载(静态内部类里面的代码不会执行)
③ 当调用 SingletonStaticInner 类里面的 getInstance 方法后,getInstance 方法内部会使用到静态内部类 StaticInnerClass 里面的静态属性。使用静态内部类里面的静态属性会导致静态内部类的装载,进而导致静态内部类里面的代码被执行,以至于 SingletonStaticInner 被实例化,并赋值给了 INSTANCE 。
④ 类的静态属性只会在第一次装载类的时候初始化(效率高)。此处巧妙地利用 JVM 保证了线程安全,类装载的时候别的线程是无法进入的。

优点:避免线程不安全;利用静态内部类的特点实现延迟加载、避免内存浪费【推荐使用】

(9) 枚举【推荐使用】
public enum SingletonEnum {
    INSTANCE; // 默认就是单例的

    public void getInstance() {
        System.out.println(INSTANCE.hashCode());
    }
}

【说明】
① 在此借助 JDK1.5 中添加的枚举类型来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象的情况。
② Effective Java (书名,见下图)的作者 Josh Bloch 提倡该方式实现单例模式。



(10) JDK 中 的 Runtime 类就是单例模式



(11) 单例模式使用在…

① 被设计为单例模式的类的对象在整个应用运行过程中只有一个实例,节省了系统资源。对于一些需要频繁创建和销毁的对象,使用单例模式可以提高性能
② 单例模式使用的场景:
若对象需要被频繁地创建和销毁;
若创建某个对象时需要耗费很多时间和资源(重量级对象),但该对象又经常被使用到;
工具类对象;
频繁访问数据库或文件的对象(eg:数据源、session 工厂等)。

四、简单工厂设计模式 (1) 项目介绍

通过一个简单的项目引出简单工厂模式。
编写代码实现【奶茶店项目】功能。


(2) 传统方式

【项目 UML 类图】

【项目代码】

public abstract class MilkTeaAbstract {
    private String name = setMilkyTeaName();

    public String getName() {
        return name;
    }

    
    abstract String setMilkyTeaName();

    
    abstract void prepareMaterial();

    
    abstract void make();

    
    abstract void box();
}
public class AppleMilkTea extends MilkTeaAbstract {
    @Override
    String setMilkyTeaName() {
        return "苹果奶茶";
    }

    @Override
    void prepareMaterial() {
        System.out.println("prepare material for 【APPLE】 milk tea");
    }

    @Override
    void make() {
        System.out.println("make 【APPLE】 milk tea");
    }

    @Override
    void box() {
        System.out.println("box 【APPLE】 milk tea");
    }
}
public class IcedMilkTea extends MilkTeaAbstract {
    @Override
    String setMilkyTeaName() {
        return "冰冰奶茶";
    }

    @Override
    void prepareMaterial() {
        System.out.println("prepare material for 【iced】 milk tea");
    }

    @Override
    void make() {
        System.out.println("make 【iced】 milk tea");
    }

    @Override
    void box() {
        System.out.println("box 【iced】 milk tea");
    }
}
public class PearlMilkTea extends MilkTeaAbstract {
    @Override
    String setMilkyTeaName() {
        return "珍珠奶茶";
    }

    @Override
    void prepareMaterial() {
        System.out.println("prepare material for 【pearl】 milk tea");
    }

    @Override
    void make() {
        System.out.println("make 【pearl】 milk tea");
    }

    @Override
    void box() {
        System.out.println("box 【pearl】 milk tea");
    }
}
public class OrderMilkTea {
    private String[] milkTeaTypes;

    public OrderMilkTea(String[] milkTeaTypes) {
        this.milkTeaTypes = milkTeaTypes;
    }

    
    public void order() {
        boolean noExit = true;
        showMilkTeaList();
        do {
            String milkTeaName = getMilkTeaName();
            if (milkTeaName.equals("000")) {
                noExit = false;
            }
            boolean existMilkTea = checkExist(milkTeaName);
            if (!existMilkTea && !milkTeaName.equals("000")) {
                System.out.println("不存在这种奶茶!!!");
                System.out.println("不想买了?输入【000】");
            } else if (existMilkTea) {
                handleOrderByMilkTeaName(milkTeaName);
                System.out.println("不想买了?输入【000】");
            } else {
                System.out.println("欢迎再次光临!");
            }
        } while (noExit);
    }

    
    private void handleOrderByMilkTeaName(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "珍珠奶茶":
                milkTeaAbstract = new PearlMilkTea();
                break;
            case "冰冰奶茶":
                milkTeaAbstract = new IcedMilkTea();
                break;
            case "苹果奶茶":
                milkTeaAbstract = new AppleMilkTea();
                break;
        }
        assert milkTeaAbstract != null;
        System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
        System.out.println("---------------------");
        milkTeaAbstract.prepareMaterial();
        milkTeaAbstract.make();
        milkTeaAbstract.box();
        System.out.println("给您!请慢用 ❀");
        System.out.println("---------------------");
    }

    
    private boolean checkExist(String name) {
        for (String n : milkTeaTypes) {
            if (n.equals(name)) {
                return true;
            }
        }
        return false;
    }

    
    private String getMilkTeaName() {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader reader = new BufferedReader(isr);
            System.out.println("input milk tea name:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    
    private void showMilkTeaList() {
        System.out.println("本店现有如下奶茶可供销售");
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
        for (String type : milkTeaTypes) {
            System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
        }
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
    }
}
public class GQEMilkTeaStore {
    private static String[] types = new String[]{"苹果奶茶", "珍珠奶茶", "冰冰奶茶"};
    private static OrderMilkTea orderMilkTea = new OrderMilkTea(types);

    public static void main(String[] args) {
        System.out.println("【❀ 顾清兒的奶茶店 ❀】");
        orderMilkTea.order();
    }
}

【实现截图】




【传统出现的问题分析】
① 这种实现方式违反了设计原则中的 OCP 原则,既开闭原则(对扩展开放,对修改关闭)。
② 若需要给项目扩展新功能,通过增加代码(模块、类)的方式进行扩展,不要修改原有的代码。
在上面的项目中,若想增加一个新的奶茶类型 —— “花儿奶茶”,则需要做如下的改变。



【改进思路分析】把创建 MilkTea 对象的代码封装到一个类中。优点:当有新的 MilkTea 种类时,只需要修改这个类即可(降低耦合)。

(3) 使用简单工厂模式
public class OrderMilkTea {
    private String[] milkTeaTypes;

    public OrderMilkTea(String[] milkTeaTypes) {
        this.milkTeaTypes = milkTeaTypes;
    }

    
    public void order() {
        boolean noExit = true;
        showMilkTeaList();
        do {
            String milkTeaName = getMilkTeaName();
            if (milkTeaName.equals("000")) {
                noExit = false;
            }
            boolean existMilkTea = checkExist(milkTeaName);
            if (!existMilkTea && !milkTeaName.equals("000")) {
                System.out.println("不存在这种奶茶!!!");
                System.out.println("不想买了?输入【000】");
            } else if (existMilkTea) {
                handleOrderByMilkTeaName(milkTeaName);
                System.out.println("不想买了?输入【000】");
            } else {
                System.out.println("欢迎再次光临!");
            }
        } while (noExit);
    }

    
    private void handleOrderByMilkTeaName(String milkTeaName) {
        // 调用 ”创建奶茶的工厂类“ 创建奶茶
        MilkTeaAbstract milkTeaAbstract = MilkTeaFactory.create(milkTeaName);
        if (milkTeaAbstract == null) {
            System.out.println("没有该奶茶");
            return;
        }
        System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
        System.out.println("---------------------");
        milkTeaAbstract.prepareMaterial();
        milkTeaAbstract.make();
        milkTeaAbstract.box();
        System.out.println("给您!请慢用 ❀");
        System.out.println("---------------------");
    }

    
    private boolean checkExist(String name) {
        for (String n : milkTeaTypes) {
            if (n.equals(name)) {
                return true;
            }
        }
        return false;
    }

    
    private String getMilkTeaName() {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader reader = new BufferedReader(isr);
            System.out.println("input milk tea name:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    
    private void showMilkTeaList() {
        System.out.println("本店现有如下奶茶可供销售");
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
        for (String type : milkTeaTypes) {
            System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
        }
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
    }
}
public class MilkTeaFactory {
    public static MilkTeaAbstract create(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "珍珠奶茶":
                milkTeaAbstract = new PearlMilkTea();
                break;
            case "冰冰奶茶":
                milkTeaAbstract = new IcedMilkTea();
                break;
            case "苹果奶茶":
                milkTeaAbstract = new AppleMilkTea();
                break;
            case "花儿奶茶":
                milkTeaAbstract = new FlowerMilkTea();
                break;
            case "西瓜奶茶":
                milkTeaAbstract = new WatermelonMilkTea();
                break;
        }
        return milkTeaAbstract;
    }
}


【简单工厂模式介绍】
① 简单工厂模式(静态工厂模式)属于创建型模式,是工厂模式的一种。
② 由一个工厂对象决定创建出哪一种类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
③ 定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)。
④ 软件开发中,当需要大量地创建某种、某类或者某批对象时,就会使用到工厂模式。

五、工厂方法模式

需求:客户在购买奶茶的时候可以选择地区(如韩国的珍珠奶茶,韩国的苹果奶茶,日本的珍珠奶茶,日本的苹果奶茶…)

public abstract class MilkTeaAbstract {
    private String name = setMilkyTeaName();

    public String getName() {
        return name;
    }

    
    public abstract String setMilkyTeaName();

    
    public abstract void prepareMaterial();

    
    public abstract void make();

    
    public abstract void box();
}
public class KoreaPearlMilkTea extends MilkTeaAbstract {
    @Override
    public String setMilkyTeaName() {
        return "韩国珍珠奶茶";
    }

    @Override
    public void prepareMaterial() {
        System.out.println("prepare material for 【KoreaPearl】 milk tea");
    }

    @Override
    public void make() {
        System.out.println("make 【KoreaPearl】 milk tea");
    }

    @Override
    public void box() {
        System.out.println("box 【KoreaPearl】 milk tea");
    }
}
public class KoreaAppleMilkTea extends MilkTeaAbstract {
    @Override
    public String setMilkyTeaName() {
        return "韩国珍苹果奶茶";
    }

    @Override
    public void prepareMaterial() {
        System.out.println("prepare material for 【KoreaApple】 milk tea");
    }

    @Override
    public void make() {
        System.out.println("make 【KoreaApple】 milk tea");
    }

    @Override
    public void box() {
        System.out.println("box 【KoreaApple】 milk tea");
    }
}
public class JapanPearlMilkTea extends MilkTeaAbstract {
    @Override
    public String setMilkyTeaName() {
        return "日本珍珠奶茶";
    }

    @Override
    public void prepareMaterial() {
        System.out.println("prepare material for 【JapanPearl】 milk tea");
    }

    @Override
    public void make() {
        System.out.println("make 【JapanPearl】 milk tea");
    }

    @Override
    public void box() {
        System.out.println("box 【JapanPearl】 milk tea");
    }
}
public class JapanAppleMilkTea extends MilkTeaAbstract {
    @Override
    public String setMilkyTeaName() {
        return "日本苹果奶茶";
    }

    @Override
    public void prepareMaterial() {
        System.out.println("prepare material for 【JapanApple】 milk tea");
    }

    @Override
    public void make() {
        System.out.println("make 【JapanApple】 milk tea");
    }

    @Override
    public void box() {
        System.out.println("box 【JapanApple】 milk tea");
    }
}
public abstract class OrderMilkTea {
    private String[] milkTeaTypes;

    public OrderMilkTea(String[] milkTeaTypes) {
        this.milkTeaTypes = milkTeaTypes;
    }

    public abstract MilkTeaAbstract createMilkTea(String milkTeaName);

    
    public void order() {
        boolean noExit = true;
        showMilkTeaList();
        do {
            String milkTeaName = getMilkTeaName();
            if (milkTeaName.equals("000")) {
                noExit = false;
            }
            boolean existMilkTea = checkExist(milkTeaName);
            if (!existMilkTea && !milkTeaName.equals("000")) {
                System.out.println("不存在这种奶茶哦!!!");
                System.out.println("不想买了?输入【000】");
            } else if (existMilkTea) {
                handleOrderByMilkTeaName(milkTeaName);
                System.out.println("不想买了?输入【000】");
            } else {
                System.out.println("欢迎再次光临!");
            }
        } while (noExit);
    }

    
    private void handleOrderByMilkTeaName(String milkTeaName) {
        // 调用 ”创建奶茶的工厂类“ 创建奶茶
        MilkTeaAbstract milkTeaAbstract = createMilkTea(milkTeaName);
        if (milkTeaAbstract == null) {
            System.out.println("没有该奶茶");
            return;
        }
        System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
        System.out.println("---------------------");
        milkTeaAbstract.prepareMaterial();
        milkTeaAbstract.make();
        milkTeaAbstract.box();
        System.out.println("给您!请慢用 ❀");
        System.out.println("---------------------");
    }

    
    private boolean checkExist(String name) {
        for (String n : milkTeaTypes) {
            if (n.equals(name)) {
                return true;
            }
        }
        return false;
    }

    
    private String getMilkTeaName() {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader reader = new BufferedReader(isr);
            System.out.println("input milk tea name:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    
    private void showMilkTeaList() {
        System.out.println("本店现有如下奶茶可供销售");
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
        for (String type : milkTeaTypes) {
            System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
        }
        System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
    }
}
public class KoreaOrderMilkTea extends OrderMilkTea {
    public KoreaOrderMilkTea(String[] milkTeaTypes) {
        super(milkTeaTypes);
    }

    @Override
    public MilkTeaAbstract createMilkTea(String milkTeaName) {
        return KoreaMilkTeaFactory.create(milkTeaName);
    }
}
public class KoreaMilkTeaFactory {
    public static MilkTeaAbstract create(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "韩国珍珠奶茶":
                milkTeaAbstract = new KoreaPearlMilkTea();
                break;
            case "韩国苹果奶茶":
                milkTeaAbstract = new KoreaAppleMilkTea();
                break;
        }
        return milkTeaAbstract;
    }
}
public class JapanMilkTeaFactory {
    public static MilkTeaAbstract create(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "日本珍珠奶茶":
                milkTeaAbstract = new JapanPearlMilkTea();
                break;
            case "日本苹果奶茶":
                milkTeaAbstract = new JapanAppleMilkTea();
                break;
        }
        return milkTeaAbstract;
    }
}
public class JapanOrderMilkTea extends OrderMilkTea {
    public JapanOrderMilkTea(String[] milkTeaTypes) {
        super(milkTeaTypes);
    }

    @Override
    public MilkTeaAbstract createMilkTea(String milkTeaName) {
        return JapanMilkTeaFactory.create(milkTeaName);
    }
}
public class GqMilkTeaStore {
    public static void main(String[] args) {
        String inputStr = getInputStr();
        if (inputStr.equals("日本")) {
            JapanOrderMilkTea order =
                    new JapanOrderMilkTea(new String[]{"日本珍珠奶茶", "日本苹果奶茶"});
            order.order();
        } else if (inputStr.equals("韩国")) {
            KoreaOrderMilkTea order2 =
                    new KoreaOrderMilkTea(new String[]{"韩国珍珠奶茶", "韩国苹果奶茶"});
            order2.order();
        }
    }

    public static String getInputStr() {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader reader = new BufferedReader(isr);
            System.out.println("input region:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

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

六、抽象工厂模式

定义一个 interface 用于创建相关或有依赖关系的对象簇,而无需指明具体的类。抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。将工厂抽象成两层,AbstractFactory(抽象工厂) 和具体实现的工厂子类。设计师可以根据创建的对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。

public interface AbstractFactory {
      MilkTeaAbstract create(String name);
}
public class JapanMilkTeaFactory implements AbstractFactory {
    public MilkTeaAbstract create(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "日本珍珠奶茶":
                milkTeaAbstract = new JapanPearlMilkTea();
                break;
            case "日本苹果奶茶":
                milkTeaAbstract = new JapanAppleMilkTea();
                break;
        }
        return milkTeaAbstract;
    }
}
public class KoreaMilkTeaFactory implements AbstractFactory {
    public MilkTeaAbstract create(String milkTeaName) {
        MilkTeaAbstract milkTeaAbstract = null;
        switch (milkTeaName) {
            case "韩国珍珠奶茶":
                milkTeaAbstract = new KoreaPearlMilkTea();
                break;
            case "韩国苹果奶茶":
                milkTeaAbstract = new KoreaAppleMilkTea();
                break;
        }
        return milkTeaAbstract;
    }
}

工厂设计模式:用于生产对象。

七、原型模式
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936098.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号