文章目录

一、工厂方法
- 1、工厂法法模式结构图：
- 2、工厂方法模式的优缺点
二、抽象工厂模式
- 1、抽象工厂模式结构图
- 2、抽象工厂模式的优缺点

一、工厂方法

工厂方法定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

1、工厂法法模式结构图：

工厂方法抽象出一个工厂接口，这个接口只有一个方法，就是创建抽象产品的工厂方法，所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时，就不需要更改原有的工厂类，只需要增加相应的工厂类。

产品抽象类 Product

public abstract class Product {protected String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}

具体产品类 ConcreteProductA

public class ConcreteProductA extends Product{public ConcreteProductA(){super();this.name = "具体产品 A";}
}

具体产品类 ConcreteProductB

public class ConcreteProductB extends Product{public ConcreteProductB(){super();this.name = "具体产品 B";}
}

抽象工厂接口 Factory

public interface Factory {public Product createProduct();
}

创建 ConcreteProductA 的工厂类 ConcreteProductAFactory

public class ConcreteProductAFactory implements Factory{@Overridepublic Product createProduct() {return new ConcreteProductA();}
}

创建 ConcreteProductB 的工厂类 ConcreteProductBFactory

public class ConcreteProductBFactory implements Factory{@Overridepublic Product createProduct() {return new ConcreteProductB();}
}

效果测试类

public class FactoryMethodTest {public static void main(String[] args) {Factory factoryA = new ConcreteProductAFactory();Factory factoryB = new ConcreteProductBFactory();Product productA = factoryA.createProduct();Product productB = factoryB.createProduct();System.out.println(productA.getName());System.out.println(productB.getName());}
}

2、工厂方法模式的优缺点

工厂方法模式具有良好的封装性，代码结构清晰。如果一个调用者需要一个具体的产品对象，只要知道这个产品的类名，不用知道创建对象的艰辛过程，降低模块间的耦合，并且拓展性好。但缺点也是相对的，每增加一个产品，就需要加一个产品的工厂类，增加了额外的开发量。

二、抽象工厂模式

抽象工厂模式定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

1、抽象工厂模式结构图

AbstractProductA 和 AbstractProductB 是两个抽象产品，而ProductA1和ProductA2、ProductB1、ProductB2就是对两个抽象产品的具体实现。

AbstractFactory是一个抽象工厂接口，它里面包含所有产品创建的抽象方法。而ConcreteFactory1 和ConcreteFactory2就是具体的工厂了。

抽象产品类 AbstractProductA

public abstract class AbstractProductA {protected String type = "A型产品";protected String name;public String getName() {return name;}public void setName(String name) {this.name = name;}/** 每个产品具体实现该方法 */public abstract void doSomething();
}

抽象产品类 AbstractProductB

public abstract class AbstractProductB {protected String type = "B型产品";protected String name;public String getName() {return name;}public void setName(String name) {this.name = name;}/** 每个产品具体实现该方法 */public abstract void doSomething();
}

A型具体产品 ProductA1

public class ProductA1 extends AbstractProductA{public ProductA1(){super();this.name = "产品A1";}@Overridepublic void doSomething() {System.out.println(this.name + " doSomething");}
}

A型具体产品 ProductA2

public class ProductA2 extends AbstractProductA{public ProductA2(){super();this.name = "产品A2";}@Overridepublic void doSomething() {System.out.println(this.name + " doSomething");}
}

B型具体产品 ProductB1

public class ProductB1 extends AbstractProductB{public ProductB1(){super();this.name = "产品B1";}@Overridepublic void doSomething() {System.out.println(this.name + " doSomething");}
}

B型具体产品 ProductB2

public class ProductB2 extends AbstractProductB{public ProductB2(){super();this.name = "产品B2";}@Overridepublic void doSomething() {System.out.println(this.name + " doSomething");}
}

抽象工厂接口 AbstractFactory

public interface AbstractFactory {public AbstractProductA createProductA();public AbstractProductB createProductB();
}

创建1系列产品的工厂类 ConcreteFactory1

public class ConcreteFactory1 implements AbstractFactory{@Overridepublic AbstractProductA createProductA() {return new ProductA1();}@Overridepublic AbstractProductB createProductB() {return new ProductB1();}
}

