设计模式总结之工厂模式-java实现

这是针对面试的解答：

这是面试经常会被问到的设计模式，工程模式分为简单工厂模式（simple factory 静态工厂模式）、工厂方法模式（factory method）、抽象工厂模式（abstract factory）

其中后两者属于23种常用的设计模式。简单工厂模式不属于23种常用的设计模式。

首先让我们来看下简单工厂模式：

工厂模式就是来生成对象的

比如说一个娃娃工厂就是生产娃娃对象的。

分为一个产品接口（Interface Product）

多个具体的产品实现类（ProductA implements Product    ProductB implements Product ......等等具体产品类）---ConcreteProduct

一个工厂类(具体决定生产哪个产品，主要由里面的方法根据传入的参数来决定生产哪个产品)--Creator(或者叫做Factory)

首先来一个Product 接口

public interface Product {

	public void name();
}

然后来几个具体的产品类来实现Product接口（你可以继续来C，D等等产品，这个看到时候的具体需求）

public class ProductA implements Product{

	@Override
	public void name() {
		System.out.println("I'm ProductA!");
	}

}

public class ProductB implements Product{

	@Override
	public void name() {
		System.out.println("I'm ProductB！");
	}

}

最后来一个factory类来实现具体要生产什么产品，根据传入的参数来决定生产第几种产品

public class Factory {

	public static Product Create(int type){
		if(type == 1){
			return new ProductA();
		}else if(type == 2){
			return new ProductB();
		}else
			return null;
	}
}

简单工厂类是不是就这么搞定了，是不是很简单，连我这枚菜鸟都觉得so easy 

让我们来总结下简单工厂类的优劣吧：

简单工厂总的来说违反了开闭原则，在新增产品的话，你factory类就必须修改了。。。。OO原则之开闭原则：对修改关闭，对扩展开放。

然后下面是自己总结的工厂方法模式：

总的来说，工厂方法模式已经没有违反闭合原则，针对接口编程

相比简单工厂模式，工厂方法模式把工厂类也抽象了，成为了一个抽象工厂类或者接口工厂，要生产哪种产品就实现那个那个产品的生产类（工厂类）

首先让我们来看下 

product 接口（或者可以是抽象类）

public interface Product {
	public void ProductName();
}

然后来两个实现此接口的具体产品类

public class ProductA implements Product{

	@Override
	public void ProductName() {
		System.out.println("I'm productA");
	}

}

public class ProductB implements Product{

	@Override
	public void ProductName() {
		System.out.println("I'm productB!");
	}

}

然后再是抽象工厂（接口||抽象类）

public interface Factory {
	public void FactoryName();
	public Product Create();
}

再来两个与具体产品想对应的工厂生产类（一一对应，里面有生产产品方法Create）

public class FactoryA implements Factory{

	@Override
	public void FactoryName() {
		System.out.println("I'm FactoryA");
	}

	@Override
	public Product Create() {
		return new ProductA();
	}

}

public class FactoryB implements Factory{

	@Override
	public void FactoryName() {
		System.out.println("I'm factoryB");
	}

	@Override
	public Product Create() {
		return new ProductB();
	}

}

到此为止简单的工厂方法模式就实现了，我们来个test方法吧

public class Test {

	public static void main(String[] args) {
		Factory a = new FactoryA();
		Product pa = a.Create();
		pa.ProductName();
		
		Factory b = new FactoryB();
		Product pb = b.Create();
		pb.ProductName();
	}

}

输出结果为：
I'm productA
I'm productB!

抽象工厂模式与工厂方法模式有点不太的地方就是他具有多个抽象产品，而工厂方法模式则只有一个抽象产品（换一句话说，工厂方法模式只是极端情况下的抽象工厂模式——抽象产品只有一种的抽象工厂模式）

首先我们来两个抽象产品（类或者接口） ProductA  & ProductB

public interface ProductA {
	public void ProductAName();
}
public interface ProductB {
	public void ProductBName();
}

然后针对两个产品分别来两个具体产品类 ProductA1,A2 & ProductB1,B2具体实现ProductA,B抽象产品

public class ProductA1 implements ProductA{

	@Override
	public void ProductAName() {
		System.out.println("I'm ProductA1 !");
	}

}
public class ProductA2 implements ProductA{
	@Override
	public void ProductAName() {
		System.out.println("I'm ProductA2 !");
	}
}
public class ProductB1 implements ProductB{

	@Override
	public void ProductBName() {
		System.out.println("I'm ProductB1 !");
	}

}
public class ProductB2 implements ProductB{
	@Override
	public void ProductBName() {
		System.out.println("I'm ProductB2 !");
	}
}

然后再来一个抽象工厂Factory

public interface Factory {
	public ProductA getProductA();
	public ProductB getProductB();
}

接着来两个具体工厂Factory1,2来实现Factory

public class Factory1 implements Factory{

	@Override
	public ProductA getProductA() {
		return new ProductA1();
	}

	@Override
	public ProductB getProductB() {
		return new ProductB1();
	}

}
public class Factory2 implements Factory{

	@Override
	public ProductA getProductA() {
		return new ProductA2();
	}

	@Override
	public ProductB getProductB() {
		return new ProductB2();
	}
	
}

这样 一个抽象工厂就大功告成了！

然后让我们来Test一下吧

public class Test {

	public static void main(String[] args) {
		Factory a = new Factory1();
		Factory b = new Factory2();
		
		ProductA pa1 = a.getProductA();
		ProductB pb1 = a.getProductB();
		ProductA pa2 = b.getProductA();
		ProductB pb2 = b.getProductB();
		
		pa1.ProductAName();
		pb1.ProductBName();
		pa2.ProductAName();
		pb2.ProductBName();
	}

}
输出为：
I'm ProductA1 !
I'm ProductB1 !
I'm ProductA2 !
I'm ProductB2 !

这样工厂模式就结束了。面试应该也没问题了。。。