【设计模式】第四章 工厂模式

第四章 工厂模式

一、介绍

工厂模式（Factory Pattern），工厂就是创建产品的地方，根据创建的产品是具体产品还是具体工厂可以分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式

二、简单工厂模式

该模式对对象创建管理方式最为简单，因为其仅仅简单地对不同类对象地创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其 UML 类图如下：

下面我们使用手机生产来讲解该模式：

Phone 接口，手机标准规范类（AbstractProduct）

public interface Phone{
	void make();
}

IPhone 类，苹果手机（Prouduct1）

public class IPhone implements Phone{
	public IPhone(){
		this.make();
	}

	@Override
	public void make(){
		System.out.pringln("make iphone")
	}
}

MiPhone，小米手机（Product2）

public class MiPhone implements Phone{
	public MiPhone(){
		this.make();
	}

	@Override
	public void make(){
		System.out.println("make miphone")
	}
}

PhoneFactory 类，手机代工厂（Factory）

public class PhoneFactory{
	public Phone makePhone(String phoneType){
		if(phoneType.equalsIgnoreCase("IPhone")){
			return new IPhone();
		}
		else if(phoneType.equalsIgnoreCase("MiPhone")){
			return new MiPhone();
		}
		return null;
	}
}

测试用例

public class Demo{
	public static void main(String[] args){
		PhoneFactory factory = new PhoneFactory();
		Phone iPhone = (IPhone)factory.makePhone("IPhone");		//make iphone
		Phone miphone = (MiPhone)factory.makePhone("MiPhone");	//make miphone
		
	}
}

三、工厂方法模式

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品地任务分发给具体的产品工厂，其 UML 类图如下

也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，而是将生产任务交给不同的派生类工厂。这样就不用通过指定类型来创建对象了

接下来继续使用生产手机的例子来讲解该模式

其中和产品相关的 IPhone 类、MiPhone 类和 IPhone 类的定义不变

AbstarctFactory 接口，生产不同产品的工厂

public interface AbstarctFactory {
    Phone makePhone();
}

AppleFactory 类，生产苹果手机的工厂（ConcreteFactory1）

public class AppleFactory implements AbstarctFactory{

    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

XiaoMiFactory 类，生产小米手机的工厂（ConcreteFactory2）

public class XiaoMiFactory implements AbstarctFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

测试用例

public class Demo{
    public static void main(String[] args){
        AbstarctFactory appleFactory = new AppleFactory();
        AbstarctFactory miFactory = new XiaoMiFactory();
        appleFactory.makePhone();   //make iphone
        miFactory.makePhone();      //make miphone
        
    }
}

四、抽象工厂模式

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品 Phone（AbstractProduct），如果要生成另一种产品 PC，应该怎么表示呢？

最简单的方式是把工厂方法模式完全复制一份，只是这次生产的是 PC，但同时也就意味着我们要完全复制和修改 Phone 生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护

抽象工厂模式通过在 AbstractFactory 中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干

其 UML 类图如下：

从上面类图结构中可以清楚地看到如何在工厂方法模式中通过增加新产品接口来实现产品的增加的

接下来我们继续通过小米和苹果生产的例子来解释该模式

为了弄清楚上面的结构，我们使用具体的产品和工厂来表示上面的 UML 类图，能更清晰地看出模式是如何演变的

PC 接口，定义 PC 产品的接口（AbstaractPC）

public interface PC{
	void make();
}

MAC 类，定义苹果电脑产品（MAC）

public class MAC implements PC{
    public MAC(){
        this.make();
    }
    
    @Override
    public void make() {
        System.out.println("make MAC");
    }
}

MiPC类，定义小米电脑产品（MiPC）

public class MiPC implements PC{
    public MiPC(){
        this.make();
    }

    @Override
    public void make() {
        System.out.println("make miPC");
    }
}

下面需要修改工厂相关的类的定义

AbstarctFactory，增加 PC 产品制造接口

public interface AbstarctFactory {
    Phone makePhone();
    PC makePC();
}

AppleFactory 类，增加苹果 PC 的制造（ConcreteFactory1）

public class MAC implements PC{
    public MAC(){
        this.make();
    }

    @Override
    public void make() {
        System.out.println("make MAC");
    }
}

XiaoMiFactory 类，增加小米 PC 的制造（ConcreteFactory2）

public class XiaoMiFactory implements AbstarctFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }

    @Override
    public PC makePC() {
        return new MiPC();
    }
}

测试用例

public class Demo{
    public static void main(String[] args){
        AbstarctFactory appleFactory = new AppleFactory();
        AbstarctFactory miFactory = new XiaoMiFactory();
        appleFactory.makePhone();   //make iphone
        appleFactory.makePC();      //make MAC
        miFactory.makePhone();      //make miphone
        miFactory.makePC();         //make miPC

    }
}