设计模式--第2篇（工厂模式）

于 2019-09-23 23:25:44 发布
阅读量255 收藏
点赞数
分类专栏： 设计模式 文章标签： 工厂模式 简单工厂 工厂方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42413454/article/details/101164823
版权
本文详细介绍了设计模式中的工厂模式，包括简单工厂、工厂方法和抽象工厂三种模式。通过原理类图和实例分析，阐述了每种模式的意图、适用场景以及如何在实际开发中应用。同时，文章提供了JDK源码中工厂模式的应用示例，如Calendar类的实现。
摘要由CSDN通过智能技术生成

设计模式

一，工厂模式

工厂模式： 创建式模式的一种，由一个工厂对象决定创建出哪一种类的实例，即本身是一个创建对象的类，封装了实例化对象的类；在开发中，当我们需要大量的创建某种类对象时，就可以考虑优先使用工厂模式；

二，原理类图

1，工厂方法

在这里插入图片描述
意图： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。
适用性：

  1. 当一个类不知道它所必须创建的对象的类的时候。
  2. 当一个类希望由它的子类来指定它所创建的对象的时候。
  3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
2，抽象工厂

在这里插入图片描述
意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性：

  1. 一个系统要独立于它的产品的创建、组合和表示时。
  2. 一个系统要由多个产品系列中的一个来配置时。
  3. 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
  4. 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

三，实例

1，简单工厂模式：

简单工厂模式： 工厂模式中最简单，最常用的一种；
抽象类（即我们可能大量创建的对象种类规范）

package com.neei.factory;

/**
 * @param
 * @Author: AaNeei
 * @Date: 2019/9/23  22:27
 * @Description: 游学网
 * @throws:
 */
public abstract class Sql {

    //连接
    public abstract void connect();

    //增
    public void add(){
        System.out.println("sql新增");
    }
    //删
    public void deleted(){
        System.out.println("sql删除");
    }
    //...
}

实现（即我们需要创建的具体细节类）

public class MySql extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到MySQL数据库");
    }
}

public class Oracle extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到Oracle数据库");
    }
}

public class SqlServer extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到SqlServer数据库");
    }
}

工厂（即统一暴露我们需要的种类的类）

package com.neei.factory;

import com.neei.factory.sql.MySql;
import com.neei.factory.sql.Oracle;
import com.neei.factory.sql.SqlServer;

import java.util.HashMap;

/**
 * @param
 * @Author: AaNeei
 * @Date: 2019/9/23  22:25
 * @Description: 游学网
 * @throws:
 */
public class SimpleFactory {

    private static HashMap<String, Sql> map = new HashMap<>();

    static {
        map.put("mysql", new MySql());
        map.put("sqlserver", new SqlServer());
        map.put("oracle", new Oracle());
    }

    public static Sql getSqlFactory(String sqlType) {
        return map.get(sqlType);
    }
}

调用

public class FactoryClient {
    public static void main(String[] args) {
        Sql sql = SimpleFactory.getSqlFactory("mysql");
        sql.connect();
    }
}
2，工厂方法模式：

工厂方法模式： 将对象的实例化推迟到子类中；

抽象类（即我们可能大量创建的对象种类规范）

 */
public abstract class Connect {

    public abstract void connectedTool(String sqlType);

    private static HashMap<String, Sql> map = new HashMap<>();

    static {
        map.put("mysql", new MySql());
        map.put("sqlserver", new SqlServer());
        map.put("oracle", new Oracle());
    }

    public static Sql getSqlFactory(String sqlType) {
        return map.get(sqlType);
    }
}

实现（即我们需要创建的具体细节类）

public class IDB extends Connect {
    @Override
    public void connectedTool(String sqlType) {
        System.out.println("通过IDB");
        Connect.getSqlFactory(sqlType).connect();
    }
}

public class Navicat extends Connect {

    @Override
    public void connectedTool(String sqlType) {
        System.out.println("通过Navicat");
        Connect.getSqlFactory(sqlType).connect();
    }
}

public class SQLyog extends Connect {
    @Override
    public void connectedTool(String sqlType) {
        System.out.println("通过SQLyog");
        Connect.getSqlFactory(sqlType).connect();
    }
}

工厂（即统一暴露我们需要的种类的类）

public class SimpleFactory {

    private static HashMap<String, Sql> map = new HashMap<>();

    static {
        map.put("mysql", new MySql());
        map.put("sqlserver", new SqlServer());
        map.put("oracle", new Oracle());
    }

    public static Sql getSqlFactory(String sqlType) {
        return map.get(sqlType);
    }
}

调用

public class FactoryClient {
    public static void main(String[] args) {
        new IDB().connectedTool("mysql");
        new SQLyog().connectedTool("oracle");
        new Navicat().connectedTool("sqlserver");
    }
}
3，抽象工厂模式：

抽象工厂模式：

  1. 定义一个接口用于创建相关或有依赖关系的对象，不需要指明具体的类；
  2. 抽象工厂分为抽象工厂和具体实现的工厂子类，我们可以根据创建的对象使用具体子类，完成需要的个性化功能；

工厂接口（即我们可能大量创建的对象种类的统一规范接口）

public interface AbsFactory {
    Sql connected(String sqlType);
    //...
}

工厂（即我们需要创建的具体细节类的工厂）

public class IDB implements AbsFactory {

    @Override
    public Sql connected(String sqlType) {
        System.out.println("通过IDB");
       return Connect.getSqlFactory(sqlType);
    }
}

public class Navicat implements AbsFactory {

    @Override
    public Sql connected(String sqlType) {
        System.out.println("通过Navicat");
        return Connect.getSqlFactory(sqlType);
    }
}

public class SQLyog implements AbsFactory {

    @Override
    public Sql connected(String sqlType) {
        System.out.println("通过SQLyog");
        return Connect.getSqlFactory(sqlType);
    }
}

实现（即我们需要创建的具体细节类）

public class MySql extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到MySQL数据库");
    }
}

public class Oracle extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到Oracle数据库");
    }
}

public class SqlServer extends Sql {
    @Override
    public void connect() {
        System.out.println("连接到SqlServer数据库");
    }
}

调用

public class FactoryClient {
    public static void main(String[] args) {
        connected(new IDB());
        connected(new Navicat());
        connected(new SQLyog());
    }

    private static void connected(AbsFactory absFactory){
        absFactory.connected("mysql").connect();
    }
}

四，源码分析

jdk源码中使用的工厂模式,如**Calendar **；

 public static Calendar getInstance(TimeZone zone,
                                       Locale aLocale)
    {
        return createCalendar(zone, aLocale);
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;
		//简单工厂
        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }
neei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值