认识设计模式（四）---工厂模式

fixAllenSun

已于 2023-02-12 14:33:51 修改

阅读量201

点赞数

分类专栏：学习设计模式文章标签： java 设计模式 spring 编程语言

于 2020-03-12 23:43:44 首次发布

本文链接：https://blog.csdn.net/weixin_44823875/article/details/104831468

版权

学习设计模式专栏收录该内容

20 篇文章 0 订阅

订阅专栏

（一）工厂模式

（1）具体需求

看一个披萨的项目，要便于披萨种类的扩展，要便于维护（当需要添加新的披萨种类时，要尽量少改动代码）

披萨的种类
披萨的制作步骤（prepare，bake，cut，box）
完成披萨店的订购功能

（二）传统方式

（1）思路分析

创建一个Pizza父类抽象类，包含prepare，bake，cut，box等方法
实现各个种类的披萨子类，实现上述方法

（2）代码示例

（1）Pizza父类

abstract class Pizza{
    //披萨的名字
    protected String name;

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

    //不同种类的披萨，有不同的准备的方式，所以写成抽象方法，不同种类的披萨有不同的实现方法
    public abstract void prepare();

    //所有披萨都是放在烤箱里，所以直接实现
    public void bake(){
        System.out.println(name+"baking");
    }
    public void cut(){
        System.out.println(name+"cutting");
    }
    public void box(){
        System.out.println(name+"boxing");
    }

}

（2）子类CheesePizza

class CheesePizza extends Pizza{

    @Override
    public void prepare() {
        System.out.println("给制作起司披萨准备材料");
    }
}

（3）子类GreekPizza

class GreekPizza extends Pizza{

    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨准备材料");
    }
}

（4）披萨订购类OrderPizza

public class OrderPizza {
    //构造器
    //构造器，在简单工厂模式里，把这一块的内容封装起来，放到SimpleFactory里去
    public OrderPizza(){
        Pizza pizza=null;
        String orderType;//订购披萨的类型
        do {
            orderType=getType();
            if(orderType.equals("greek")){
                pizza=new GreekPizza();
                pizza.setName("希腊");
            } else if(orderType.equals("cheese")){
                pizza=new CheesePizza();
                pizza.setName("起司");
            } else {
                break;
            }

            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            System.out.println("您点的"+pizza.name+"披萨已经做好了，请慢用");

        } while (true);
    }

（5）测试类PizzaStore

public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

（3）传统方式优缺点分析

优点：好理解，容易操作
缺点：违反了OCP原则，对扩展开放，对修改关闭。当我们给类增加新功能时，要做到尽量不修改代码
改进思路：把创建Pizza对象封装到一个类中，这样当我们新增披萨种类时，只需要修改该类即可，其他创建到Pizza对象的代码就不需要修改了（即简单工厂模式）

（三）简单工厂模式

（1）基本介绍

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，是工厂模式中最简单使用的模式
简单工厂模式，定义了一个创建对象的类，让这个类来封装实例化对象的行为
当我们用到大量的创建某类或者某批对象的时候，就会使用到工厂模式（如Spring框架）

（2）代码示例

（1）Pizza父类

abstract class Pizza02{
    //披萨的名字
    protected String name;

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

    //不同种类的披萨，有不同的准备的方式，所以写成抽象方法，不同种类的披萨有不同的实现方法
    public abstract void prepare();

    //所有披萨都是放在烤箱里，所以直接实现
    public void bake(){
        System.out.println(name+"baking");
    }
    public void cut(){
        System.out.println(name+"cutting");
    }
    public void box(){
        System.out.println(name+"boxing");
    }

}

（2）子类CheesePizza

class CheesePizza02 extends Pizza02 {

    @Override
    public void prepare() {
        System.out.println("给制作起司披萨准备材料");
    }
}

（3）子类GreekPizza

class GreekPizza02 extends Pizza02 {

    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨准备材料");
    }
}

（4）简单工厂类SimpleFactory（封装创建对象）

创建createPizza方法，参数是orderType订单披萨种类
方法中Pizza02 父类创建对象，但是不急着实例化，等等根据orderType再实例化
这样就做到了根据订单种类来点披萨，并且整个创建对象的过程被封装起来了

