设计模式-简单工厂、工厂方法、抽象工厂模式详解

前言

工厂模式是比较常用的设计模式，如解析xml中，jdbc连接数据库等）利用好工厂模式对程序的设计很有用处。有的书中把工厂模式分为：简单工厂、工厂方法、抽象工厂。也有把工厂方法模式划分到抽象工厂模式的，认为工厂方法是抽象工厂模式的特例的一种，就是只有一个要实现的产品接口。

我们以汽车厂家生产汽车为例,有奔驰、宝马、奥迪三个汽车厂家要生产汽车
1.简单工厂：
定义共同的接口类：

public interface Product {
	void drive();//汽车都可以用来驾驶
}

奔驰的产品：

public class BenzProduct implements Product {

	@Override
	public void drive() {
		System.out.println("驾驶奔驰");
	}

}

宝马的产品：

public class BMWproduct implements Product {

	@Override
	public void drive() {
		System.out.println("驾驶宝马");
	}
}

奥迪的产品：

public class Audiproduct implements Product {

	@Override
	public void drive() {
		System.out.println("驾驶奥迪");
	}
}

现在创建一个简单工厂类：

public class Factory {
	
	public static Product createProduct(String type){
		if(type.equals("Benz")){
			return new BenzProduct();
		}else if(type.equals("BMW")){
			return new BMWproduct();
		}else if(type.equals("Audi")){
			return new Audiproduct();
		}
	
		return null;
	}

}

现在我们想开宝马：

Product bmw=Factory.createProduct("BMW");
bmw.drive();

想开奔驰：

Product benz=Factory.createProduct("Benz");
benz.drive();

这就是简单工厂模式，在工厂类Factory 中你可以添加所需的生成产品的逻辑代码，但是问题来了，优秀的java代码是符合“开放-封闭”原则的，也就是说对扩展开发，对修改关闭，如果我现在想开兰博基尼，就要修改工厂类里的代码，增加if-else判断。对于这个问题，我们的工厂方法模式就可以解决这个问题。

2.工厂方法
上面的类可以复用
创建工厂接口类

public interface IFactory {
	public Product createProduct();

}

奔驰工厂：

public class BenzFactory implements IFactory {

	@Override
	public Product createProduct() {
		return new BenzProduct();
	}
}

宝马工厂：

public class BMWFactory implements IFactory {

	@Override
	public Product createProduct() {
		return new BMWproduct();
	}
}

现在我想开宝马：

BMWFactory factory=new BMWFactory ();
Product product = factory.createProduct();
product.drive();

工厂方法模式中我们把生成产品类的时间延迟，就是通过对应的工厂类来生成对应的产品类，在这里我们就可以实现“开发-封闭”原则，无论加多少产品类，我们都不用修改原来类中的代码，而是通过增加工厂类来实现。但是这还是有缺点的，如果产品类过多，我们就要生成很多的工厂类。假如我们要实现的产品接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族。什么是产品族呢？简单的理解就是，不同牌子产的车里面会有跑车类型，家庭类型，商用类型等的车，不同牌子的车的跑车类型的车可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。

3.抽象工厂模式

假如现在不同的汽车厂家都有不同的折扣活动，奔驰10%折扣，宝马20%折扣，奥迪30%折扣

折扣接口：

public interface Discount {
	void discount();
}

奔驰打折实现类：

public class BenzDiscount implements Discount {

	@Override
	public void discount() {
		System.out.println("奔驰打折10%");
	}

}

宝马折扣实现类：

public class BMWDiscount implements Discount {

	@Override
	public void discount() {
		System.out.println("宝马打折20%");
	}

}

抽象工厂类接口：

public interface AbstractFactory {
	Product createProduct();
	void discount();

}

奔驰工厂的实现类：

public class BenzAbstractFactory implements AbstractFactory{

	@Override
	public Product createProduct() {
		return new BenzProduct();
	}

	@Override
	public void discount() {
		BenzDiscount discount = new BenzDiscount();
		System.out.println("打折："+discount.discount());
	}

}

现在我想开奔驰并且享受10%折扣：

AbstractFactory benzFactory=new BenzAbstractFactory();
Product benzProduct = benzFactory.createProduct();
benzProduct.drive();
benzFactory.discount();

输出：

开奔驰
打折：10%

想开宝马并且享受10%折扣：

AbstractFactory bmwFactory=new BMWAbstractFactory();
Product bmwProduct = bmwFactory.createProduct();
bmwProduct.drive();
bmwProduct.discount();

输出：

开宝马
打折： 20%

抽象工厂模式中我们可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类，抽象工厂模式较好的实现了“开放-封闭”原则，是三个模式中较为抽象，并具一般性的模式。我们在使用中要注意使用抽象工厂模式的条件。