工厂设计模式

1、概念

工厂模式分三种：简单工厂模式、工厂方法模式、抽象工厂模式

• 简单工厂模式(Simple Factory Pattern)：属于类的创新型模式，又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式严重违背了“开闭原则”，难以拓展。
• 工厂方法模式(Factory Method)：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
• 抽象工厂模式(Abstract Factory Pattern)：是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
  对比
• 简单工厂模式代码简单，虽有多处if分支且违背开闭原则，但扩展性和可读性尚可，这样的代码在大多数情况下并无问题。
• 工厂方法模式通过不同的工厂创建不同的对象，每个对象都有自己的工厂来创建。当对象的创建过程比较复杂，需要组合其他类对象做各种初始化操作时，推荐使用工厂方法模式。
• 在抽象工厂模式中，工厂不仅可以创建一种对象，还可创建一组对象。是用来解决产品簇的问题，而不是解决调用方的开闭原则的问题。
• 需求不易改变选择简单工厂；产品等级少选工厂方法；产品等级稳定选抽象工厂。

2、实现

有四种产品ProductA1、ProductA2、ProductB1、ProductB2，假设ProductA1与ProductA2属于一类，ProductB1、ProductB1属于一类，使用简单工厂模式、工厂方法模式、抽象工厂模式实现。

2.1、简单工厂

package com.mine.design.factory.simple;

public interface IProduct {
	void produce();
}
1
2
3
4
5

package com.mine.design.factory.simple;

public class ProductA1 implements IProduct {

	public void produce() {
		System.out.println("生成产品A1");
	}

}
1
2
3
4
5
6
7
8
9

package com.mine.design.factory.simple;

public class ProductA2 implements IProduct {

	public void produce() {
		System.out.println("生成产品A2");
	}

}
1
2
3
4
5
6
7
8
9

package com.mine.design.factory.simple;

public class ProductB1 implements IProduct {

	public void produce() {
		System.out.println("生产产品B1");
	}

}
1
2
3
4
5
6
7
8
9

package com.mine.design.factory.simple;

public class SimpleFactory {
	public static IProduct getProduct(String type) {
		IProduct product = null;
		if ("1".equals(type)) {
			product = new ProductA1();
			product.produce();
		} else if ("2".equals(type)) {
			product = new ProductA2();
			product.produce();
		} else if ("3".equals(type)) {
			product = new ProductB1();
			product.produce();
		} else if ("4".equals(type)) {
			product = new ProductB2();
			product.produce();
		}
		
		return product;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.mine.design.factory.simple;

public class Client {

	public static void main(String[] args) {
		// 生产产品A
		SimpleFactory.getProduct("1");

		// 生产产品A2
		SimpleFactory.getProduct("2");

		// 生产产品B1
		SimpleFactory.getProduct("3");

		// 生产产品B2
		SimpleFactory.getProduct("4");

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.2、工厂方法

product相关类参考简单工厂模式

package com.mine.design.factory.method;

import com.mine.design.factory.simple.IProduct;

public interface IFactory {
	IProduct getProduct();
}
1
2
3
4
5
6
7

package com.mine.design.factory.method;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductA1;

public class FactoryA1 implements IFactory {

	public IProduct getProduct() {
		ProductA1 product = new ProductA1();
		product.produce();
		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.mine.design.factory.method;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductA2;

public class FactoryA2 implements IFactory {

	public IProduct getProduct() {
		ProductA2 product = new ProductA2();
		product.produce();
		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.mine.design.factory.method;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductB1;

public class FactoryB1 implements IFactory {

	public IProduct getProduct() {
		ProductB1 product = new ProductB1();
		product.produce();
		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.mine.design.factory.method;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductB2;

public class FactoryB2 implements IFactory {

	public IProduct getProduct() {
		ProductB2 product = new ProductB2();
		product.produce();
		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3、抽象工厂

package com.mine.design.factory.abs;

import com.mine.design.factory.simple.IProduct;

public interface IFactory {
	IProduct getProduct(String type);
}
1
2
3
4
5
6
7

package com.mine.design.factory.abs;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductA1;
import com.mine.design.factory.simple.ProductA2;

public class FactoryA implements IFactory {

	public IProduct getProduct(String type) {
		IProduct product = null;
		if ("1".equals(type)) {
			product = new ProductA1();
			product.produce();
		} else if ("2".equals(type)) {
			product = new ProductA2();
			product.produce();
		}

		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.mine.design.factory.abs;

import com.mine.design.factory.simple.IProduct;
import com.mine.design.factory.simple.ProductB1;
import com.mine.design.factory.simple.ProductB2;

public class FactoryB implements IFactory {

	public IProduct getProduct(String type) {
		IProduct product = null;
		if ("1".equals(type)) {
			product = new ProductB1();
			product.produce();
		} else if ("2".equals(type)) {
			product = new ProductB2();
			product.produce();
		}

		return product;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.mine.design.factory.abs;

public class Client {

	public static void main(String[] args) {
		// 生产产品A
		new FactoryA().getProduct("1");

		// 生产产品A2
		new FactoryA().getProduct("2");

		// 生产产品B1
		new FactoryB().getProduct("1");

		// 生产产品B2
		new FactoryB().getProduct("2");

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20