一,工厂模式
工厂模式: 创建式模式的一种,由一个工厂对象决定创建出哪一种类的实例,即本身是一个创建对象的类,封装了实例化对象的类;在开发中,当我们需要大量的创建某种类对象时,就可以考虑优先使用工厂模式;
二,原理类图
1,工厂方法
意图: 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。
适用性:
- 当一个类不知道它所必须创建的对象的类的时候。
- 当一个类希望由它的子类来指定它所创建的对象的时候。
- 当类将创建对象的职责委托给多个帮助子类中的某一个,并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
2,抽象工厂
意图: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
适用性:
- 一个系统要独立于它的产品的创建、组合和表示时。
- 一个系统要由多个产品系列中的一个来配置时。
- 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
- 当你提供一个产品类库,而只想显示它们的接口而不是实现时。
三,实例
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,抽象工厂模式:
抽象工厂模式:
- 定义一个接口用于创建相关或有依赖关系的对象,不需要指明具体的类;
- 抽象工厂分为抽象工厂和具体实现的工厂子类,我们可以根据创建的对象使用具体子类,完成需要的个性化功能;
工厂接口(即我们可能大量创建的对象种类的统一规范接口)
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;
}