//简单工厂类，也叫静态工厂类
//定义一个可以实例化Pizza对象的类，封装创建对象的代码
class SimpleFactory{
    //根据orderType，返回对应的Pizza对象
    //补充：写成static静态方法
    public Pizza02 createPizza(String orderType){
        Pizza02 pizza02=null;
        System.out.println("使用简单工厂模式");
        if(orderType.equals("greek")){
            pizza02=new GreekPizza02();
            pizza02.setName("希腊");
        } else if(orderType.equals("cheese")){
            pizza02=new CheesePizza02();
            pizza02.setName("起司");
        }
        return pizza02;
    }
}

（5）订购披萨类

public class OrderPizza02 {
    //构造器，在简单工厂模式里，把这一块的内容封装起来，放到SimpleFactory里去

    SimpleFactory simpleFactory;
    Pizza02 pizza02=null;

    public OrderPizza02(SimpleFactory simpleFactory){
        setSimpleFactory(simpleFactory);
    }

    public void setSimpleFactory(SimpleFactory simpleFactory){
        String orderType="";//用户来输入披萨的种类
        this.simpleFactory=simpleFactory;
        do {
            orderType=getType();
            pizza02=this.simpleFactory.createPizza(orderType);//调用create方法创建对象
            if(pizza02!=null){
                pizza02.prepare();
                pizza02.bake();
                pizza02.cut();
                pizza02.box();
            } else {
                System.out.println("没有该类披萨，订购失败");
            }
        } while (true);
    }

    //写一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入披萨的种类：");
            String str=strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

（6）测试类

public class PizzaStore02 {
    public static void main(String[] args) {
        OrderPizza02 orderPizza02 = new OrderPizza02(new SimpleFactory());
        System.out.println("退出程序");
    }
}

（3）简单工厂模式UML图

在这里插入图片描述

（四）工厂方法模式

补充功能：

客户在点披萨时，可以点不同口味的披萨，比如”北京的奶酪披萨，北京的起司披萨，伦敦的奶酪披萨“

（1）思路分析

使用工厂方法模式
把披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现
定义了一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式把对象的实例化推迟到了子类

（2）代码示例

（1）Pizza父类

abstract class Pizza03{
    //披萨的名字
    protected String name;

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

    //不同种类的披萨，有不同的准备的方式，所以写成抽象方法，不同种类的披萨有不同的实现方法
    public abstract void prepare();

    //所有披萨都是放在烤箱里，所以直接实现
    public void bake(){
        System.out.println(name+"baking");
    }
    public void cut(){
        System.out.println(name+"cutting");
    }
    public void box(){
        System.out.println(name+"boxing");
    }
}

（2）创建多个子类，代表不同种类的披萨

class BJCheesePizza extends Pizza03{
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("给北京奶酪披萨准备材料");
    }
}

class BJPepperPizza extends Pizza03{
    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("给北京胡椒披萨准备材料");
    }
}

class LDCheesePizza extends Pizza03{
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("给伦敦奶酪披萨准备材料");
    }
}

class LDPepperPizza extends Pizza03{
    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("给伦敦胡椒披萨准备材料");
    }
}

（3）创建订购披萨类父类

父类构造器内，先创建对象，这里不是使用new实例化对象，而是调用createPizza方法来实例化对象。就是把实例化对象这一块封装起来了
在父类中createPizza只是一个抽象方法，具体的实现交给子类

public abstract class OrderPizza03 {

    //构造器，在简单工厂模式里，把这一块的内容封装起来，放到SimpleFactory里去
    public OrderPizza03(){
        Pizza03 pizza03=null;
        String orderType;//订购披萨的类型
        do {
            orderType=getType();
            pizza03=createPizza(orderType);

            pizza03.prepare();
            pizza03.bake();
            pizza03.cut();
            pizza03.box();
            System.out.println("您点的"+pizza03.name+"披萨已经做好了，请慢用");

        } while (true);
    }

    //定义一个抽象方法，具体的实现交给工厂子类去实现
    abstract Pizza03 createPizza(String orderType);
    
    //写一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入披萨的种类：");
            String str=strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

（4）创建不同的订购披萨类（对象的创建实例化在这里实现）

class LDOrderPizza extends OrderPizza03{

    @Override
    Pizza03 createPizza(String orderType) {
        Pizza03 pizza03=null;
        if(orderType.equals("cheese")){
            pizza03=new LDCheesePizza();
        } else if(orderType.equals("pepper")){
            pizza03=new LDPepperPizza();
        }
        return pizza03;
    }
}

class BJOrderPizza extends OrderPizza03{

