工厂模式

最新推荐文章于 2024-09-15 21:58:41 发布

指尖残雪

最新推荐文章于 2024-09-15 21:58:41 发布

阅读量142

点赞数

分类专栏： Java设计模式文章标签： Java设计模式工厂模式简单工厂模式抽象工厂模式工厂方法模式

Java设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文参考：《修炼Java开发技术：在架构中体验设计模式和算法之美于广编著》。

工厂模式主要是为创建对象提供了接口，一般来说可以分为如下3类：

1、简单工厂模式。(Simple Factory)

2、工厂方法模式。(Factory Method)

3、抽象工厂模式。(Abstract Factory)

使用工厂模式的两种情况：

1、在编码时不能预见需要创建哪种类的实例。

2、系统不应该依赖产品类实例如何被创建、组合和表达的细节。

简单工厂模式：使用在业务比较简单的情况。

Creator工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在Java中往往由一个具体的类实现。

Product抽象产品角色：一般是具体产品继承的父类或者实现的接口，在Java中由接口或者抽象类来实现。

ConcreteProduct具体产品角色：工厂类所创建的对象就是此角色的实例，在Java中由一个具体类来实现。

命名建议：

类名建议为“模块名称+Factory”，比如用户工厂为UserFactory,方法名称通常为“get+接口名称”或者是“create+接口名称”，例如getUserAsc或者createUserAsc。

简单工厂模式举例：

package org.dyb.design.simplefactory;
/**
 * 
 *description:运动员
 * @see
 */
public interface Athlete {
    public void run();
    public void jump();
}

package org.dyb.design.simplefactory;
/**
 *description:篮球运动员
 * @see
 */
public class BasketballPlayer implements Athlete {
    @Override
    public void run() {
    }
    @Override
    public void jump() {
    }
}

package org.dyb.design.simplefactory;
/**
 *description:足球运动员
 * @see
 */
public class FootballPlayer implements Athlete {
    @Override
    public void run() {
    }

    @Override
    public void jump() {
    }
}

运动员工厂类：

package org.dyb.design.simplefactory;

public class AthleteFactory {
    public static Athlete createFootballPlayer() {
        return new FootballPlayer();
    }
    public static Athlete createBasketballPlayer() {
        return new BasketballPlayer();
    }
}

测试;

package org.dyb.design.simplefactory;

import org.junit.Test;

public class TestSimpleFactory {
    private Athlete basketball = null;
    private Athlete football = null; 
    @Test
    public void test(){
        basketball = AthleteFactory.createBasketballPlayer();
        football = AthleteFactory.createFootballPlayer();
        basketball.jump();
        football.run();
    }
}

简单工厂模式的优缺点：

优点：简单工厂模式虽然很简单，但是非常友好地帮助我们实现了组件的封装，让组件外部能够真正的面向接口编程。实现了客户端和具体实现类的解耦，客户端不知道具体是由谁来实现，也不知道具体是如何实现的。客户端只需要通过工厂获得它需要的接口对象。

缺点：不方便进行扩展。如果增加一个工厂生产对象（例如乒乓球运动员），需要修改工厂内部代码。

工厂方法模式：

工厂方法模式是类的创建模式，又叫虚拟构造器模式或者多态性工厂模式，工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且客服了它的缺点。

在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做。这个核心工厂则变为抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一产品的创建的细节。这种抽象的结果，使这种工厂方法模式可以用来允许系统在不修改具体工厂角色的情况下引进新产品，这一特点无疑使得工厂方法模式具有超过简单工厂模式的优越性。

在工厂方法模式中一般都有一个平行的等级结构，也就是说，工厂和产品是对应的。抽象工厂对应抽象产品，具体工厂对应具体产品。工厂模式的具体结构如图：

抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关，是具体工厂角色必须实现的接口或者必须继承的父类。在Java汇总它由抽象类或者接口来实现。

具体工厂角色：它含有与具体业务逻辑有关的代码。由应用程序调用，以创建相应的具体产品的对象。在Java中由具体的类来实现。

抽象产品角色：它是具体产品继承的父类或者实现的接口。在Java汇总它由抽象类或者接口来实现。

具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在Java中由具体的类来实现。

举例：

抽象产品类：

package org.dyb.design.simplefactory;
/**
 * 
 *description:运动员
 * @see
 */
public interface Athlete {
    public void run();
    public void jump();
}

package org.dyb.design.simplefactory;
/**
 *description:篮球运动员
 * @see
 */
public class BasketballPlayer implements Athlete {
    @Override
    public void run() {
        System.out.println("BasketballPlayer-->run");
    }
    @Override
    public void jump() {
        System.out.println("BasketballPlayer-->jump");
    }
}

package org.dyb.design.simplefactory;
/**
 *description:足球运动员
 * @see
 */
public class FootballPlayer implements Athlete {
    @Override
    public void run() {
        System.out.println("FootballPlayer-->run");
    }

    @Override
    public void jump() {
        System.out.println("FootballPlayer-->jump");
    }
}

抽象工厂类：

package org.dyb.design.simplefactory;

public interface AthleteFactory {
    public Athlete createPlayer();
}

package org.dyb.design.simplefactory;

public class BasketBallPlayerFactory implements AthleteFactory{
    public Athlete createPlayer() {
        return new BasketballPlayer();
    }
}

package org.dyb.design.simplefactory;

public class FootBallPlayerFactory implements AthleteFactory{
    public Athlete createPlayer() {
        return new FootballPlayer();
    }
}

测试：

package org.dyb.design.simplefactory;

import org.junit.Test;

