工厂模式（Factory Pattern）
比 如，你要办一张联通的电话卡，联通有A计划套餐、B计划套餐，不管什么套餐，都能打电话，你只要到营业厅买一张卡就行了。其中，电话卡是一个接口 （SimCard），它有一个方法就是用来打电话（service），A计划和B计划的卡都是其实现类（SimCardPlanA、 SimCardPlanB），营业厅就是一个工厂，用来生产电话卡（ChinaUnicomFactory），你只要告诉它你要什么套餐就行了。
电话卡接口（SimCard）：
public interface SimCard {
public void service();
}
A套餐的卡（SimCardPlanA）：
public class SimCardPlanA implements SimCard {
@Override
public void service() {
System.out.println("联通A计划电话卡");
}
}
B套餐的卡（SimCardPlanB）：
public class SimCardPlanB implements SimCard {
@Override
public void service() {
System.out.println("联通B计划电话卡");
}
}
生产电话卡的工厂，也就是营业厅（ChinaUnicomFactory）：
public class ChinaUnicomFactory {
public static SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
}
测试类：
public class Test {
/**
* 又称静态工厂方法模式（Static Factory Method Pattern），很简单，
* 就是通过一个工厂类来负责对象的创建。
*
* @param args
*/
public static void main(String[] args) {
//获取一个联通A计划的电话卡
SimCard simCard1 = ChinaUnicomFactory.getSimCard("PlanA");
simCard1.service();
//获取一个联通B计划的电话卡
SimCard simCard2 = ChinaUnicomFactory.getSimCard("PlanB");
simCard2.service();
}
}
继 续上面的例子，能生产电话卡的不光是联通啊，移动、电信也行啊，只要是运营商都卖手机卡啊。于是，我们将上面的工厂改造一下，提供一个运营商工厂的接口 （ServiceOperatorFactory），联通工厂（ChinaUnicomFactory）、移动工厂 （ChinaMobileFactory）都实现了运营商接口的实现类，再增加两种卡的类型，移动的全球通卡（SimCardQQT）和神州行卡 （SimCardSZX）。这样，当用户想办联通卡时就用联通的工厂，想用移动卡时就用移动的工厂，没准哪天都不想用了，想换个电信的，没问题，不用修改 写好的代码，再加一个电信的工厂就行了，扩展性得到提高了吧。
运营商接口（ServiceOperatorFactory）：
public interface ServiceOperatorFactory {
public SimCard getSimCard(String kind);
}
联通工厂（ChinaUnicomFactory）：
public class ChinaUnicomFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
}
移动工厂（ChinaMobileFactory）：
public class ChinaMobileFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("QQT".equals(kind)){
return new SimCardQQT();
}else if("SZX".equals(kind)){
return new SimCardSZX();
}else{
System.out.println("中国移动尚未推出该套餐");
return null;
}
}
}
联通的A计划、B计划卡和上面一样，不列举了。
移动的全球通卡（SimCardQQT）：
public class SimCardQQT implements SimCard {
@Override
public void service() {
System.out.println("移动全球通电话卡");
}
}
移动的神州行卡（SimCardSZX）：
public class SimCardSZX implements SimCard {
@Override
public void service() {
System.out.println("移动神州行电话卡");
}
}
测试类：
public class Test {
/**
* 工厂方法模式（Factory Method Pattern）——定义了一个创建对象的接口，
* 但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
*
* @param args
*/
public static void main(String[] args) {
ServiceOperatorFactory factory;
//获取一个联通A计划的电话卡
factory = new ChinaUnicomFactory();
SimCard simCard1 = factory.getSimCard("PlanA");
simCard1.service();
//获取一个移动神州行的电话卡
factory = new ChinaMobileFactory();
SimCard simCard2 = factory.getSimCard("SZX");
simCard2.service();
}
}
抽象工厂模式（Abstract Factory Pattern）——提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
还 是继续上面的例子，现在运营商可不光是卖卡了，还卖手机。你想买个IPhone5，还得分清是买联通版还是移动版。去联通营业厅，肯定不能买到移动版的 IPhone5啊。于是，我们改造一下上面的例子，增加一个电话的接口（Phone），有一个方法打电话（call），定义两个实现类，联通版 IPhone（IPhoneUnicom）和移动版IPhone（IPhoneMobile），在运营商接口中增加一个获取电话的方法 （getPhone，假设营业厅只卖IPhone）。当使用不同的运营商工厂时，得到的电话卡和电话都是指定运营商的，你不需要指定说我要个什么版本的电 话，因为联通不卖移动版的电话。
电话接口（Phone）：
public interface Phone {
public void call();
}
联通版IPhone（IPhoneUnicom）：
public class IPhoneUnicom implements Phone {
@Override
public void call() {
System.out.println("正在使用IPhone联通版");
}
}
移动版IPhone（IPhoneMobile）：
public class IPhoneMobile implements Phone {
@Override
public void call() {
System.out.println("正在使用IPhone移动版");
}
}
运营商接口（ServiceOperatorFactory）：
public interface ServiceOperatorFactory {
public SimCard getSimCard(String kind);
public Phone getPhone();
}
联通工厂（ChinaUnicomFactory）：
public class ChinaUnicomFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
@Override
public Phone getPhone() {
return new IPhoneUnicom();
}
}
移动工厂（ChinaMobileFactory）：
public class ChinaMobileFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("QQT".equals(kind)){
return new SimCardQQT();
}else if("SZX".equals(kind)){
return new SimCardSZX();
}else{
System.out.println("中国移动尚未推出该套餐");
return null;
}
}
@Override
public Phone getPhone() {
return new IPhoneMobile();
}
}
电话卡接口和实现类同上，不再列举。
测试类：
public class Test {
/**
* 抽象工厂模式（Abstract Factory Pattern）——提供一个接口，
* 用于创建相关或依赖对象的家族，而不需要明确指定具体类。
*
* @param args
*/
public static void main(String[] args) {
ServiceOperatorFactory factory;
//获取一个联通A计划的电话卡
factory = new ChinaUnicomFactory();
SimCard simCard1 = factory.getSimCard("PlanA");
Phone phone1 = factory.getPhone();
simCard1.service();
phone1.call();
//获取一个移动神州行的电话卡
factory = new ChinaMobileFactory();
SimCard simCard2 = factory.getSimCard("SZX");
Phone phone2 = factory.getPhone();
simCard2.service();
phone2.call();
}
}
区别：
简单工厂模式多用于需求明确、功能简单的开发，通过一个工厂类就可完成所有产品的生成工作。
工厂方法模式侧重点是，开发时不明确要生成哪种类型的实例，不同的工厂类生成不同类型的产品，运行时通过指定不同的工厂类来生成相应的产品类型。如有产品类型A，工厂1用于生成产品A1，工厂2用于生成产品A2，运行时通过指定不同的工厂来生成不同的产品。
抽 象工厂模式更注重于生产一个产品家族（即多种类型的产品），而这些产品类型又可横向划分为多个系列，那么，抽象工厂中定义生成所有产品类型的方法，每个工 厂的实现类用于生产一个系列所有类型的产品。如有A、B、C等产品类型，而这些类型中又可分为多个系列1、2，这样就有了产品A1、A2、B1、B2、 C1、C2，这时，工厂1用于生产A1、B1、C1，工厂2用于生产A2、B2、C2，运行时通过指定不同的工厂来生成不同系列的一组产品。
相关推荐
以下是一些在尚学堂300Java设计模式部分学习笔记中涉及的设计模式的知识点： 创建型模式： 创建型模式主要解决对象创建的问题，确保系统的灵活性和封装创建细节。学习笔记中提到了5种创建型模式： 1. 单例模式...
### 23种设计模式学习笔记 #### 一、软件设计模式的概念与意义 **概念：** 软件设计模式（Software Design Pattern），又称设计模式，是一套被广泛采用、经过整理和分类的代码设计经验总结。它针对软件设计过程中...
还有“工厂模式”（Factory pattern），它是创建型设计模式之一，用于创建对象而不暴露创建逻辑给客户端，并且通过使用一个共同的接口来指向新创建的对象。这种模式在创建对象时提供了更高的灵活性和可扩展性。在...
设计模式学习笔记，此项目参考《大话设计模式》，只能作为入门级设计模式学习 设计原则 职责单一原则 开放-封闭原则 依赖倒转原则 高层模块不依赖底层模块，两个模块都应该依赖抽象。抽象不依赖细节，细节依赖抽象。...
### 设计模式学习笔记知识点概览 #### 一、引言 设计模式是软件工程领域中一种非常重要的概念，它代表了一种最佳实践的方式，帮助开发者解决特定问题时能够更加高效、灵活。良葛格的《Design Pattern学习笔记》不仅...
本篇文章是对一份设计模式学习资料的深入解读，这份资料包含了19种经典的设计模式，并提供了C#示例代码，适用于学习和复习。下面将逐一介绍这些设计模式及其核心概念。 #### 1. 简单工厂模式 (Simple Factory ...
创建型模式如工厂模式（Factory）、抽象工厂模式（Abstract Factory）、单例模式（Singleton）、建造者模式（Builder）、原型模式（Prototype）和对象池模式（Object Pool Pattern）主要关注对象的创建。结构型模式...
配套博客学习笔记： ://yubuntu0109.github.io/tags/design-and-pattern/ 参考书籍（推荐）： 《Java设计模式 - 刘伟》 ， 《图解设计模式 - [日]结城浩》 创建型模式 :check_mark:简单工厂模式( Simple Factor ...
3. **抽象工厂模式（Abstract Factory）**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。 4. **建造者模式（Builder）**：将复杂对象的构建与其表示分离，使得同样的构建过程可以创建...
本学习笔记和示例代码将深入探讨23种经典的GOF设计模式，并以Java语言为实现基础。 1. **单例模式（Singleton）**：确保一个类只有一个实例，并提供全局访问点。在Java中，通常使用双重检查锁定（Double-Checked ...
本笔记主要关注的是如何有效地学习和运用设计模式。 首先，我们需要了解设计模式的基本分类。设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式...
### 工厂模式（Factory Pattern） 工厂模式是一种创建型模式，用于创建对象但隐藏创建逻辑，而不是直接使用`new`关键字来创建对象。工厂模式通过引入一个单独的工厂类来封装对象的创建逻辑，这样可以避免依赖于具体...
在源码层面，MyBatis使用了工厂模式（Factory Pattern）来创建SqlSessionFactory，而SqlSessionFactory又使用Builder模式来构造复杂的配置。此外，MyBatis的动态代理机制是基于Java的InvocationHandler接口实现的，...