    @Override
    Pizza03 createPizza(String orderType) {
        Pizza03 pizza03=null;
        if(orderType.equals("cheese")){
            pizza03=new BJCheesePizza();
        } else if(orderType.equals("pepper")){
            pizza03=new BJPepperPizza();
        }
        return pizza03;
    }
}

（5）测试类

public class PizzaStore03 {
    public static void main(String[] args) {
        new BJOrderPizza();
    }
}

（3）UML图

在这里插入图片描述

（4）工厂模式的补充说明和使用场景

【介绍】
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

【意图】
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

【主要解决】
主要解决接口选择的问题。

【何时使用】
我们明确地计划不同条件下创建不同实例时。

【如何解决】
让其子类实现工厂接口，返回的也是一个抽象的产品。

【关键代码】
创建过程在其子类执行。

【应用实例】
1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
2、Hibernate 换数据库只需换方言和驱动就可以。

【优点】
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。

【缺点】
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

【使用场景】
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。

【注意事项】
作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

（五）抽象工厂模式

（1）基本介绍

抽象工厂模式，定一个Interface，用来创建相关的对象簇，且不需要指明具体的类
抽象工厂模式可以把简单工厂模式和工厂方法模式进行整合
从设计层面看，抽象工厂模式是对简单工厂的改进（进一步的抽象）
把工厂抽象成两层，ABSFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据常见对象类型使用对应的工厂子类，这样把单个的简单工厂变成工厂簇，更利于代码的维护和扩展

（2）代码示例

（1）Pizza父类

abstract class Pizza04{
    //披萨的名字
    protected String name;

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

    //不同种类的披萨，有不同的准备的方式，所以写成抽象方法，不同种类的披萨有不同的实现方法
    public abstract void prepare();

    //所有披萨都是放在烤箱里，所以直接实现
    public void bake(){
        System.out.println(name+"baking");
    }
    public void cut(){
        System.out.println(name+"cutting");
    }
    public void box(){
        System.out.println(name+"boxing");
    }
}

（2）披萨子类

class BJCheesePizza extends Pizza04 {
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("给北京奶酪披萨准备材料");
    }
}

class BJPepperPizza extends Pizza04 {
    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("给北京胡椒披萨准备材料");
    }
}

class LDCheesePizza extends Pizza04 {
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("给伦敦奶酪披萨准备材料");
    }
}

class LDPepperPizza extends Pizza04 {
    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("给伦敦胡椒披萨准备材料");
    }
}

（3）抽象工厂接口

interface AbsFactory{
    //让下面的工厂子类来具体实现
    public Pizza04 createPizza(String orderType);
}

（4）实现抽象工厂类

class BJFactory implements AbsFactory {

    @Override
    public Pizza04 createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza04 pizza04=null;
        if(orderType.equals("cheese")){
            pizza04=new BJCheesePizza();
        } else if(orderType.equals("pepper")){
            pizza04=new BJPepperPizza();
        }
        return pizza04;
    }
}


class LDFactory implements AbsFactory {

    @Override
    public Pizza04 createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza04 pizza04=null;
        if(orderType.equals("cheese")){
            pizza04=new LDCheesePizza();
        } else if(orderType.equals("pepper")){
            pizza04=new LDPepperPizza();
        }
        return pizza04;
    }
}

（5）披萨订单类

public class OrderPizza04 {

    AbsFactory factory;

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