创建2系列产品的工厂类 ConcreteFactory2

public class ConcreteFactory2 implements AbstractFactory{@Overridepublic AbstractProductA createProductA() {return new ProductA2();}@Overridepublic AbstractProductB createProductB() {return new ProductB2();}
}

效果测试类

public class AbstractFactoryTest {public static void main(String[] args) {AbstractFactory factory = new ConcreteFactory1();AbstractProductA productA = factory.createProductA();AbstractProductB productB = factory.createProductB();productA.doSomething();productB.doSomething();System.out.println("=========切换产品系列工厂=========");factory = new ConcreteFactory2();productA = factory.createProductA();productB = factory.createProductB();productA.doSomething();productB.doSomething();}}

输出：
产品A1 doSomething
产品B1 doSomething
=切换产品系列工厂=
产品A2 doSomething
产品B2 doSomething

由此可见，切换工厂类，即可对获取的产品系列进行切换

2、抽象工厂模式的优缺点

抽象工厂最大的好处是便于切换产品系列，其次是它让具体的创建实例过程与客户端分离，客户端是通过抽象接口获取实例，依赖的产品也是抽象的，而不是具体的产品类。

抽象工厂的缺点是产品族的拓展非常困难，如果增加了一个产品，抽象工厂类中需要增加创建该产品的抽象方法，具体工厂类中也得去实现，涉及到的改动多。

工厂方法和抽象工厂模式相关推荐

工厂模式（简单工厂，工厂方法，抽象工厂）
工厂顾名思义就是创建产品,工厂分为三种:简单工厂,工厂方法,抽象工厂.该模式用于封装和管理对象的创建,是一种创建型模式. 1)简单工厂该模式通过向工厂传递类型来指定要创建的对象提供一个方法,根据类 ...
设计模式：工厂方法与抽象工厂模式
说明:这篇blog写的很好,有助于理解工厂方法与抽象工厂模式的联系与区别. 原文链接:http://blog.csdn.net/yzxz/article/details/4601152 抽象工厂模式与 ...
23招做项目——工厂模式：工厂方法和抽象工厂
在网上的大多数资料里面,将工厂模式分为:简单工厂.工厂方法.抽象工厂,他们之间的联系(以电子厂为例)如下: 那么该文章首先讲解工厂模式是什么,为什么需要工厂模式,最后再对三种模式进行示例.该文章是23 ...
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
工厂模式 Factory Pattern(简单工厂.工厂方法.抽象工厂) 工厂模式-创建型模式-提供了创建对象的最佳方式. 在工厂模式中,创建对象时不会对客户端暴露创建逻辑,并且是通过一个共同的接口来 ...
设计模式：简单工厂、工厂方法、抽象工厂之小结与区别
简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式.其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性. 本文是本人对这三种模式学习后的一个小结以及对他 ...
java 抽象工厂工厂_Java设计模式之简单工厂、工厂方法和抽象工厂
学习Java的同学注意了!!! 学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:456544752我们一起学Java! 在前面的学习中(参见前面的博客),我们学到了很 ...
每周一个设计模式之工厂方法与抽象工厂
工厂方法模式与抽象工厂模式,两个模式比较相似,把任何一个独立出来,好像都不太好,所以把它们放到一起来理解会更好.不管是工厂方法还是抽象工厂,都有三个要素,那就是Client,Factory,Produ ...
工厂方法 VS 抽象工厂
工厂方法 VS 抽象工厂工厂方法模式与抽象工厂抽象,经过多次学习,反复对比,最后得出了这样的结论:工厂方法模式与抽象工厂模式的区别仅在于业务更加的复杂.下面请看两模式的结构图 (一) ...
【设计模式实战】简单工厂、工厂方法、抽象工厂：原理篇
小明开发的应用,经常要从XML或者Asset中读取省市区数据. 小明是这样写的: public abstract class IOHandler {/*** 添加*/public abstract v ...
Python实现简单工厂、工厂方法、抽象工厂设计模式
工厂模式概念实现简单工厂工厂方法工厂方法优点抽象工厂工厂方法和抽象工厂的比较概念在面向对象中,工厂表示一个负责创建其他类型对象的类. 工厂具有: 松耦合客户端无需了解创建对象的类, ...

工厂方法和抽象工厂模式