public class TestSimpleFactory {
    private Athlete basketball = null;
    private Athlete football = null; 
    @Test
    public void test(){
        AthleteFactory basketBallPlayerFactory = new BasketBallPlayerFactory();
        AthleteFactory footBallPlayerFactory = new FootBallPlayerFactory();
        basketball = basketBallPlayerFactory.createPlayer();
        football = footBallPlayerFactory.createPlayer();
        basketball.jump();
        football.run();
    }
}

测试结果：

BasketballPlayer-->jump
FootballPlayer-->run

抽象工厂模式：

抽象工厂模式和工厂方法模式的区别在于需要创建对象的复杂成程度上。而且抽象工厂模式是三个里面最为抽象、为具一般性的。

抽象工厂模式的目的是给客户端提供一个接口，可以创建多个产品族中的产品对象。而且使用抽象工厂模式还要满足以下条件：

1、系统中有多个产品族，而系统一次只可能消费其中一族产品。

2、同属于一个产品族的产品一起使用。

起源：

抽象工厂模式的起源或者最早的应用，是用于创建分属于不同操作系统的视窗构件。比如：命令按键(button)与文本框(Text)都是视窗构件，但是在window和UNIX系统中有不同的本地实现，button和text构成产品族，二每一个视窗构件构成了自己的等级结构，由一个抽象角色给出抽象的功能描述，而由具体子类给出不同操作系统下的具体实现。

	button	text
unix	unix button	unix text
windows	windows button	windows text

抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。

在演示抽象工厂具体代码之前，应该先明白如下两个重要的概念。

1、产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的CPU和AMD芯片的主板，组成一个家族。Intel的CPU和Intel芯片的主板，又组成一个家族。

2、产品等级：上述两个家族都来自于两个产品等级：CPU和主板。一个等级结构式由相同结构的产品组成的。

每个工厂创造出来的都是一族产品而不是一个或者一组。组是可以随意组合的。

windows和UNIX就是产品族，button和text就是产品等级。

举例：

使用抽象工厂模式：

	cpu	Mainboard
Intel	intel cpu	intel Mainboard
AMD	AMD cpu	AMD Mainboard

intel和AMD是产品族，CPU和mainboard是产品等级。

CPU接口：

package org.dyb.design.abstractfactory;

public interface Cpu {
    public void calculate();
}

package org.dyb.design.abstractfactory;

public class IntelCpu implements Cpu {
    /**
     * cpu的针脚数
     */
    private int pins = 0;
    public IntelCpu(int pins){
        this.pins = pins;
    }
    @Override
    public void calculate() {
        System.out.println("intel cup的针脚数"+ pins);
    }

}

package org.dyb.design.abstractfactory;

public class AmdCpu implements Cpu {
    /**
     * cpu的针脚数
     */
    private int pins = 0;
    
    public AmdCpu(int pins){
        this.pins = pins;
    }
    @Override
    public void calculate() {
        System.out.println("AMD cup的针脚数"+ pins);
    }

}

主板接口：

package org.dyb.design.abstractfactory;

public interface Mainboard {
    public void installCPU();
}

package org.dyb.design.abstractfactory;

public class IntelMainboard implements Mainboard{
    /**
     * cpu插槽的孔数
     */
    private int cpuHoles = 0;
    public IntelMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    @Override
    public void installCPU() {
        System.out.println("intel主板的CPU插槽的孔数是："+ cpuHoles);
    }

}

package org.dyb.design.abstractfactory;

public class AmdMainboard implements Mainboard{
    /**
     * cpu插槽的孔数
     */
    private int cpuHoles = 0;
    public AmdMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    @Override
    public void installCPU() {
        System.out.println("AMD主板的CPU插槽的孔数是："+ cpuHoles);
    }

}

产品族工厂：Intel和AMD

package org.dyb.design.abstractfactory;

public interface AbstractFactory {
    public Cpu createCpu();
    public Mainboard createMainboard();
}

package org.dyb.design.abstractfactory;

public class IntelFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        return new IntelCpu(755);
    }
    @Override
    public Mainboard createMainboard() {
        return new IntelMainboard(755);
    }
}

package org.dyb.design.abstractfactory;

public class AmdFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        return new AmdCpu(938);
    }
    @Override
    public Mainboard createMainboard() {
        return new AmdMainboard(938);
    }
}

测试：

package org.dyb.design.abstractfactory;

import org.junit.Test;

public class TestAbstractFactory {
    private Cpu cpu = null;
    private Mainboard mainboard = null;
    private void prepareHardwares(AbstractFactory af){
        this.cpu = af.createCpu();
        this.mainboard = af.createMainboard();
        //验证CPU和主要相对应
        this.cpu.calculate();
        this.mainboard.installCPU();
    }
    @Test
    public void test(){
        AbstractFactory intelFactory = new IntelFactory();
        AbstractFactory amdFactory = new AmdFactory();
        prepareHardwares(intelFactory);
        prepareHardwares(amdFactory);
    }
}

测试结果：

intel cup的针脚数755
intel主板的CPU插槽的孔数是：755

AMD cup的针脚数938
AMD主板的CPU插槽的孔数是：938

使用抽象工厂模式的情形：

1、一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是很重要的。

2、这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

3、同属于一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来（比如Intel主板必须使用IntelCPU、Intel芯片组）。

4、系统提供一个产品类的库，所有的产品以同样的接口出现，从而是客户端不依赖于实现。

抽象工厂模式的优缺点：

优点：分离接口和实现。切换产品变得很容易。

缺点：不太容易扩展新的产品。如果需要给整个产品族添加一个新的产品，需要修改抽象工厂和所有的工厂实现类。例如：增加内存（假设内存Intel和AMD是不通用的），那么需要修改AbstractFactory、IntelFactory、AmdFactory这些类。