    private void setFactory(AbsFactory factory){
        Pizza04 pizza04=null;
        String orderType="";
        this.factory=factory;
        do {
            orderType=getType();
            pizza04=factory.createPizza(orderType);
            if(pizza04!=null){
                pizza04.prepare();
                pizza04.bake();
                pizza04.cut();
                pizza04.box();
                System.out.println("您点的"+pizza04.name+"披萨已经做好了，请慢用");
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

    //写一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入披萨的种类：");
            String str=strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

（6）测试类

public class PizzaStore04 {
    public static void main(String[] args) {
        new OrderPizza04(new BJFactory());
    }
}

（3）UML图

在这里插入图片描述

（4）抽象工厂模式的补充说明和使用场景

【介绍】
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

【意图】
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

【主要解决】
主要解决接口选择的问题。

【何时使用】
系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

【如何解决】
在一个产品族里面，定义多个产品。

【关键代码】
在一个工厂里聚合多个同类产品。

【应用实例】
工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

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

【缺点】
产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

【使用场景】
1、QQ 换皮肤，一整套一起换。
2、生成不同操作系统的程序。

【注意事项】
产品族难扩展，产品等级易扩展。

（六）抽象工厂模式的实际使用案例

（1）需求描述

公司早期介入七牛云OSS（对象存储服务）上传图片与视频，后因业务调整，巩乃斯要求额外支持阿里云、腾讯云等其他云服务商，并且可以对客户提供外界访问。

设计要求：允许在不破坏原有代码逻辑的情况下，实现对任意三方云厂商的接入。

（2）实现逻辑

（1）创建工厂的工厂

public interface AbstractOssFactory {
    public OssImage uploadImage(byte[] bytes);
    public OssVideo uploadVideo(byte[] bytes);
}

public interface OssImage {
    public String getThumb();
    public String getWatermark();
    public String getEnhance();
}

public interface OssVideo {
    public String get720p();
    public String get1080p();
}

（2）创建阿里云工厂的实现类

/**
 * @ClassName: AliyunOssFacotry
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:41
 */
public class AliyunOssFacotry implements AbstractOssFactory {
    @Override
    public OssImage uploadImage(byte[] bytes) {
        return new AliyunOssImage(bytes,"Allen",true);

    }

    @Override
    public OssVideo uploadVideo(byte[] bytes) {
        return new AliyunOssVideo(bytes,"Allen");
    }
}

/**
 * @ClassName: AliyunOssImage
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:43
 */
public class AliyunOssImage implements OssImage {

    private byte[] bytes;

    public AliyunOssImage(byte[] bytes, String watermark, boolean transparent) {
        this.bytes = bytes;
        System.out.println("【阿里云】图片已上传至阿里云OSS");
        System.out.println("【阿里云】已生成缩略图，尺寸640*480像素");
        System.out.println("【阿里云】已为图片新增水印，水印文本："+watermark+"，文本透明度："+transparent);
        System.out.println("【阿里云】已将图片AI增强为4K极清画质");
    }

    @Override
    public String getThumb() {
        return "获取阿里云缩略图";
    }

    @Override
    public String getWatermark() {
        return "获取阿里云水印";
    }

    @Override
    public String getEnhance() {
        return "获取阿里云画质增强图";
    }
}

/**
 * @ClassName: AliyunOssImage
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:43
 */
public class AliyunOssVideo implements OssVideo {
    private byte[] bytes;

    public AliyunOssVideo(byte[] bytes, String watermark) {
        this.bytes = bytes;
        System.out.println("【阿里云】视频已上传至阿里云南OSS");
        System.out.println("【阿里云】720p转码成功，码率：5000K");
        System.out.println("【阿里云】1080p转码成功，码率：7000K");
    }

    @Override
    public String get720p() {
        return "返回阿里云720p视频";
    }

    @Override
    public String get1080p() {
        return "返回阿里云1080p视频";
    }
}

（3）创建七牛云工厂的实现类

/**
 * @ClassName: AliyunOssFacotry
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:41
 */
public class QiniuyunOssFacotry implements AbstractOssFactory {
    @Override
    public OssImage uploadImage(byte[] bytes) {
        return new QiniuyunOssImage(bytes,"Allen",true);
    }

    @Override
    public OssVideo uploadVideo(byte[] bytes) {
        return new QiniuyunOssVideo(bytes,"Allen");
    }
}

/**
 * @ClassName: AliyunOssImage
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:43
 */
public class QiniuyunOssImage implements OssImage {

    private byte[] bytes;

    public QiniuyunOssImage(byte[] bytes, String watermark, boolean transparent) {
        this.bytes = bytes;
        System.out.println("【七牛云】图片已上传至阿里云OSS");
        System.out.println("【七牛云】已生成缩略图，尺寸640*480像素");
        System.out.println("【七牛云】已为图片新增水印，水印文本："+watermark+"，文本透明度："+transparent);
        System.out.println("【七牛云】已将图片AI增强为4K极清画质");
    }

    @Override
    public String getThumb() {
        return "获取七牛云缩略图";
    }

    @Override
    public String getWatermark() {
        return "获取七牛云水印";
    }

    @Override
    public String getEnhance() {
        return "获取七牛云画质增强图";
    }
}

/**
 * @ClassName: AliyunOssImage
 * @Author: AllenSun
 * @Date: 2023/2/12 下午1:43
 */
public class QiniuyunOssVideo implements OssVideo {
    private byte[] bytes;

    public QiniuyunOssVideo(byte[] bytes, String watermark) {
        this.bytes = bytes;
        System.out.println("【七牛云】视频已上传至阿里云南OSS");
        System.out.println("【七牛云】720p转码成功，码率：5000K");
        System.out.println("【阿里云】1080p转码成功，码率：7000K");
    }

    @Override
    public String get720p() {
        return "返回七牛云720p视频";
    }

    @Override
    public String get1080p() {
        return "返回七牛云1080p视频";
    }
}

（4）测试类

/**
 * @ClassName: Client
 * @Author: AllenSun
 * @Date: 2023/2/12 下午2:04
 */
public class Client {
    public static void main(String[] args) {
        AbstractOssFactory factory = new AliyunOssFacotry();
        OssImage ossImage = factory.uploadImage(new byte[1024]);
        OssVideo ossVideo = factory.uploadVideo(new byte[1024]);

        System.out.println(ossImage.getThumb());
        System.out.println(ossImage.getWatermark());
        System.out.println(ossImage.getEnhance());
        System.out.println(ossVideo.get720p());
        System.out.println(ossVideo.get1080p());
    }
}

（七）工厂模式在JDK-Calendar应用的源码分析

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {
    ...
    //构造器
    protected Calendar() {
        this(TimeZone.getDefaultRef(), Locale.getDefault(Category.FORMAT));
        this.sharedZone = true;
    }
    //getInstance方法，调用createCalendar方法
    public static Calendar getInstance() {
        Locale var0 = Locale.getDefault(Category.FORMAT);
        return createCalendar(defaultTimeZone(var0), var0);
    }
    //完成对象的创建和实例化
    private static Calendar createCalendar(TimeZone var0, Locale var1) {
        CalendarProvider var2 = LocaleProviderAdapter.getAdapter(CalendarProvider.class, var1).getCalendarProvider();
        if (var2 != null) {
            try {
                return var2.getInstance(var0, var1);
            } catch (IllegalArgumentException var7) {
            }
        }

        Object var3 = null;
        if (var1.hasExtensions()) {
            String var4 = var1.getUnicodeLocaleType("ca");
            if (var4 != null) {
                byte var6 = -1;
                switch(var4.hashCode()) {
                case -1581060683:
                    if (var4.equals("buddhist")) {
                        var6 = 0;
                    }
                    break;
                case -752730191:
                    if (var4.equals("japanese")) {
                        var6 = 1;
                    }
                    break;
                case 283776265:
                    if (var4.equals("gregory")) {
                        var6 = 2;
                    }
                }

                switch(var6) {
                case 0:
                    var3 = new BuddhistCalendar(var0, var1);
                    break;
                case 1:
                    var3 = new JapaneseImperialCalendar(var0, var1);
                    break;
                case 2:
                    var3 = new GregorianCalendar(var0, var1);
                }
            }
        }

        if (var3 == null) {
            if (var1.getLanguage() == "th" && var1.getCountry() == "TH") {
                var3 = new BuddhistCalendar(var0, var1);
            } else if (var1.getVariant() == "JP" && var1.getLanguage() == "ja" && var1.getCountry() == "JP") {
                var3 = new JapaneseImperialCalendar(var0, var1);
            } else {
                var3 = new GregorianCalendar(var0, var1);
            }
        }

        return (Calendar)var3;
    }
}

fixAllenSun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
认识设计模式（四）---工厂模式

认识设计模式（四）---工厂模式工厂模式具体需求传统方式思路分析代码示例传统方式优缺点分析简单工厂模式基本介绍代码示例简单工厂模式UML图工厂方法模式思路分析代码示例UML图抽象工厂模式基本介绍代码示例UML图工厂模式在JDK-Calendar应用的源码分析工厂模式具体需求看一个披萨的项目，要便于披萨种类的扩展，要便于维护（当需要添加新的披萨种类时，要尽量少改动代码）披萨的种类披萨的制...
复制链接

扫一扫