设计模式之工厂模式

Posted on | In | | Visitors

一 概述

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一，这种类型的设计模式属于创建型模式。工厂模式分为简单工厂模式，工厂方法模式，抽象工厂模式。

二 简单工厂模式

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

结构

简单工厂模式包含如下角色：

  • Factory：工厂角色
    工厂角色负责实现创建所有实例的内部逻辑

  • Product：抽象产品角色
    抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口

  • ConcreteProduct：具体产品角色
    具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

下面的是结构图：

代码示例

抽象产品类

1
2
3
4
5
6
7
public abstract class Shape {   
    //各个产品的相同属性与逻辑
	....

	//需要被重写的方法，展现各个产品的不同
	public abstract void draw();
}

具体产品类A

1
2
3
4
5
6
public class Circle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆形工厂：圆形");        
    }
}

具体工厂类B

1
2
3
4
5
6
public class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("方形工廠：正方形");
    }
}

工厂类

1
2
3
4
5
6
7
8
9
10
11
12
public class SimpleFactory {
    public static Shape createProduct(String product) {
        if(product.equals("circle")){
            return new Circle();
        }else if(product.equals("square")){
            return new Square();
        }else {
            System.out.println("無此產品");
            return null;
        }
    }
}

主程序

1
2
3
4
5
6
public class Main {
    public static void main(String args[]) {
        SimpleFactory.createProduct("circle").draw();
        SimpleFactory.createProduct("square").draw();
    }
}

三 工厂方法模式

工厂方法模式(Factory Method Pattern)又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类

结构

工厂方法模式包含如下角色：

  • Product：抽象产品
  • ConcreteProduct：具体产品
  • Factory：抽象工厂
  • ConcreteFactory：具体工厂
代码示例

抽象产品接口

1
2
3
4
5
public interface Pizza {
    public String getName();
    public void prepaid();
    public void baking();
}

具体产品A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class NYBeefPizza implements Pizza{
    @Override
    public String getName() {
        return "牛肉Pizza";
    }

    @Override
    public void prepaid() {
        System.out.println(getName()+" 準備中...");
        System.out.println(getName()+" 加入紐約特製醬料...");        
    }

    @Override
    public void baking() {
        System.out.println(getName()+" 烘烤中...");    
    }
}

具体产品B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class TPSeafoodPizza implements Pizza{
    @Override
    public String getName() {
        return "海鮮Pizza";
    }

    @Override
    public void prepaid() {
        System.out.println(getName()+" 準備中...");
        System.out.println(getName()+" 加入臺北特製醬料...");        
    }

    @Override
    public void baking() {
        System.out.println(getName()+" 烘烤中...");    
    }
}

抽象工厂类

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class PizzaFactory {

    public Pizza orderPizza(PIZZATYPE pizzaType){
        System.out.println(getClass()+" 開始準備Pizza");
        Pizza pizza = createPizza(pizzaType);
        pizza.prepaid();
        pizza.baking();
        return pizza;
    }

    protected abstract Pizza createPizza(PIZZATYPE pizzaType);
}

具体工厂类A

1
2
3
4
5
6
7
8
public class NYBeefPizzaFactory extends PizzaFactory {

    @Override
    protected Pizza createPizza(PIZZATYPE pizzaType) {
        Pizza pizza = new NYBeefPizza();
        return pizza;
    }
}

具体工厂类B

1
2
3
4
5
6
7
8
public class TPSeafoodPizzaFactory extends PizzaFactory {

    @Override
    protected Pizza createPizza(PIZZATYPE pizzaType) {
        Pizza pizza = new TPSeafoodPizza();
        return pizza;
    }
}

四 抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

结构

抽象工厂模式包含如下角色：

  • AbstractFactory：抽象工厂
  • ConcreteFactory：具体工厂
  • AbstractProduct：抽象产品
  • Product：具体产品
代码示例

产品类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//发动机以及型号    
public interface Engine {    
  
}    
public class EngineA extends Engine{    
    public EngineA(){    
        System.out.println("制造-->EngineA");    
    }    
}    
public class EngineB extends Engine{    
    public EngineB(){    
        System.out.println("制造-->EngineB");    
    }    
}    
  
//空调以及型号    
public interface Aircondition {    
  
}    
public class AirconditionA extends Aircondition{    
    public AirconditionA(){    
        System.out.println("制造-->AirconditionA");    
    }    
}    
public class AirconditionB extends Aircondition{    
    public AirconditionB(){    
        System.out.println("制造-->AirconditionB");    
    }    
}

工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//创建工厂的接口    
public interface AbstractFactory {    
    //制造发动机  
    public Engine createEngine();  
    //制造空调   
    public Aircondition createAircondition();   
}    
  
  
//为宝马320系列生产配件    
public class FactoryBMW320 implements AbstractFactory{    
        
    @Override    
    public Engine createEngine() {      
        return new EngineA();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionA();    
    }    
}    
//宝马523系列  
public class FactoryBMW523 implements AbstractFactory {    
    
     @Override    
    public Engine createEngine() {      
        return new EngineB();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionB();    
    }    
  
  
}

主程序

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Customer {    
    public static void main(String[] args){    
        //生产宝马320系列配件  
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();    
        factoryBMW320.createEngine();  
        factoryBMW320.createAircondition();  
            
        //生产宝马523系列配件    
        FactoryBMW523 factoryBMW523 = new FactoryBMW523();    
        factoryBMW320.createEngine();  
        factoryBMW320.createAircondition();  
    }    
}

五 总结