Java设计模式之工厂设计模式

面试题，说一下工厂设计模式：

发一篇博客来总结一下：

1. 简单工厂

interface Car{
}
class BMWCar implements Car{
BMWCar(){
System.out.println("宝马车被制造了。。");
}
}
class AudiCar implements Car{
AudiCar(){
System.out.println("奥迪车被制造了。。");
}
}
public class SimpleCarFactory {
public static final int BMWCAR = 1;
public static final int AUDICAR = 2;
public static Car produceCar(int carType) throws Exception{
switch (carType) {
case BMWCAR:
return new BMWCar();
case AUDICAR:
return new AudiCar();
default:
throw new Exception("没有这种车");
}
}
public static void main(String[] args) {

try {
SimpleCarFactory.produceCar(SimpleCarFactory.BMWCAR);
} catch (Exception e) {
e.printStackTrace();
}
}
}

上面的代码实现了一个简单工厂，传入需要制造的车的类型返回相应的实例，但是简单工厂存在许多缺陷，首先，添加新的车的种类的时候需要修改源代码。其次，也是最大的缺点就是整个系统全都依赖SimpleCarFactory,如果SimpleCarFactory类一旦出现问题，那么整个系统就变成了瘫痪状态。我们可以通过下面两种方式来谋求解决方案。

2. 工厂方法

重复代码我就不写了，看简单工厂代码
interface Factory{
Car create();
}
class BMWCarFactory implements Factory{
@Override
public Car create() {
return new BMWCar();
}
}
class AudiCarFactory implements Factory{
@Override
public Car create() {
return new AudiCar();
}
}
public class TestFactory {

public static void main(String[] args) {
Factory factory = new BMWCarFactory();
factory.create();
}
}

工厂方法有效的解决了上面简单工厂存在的问题，如果新加入一个车和一个车的工厂不需要更改源代码，而且如果一个工厂类出现了问题不会影响到其他工厂类的使用。

新添加一个车和工厂

class AUTOCar implements Car{
AUTOCar(){
System.out.println("奥拓车被制造了。。");
}
}
class AUTOCarFactory implements Factory{
@Override
public Car create() {
return new AUTOCar();
}
}

目前为止已经解决了上面的问题，下面问题又来了，因为相同的车同样还有型号不同的时候，不同型号的车的配件各有不同，可以通过抽象工厂来解决。

3. 抽象工厂

interface Car{}
abstract class BMWCar implements Car {
}
class BMWX3 extends BMWCar {
BMWX3() {
System.out.println("BMWX3车被制造了。。");
}
}
class BMWX5 extends BMWCar {
BMWX5() {
System.out.println("BMWX5车被制造了。。");
}
}
interface Chair{
}
class BMWX3Chair implements Chair{
BMWX3Chair() {
System.out.println("BMWX3的座椅被制造了。。");
}
}
class BMWX5Chair implements Chair{
BMWX5Chair() {
System.out.println("BMWX5的座椅被制造了。。");
}
}
interface Window{}
class BMWX3Window implements Window{
BMWX3Window() {
System.out.println("BMWX3的车窗被制造了。。");
}
}
class BMWX5Window implements Window{
BMWX5Window() {
System.out.println("BMWX5的车窗被制造了。。");
}
}
interface Factory {
Car create();
}
abstract class BMWCarFactory implements Factory {
abstract Chair createChair();
abstract Window createWindow();
}
class BMWX3CarFactory extends BMWCarFactory{
@Override
public Car create() {
return new BMWX3();
}
@Override
Chair createChair() {
return new BMWX3Chair();
}
@Override
Window createWindow() {
return new BMWX3Window();
}
}
class BMWX5CarFactory extends BMWCarFactory{
@Override
public Car create() {
return new BMWX5();
}
@Override
Chair createChair() {
return new BMWX5Chair();
}
@Override
Window createWindow() {
return new BMWX5Window();
}
}
public class TestAbstractFactory {

public static void main(String[] args) {
BMWCarFactory factory = new BMWX3CarFactory();
factory.createWindow();
factory.createChair();
factory.create();
}
}

总结：

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。