设计模式--10、工厂方法和抽象工厂模式
[转载]Java 之工厂方法和抽象工厂模式
1. 概念
工厂方法:一抽象产品类派生出多个具体产品类;一抽象工厂类派生出多个具体工厂类;每个具体工厂类只能创建一个具体产品类的实例。
即定义一个创建对象的接口(即抽象工厂类),让其子类(具体工厂类)决定实例化哪一个类(具体产品类)。“一对一”的关系。
抽象工厂:多个抽象产品类,派生出多个具体产品类;一个抽象工厂类,派生出多个具体工厂类;每个具体工厂类可创建多个具体产品类的实例。
即提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们的具体的类。“一对多”的关系。
2. UML
工厂方法:
抽象工厂:
3. 代码
工厂方法:
public interface Product
{
}
public interface Creator
{
public Product factory();
}
public class ConcreteProduct1 implements Product
{
public ConcreteProduct1()
{
System.out.println("ConcreteProduct1被创建");
}
}
public class ConcreteProduct2 implements Product
{
public ConcreteProduct2()
{
System.out.println("ConcreteProduct2被创建");
}
}
public class ConcreteCreator1 implements Creator
{
public Product factory()
{
return new ConcreteProduct1();
}
}
public class ConcreteCreator2 implements Creator
{
public Product factory()
{
return new ConcreteProduct2();
}
}
public class Client
{
private static Creator creator1, creator2;
private static Product prod1, prod2;
public static void main(String[] args)
{
creator1 = new ConcreteCreator1();
prod1 = creator1.factory();
System.out.println("----------------------------");
creator2 = new ConcreteCreator2();
prod2 = creator2.factory();
}
}
抽象工厂:
//定义不同的产品之间的一定具备的标准,用interface实现
//其中的method()方法可看作提取出不同产品的共性,如手机都有类似的功能
interface IProductA{
public void method();
}
interface IProductB{
public void method();
}
//实现了产品标准实现的一系列具体产品
//由于已经设计好A1由厂商1生产,故以下输出代码有“厂商x”
class ProductA1 implements IProductA{
public void method() {
System.out.println("厂商1 生产ProductA1 ...");
}
}
class ProductA2 implements IProductA{
public void method() {
System.out.println("厂商2 生产ProductA2 ...");
}
}
class ProductB1 implements IProductB{
public void method() {
System.out.println("厂商1 生产ProductB1 ...");
}
}
class ProductB2 implements IProductB{
public void method() {
System.out.println("厂商2 生产ProductB2 ...");
}
}
//每一种牌子的产品生产工厂,即不同的厂商负责自己牌子产品的生产
abstract class Factory1{
abstract IProductA getProductA1();
abstract IProductB getProductB1();
}
abstract class Factory2{
abstract IProductA getProductA2();
abstract IProductB getProductB2();
}
//具体的工厂用来生产相关的产品
class ConcreteFactory1 extends Factory1{
public IProductA getProductA1() {
return new ProductA1();
}
public IProductB getProductB1() {
return new ProductB1();
}
}
class ConcreteFactoryB extends Factory2{
public IProductA getProductA2() {
return new ProductA2();
}
public IProductB getProductB2() {
return new ProductB2();
}
}
//测试类
public class Client {
public static void main(String[] args) {
//厂商1负责生产产品A1、B1
Factory1 factory1 = new ConcreteFactory1();
IProductA productA1 = factory1.getProductA1();
IProductB productB1 = factory1.getProductB1();
productA1.method();
productB1.method();
//厂商2负责生产产品A2、B2
Factory2 factory2 = new ConcreteFactoryB();
IProductA productA2 = factory2.getProductA2();
IProductB productB2 = factory2.getProductB2();
productA2.method();
productB2.method();
}
}
4. 应用场景
工厂方法:
在以下情况下,适用于工厂方法模式:
(1) 当一个类不知道它所必须创建的对象的类的时候。
(2) 当一个类希望由它的子类来指定它所创建的对象的时候。
(3) 当类将创建对象的职责委托给多个帮助子类中的某一个,并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
抽象工厂:
(1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有形态的工厂模式都是重要的。
(2) 这个系统有多于一个的产品族,而系统只消费其中某一产品族。
(3) 同属于同一个产品族的产品是在一起使用的,这一约束必须在系统的设计中体现出来。
(4) 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于实现。
工厂模式:
首先需要说一下工厂模式。工厂模式根据抽象程度的不同分为三种:简单工厂模式(也叫静态工厂模式)、本文所讲述的工厂方法模式、以及抽象工厂模式。工厂模式是编程中经常用到的一种模式。它的主要优点有:
- 可以使代码结构清晰,有效地封装变化。在编程中,产品类的实例化有时候是比较复杂和多变的,通过工厂模式,将产品的实例化封装起来,使得调用者根本无需关心产品的实例化过程,只需依赖工厂即可得到自己想要的产品。
- 对调用者屏蔽具体的产品类。如果使用工厂模式,调用者只关心产品的接口就可以了,至于具体的实现,调用者根本无需关心。即使变更了具体的实现,对调用者来说没有任何影响。
- 降低耦合度。产品类的实例化通常来说是很复杂的,它需要依赖很多的类,而这些类对于调用者来说根本无需知道,如果使用了工厂方法,我们需要做的仅仅是实例化好产品类,然后交给调用者使用。对调用者来说,产品所依赖的类都是透明的。
工厂方法模式:
通过工厂方法模式的类图可以看到,工厂方法模式有四个要素:
- 工厂接口。工厂接口是工厂方法模式的核心,与调用者直接交互用来提供产品。在实际编程中,有时候也会使用一个抽象类来作为与调用者交互的接口,其本质上是一样的。
- 工厂实现。在编程中,工厂实现决定如何实例化产品,是实现扩展的途径,需要有多少种产品,就需要有多少个具体的工厂实现。
- 产品接口。产品接口的主要目的是定义产品的规范,所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的,产品接口定义的优劣直接决定了调用者代码的稳定性。同样,产品接口也可以用抽象类来代替,但要注意最好不要违反里氏替换原则。
- 产品实现。实现产品接口的具体类,决定了产品在客户端中的具体行为。
前文提到的简单工厂模式跟工厂方法模式极为相似,区别是:简单工厂只有三个要素,他没有工厂接口,并且得到产品的方法一般是静态的。因为没有工厂接口,所以在工厂实现的扩展性方面稍弱,可以算所工厂方法模式的简化版,关于简单工厂模式,在此一笔带过。
适用场景:
不管是简单工厂模式,工厂方法模式还是抽象工厂模式,他们具有类似的特性,所以他们的适用场景也是类似的。
首先,作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过new就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。
其次,工厂模式是一种典型的解耦模式,迪米特法则在工厂模式中表现的尤为明显。假如调用者自己组装产品需要增加依赖关系时,可以考虑使用工厂模式。将会大大降低对象之间的耦合度。
再次,由于工厂模式是依靠抽象架构的,它把实例化产品的任务交由实现类完成,扩展性比较好。也就是说,当需要系统有比较好的扩展性时,可以考虑工厂模式,不同的产品用不同的实现工厂来组装。
添加一点个人新的理解:
工厂方法优点:
1、用户只需要关心所需要的产品对应的工厂,无需关心创建细节,甚至无需要知道具体产品类的类名。
2、它能够使工厂方可以自主确定创建何种产品对象,而如何创建这个对象的细节则完美封装在具体工厂内部。
3、工厂方法模式可以使系统在不改变工厂角色的情况下引进其它新的产品。
缺点:
添加新产品时,需要编写新的具体产品类,还要提供与之对应的具体工厂类,系统中类的个数将成对增加,会给系统带来额外的开销。
工厂方法模式和简单工厂模式的对比:
工厂方法模式的核心是一个抽象工厂类,而简单工厂模式把核心放在一个具体类上,工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来,从而可以成为多个简单工厂模式的统合,进而推广了简单工厂模式。工厂方法模式退化后可以变得很像简单工厂模式。