设计模式详解之————工厂模式（一）

引言

假设我们有一个炒饭店，我们设计的类可能是下边这个样子的：

（1）首先有个Rice的接口类，有着Rice的共性。

（2）每个种类的炒饭继承自Rice，实现接口方法。

（3）还应该有一个销售炒饭的入口，表示客户想要预订哪种炒饭。

（4）既然有销售炒饭的入口，那么也必须有生产炒饭的类。

工厂模式的概念

工厂方法模式定义了创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方案把类的实例化推迟到子类。

工厂模式的分类

• 静态（简单）工厂：

  通过静态工厂实现我们的炒饭店，基本做法是这样的：

  （1）定义Rice抽象类

package 工厂模式.静态工厂;
/**
 * Author:haozhixin
 * Func:  静态工厂
 * Date:  20190814
 */
public abstract class Rice {
	public abstract void createRice();
}
           

（2）我们这个炒饭店的所有炒饭，目前就俩（一个鸡味儿饭，一个蛋炒饭继承Rice）

package 工厂模式.静态工厂;

/**
 * Author:haozhixin
 * Func:  静态工厂
 * Date:  20190814
 */
public class ChikenRice extends Rice {
	@Override
	public void createRice() {
		System.out.println("做了个鸡味儿炒饭");
	}
}

           

package 工厂模式.静态工厂;

/**
 * Author:haozhixin
 * Func: 静态工厂
 * Date: 20190814
 */
public class EggRice extends Rice {
	@Override
	public void createRice() {
		System.out.println("做了个蛋炒饭");
	}
}

           

（3）生产炒饭的工厂（点单处）

package 工厂模式.静态工厂;

/**
 * Author:haozhixin
 * Func:
 * Date:
 */
public class SimpleRiceFactory {

	public static Rice createNoodles(int type) {
		switch (type) {
			case 1:
				return new ChikenRice();
			case 2:
				return new EggRice();
			default:
				return null;
		}
	}
	public static void main(String[] args){
		createNoodles(1);
		createNoodles(1);
	}
}

           

我们来总结下：

1 静态工厂类是一个具体的类，非接口 抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。

2 create()方法通常是静态的，所以也称之为静态工厂。

我们通过看静态工厂的例子，基本能够想到就是我们平常在开发中常用的代码书写规范，没错，是一种约定俗成的规范，而且上边的我们的实现还有一个重要的问题。

即

（1）拓展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）

（2）不同的产品需要不同额外参数的时候 不支持。 所以衍生了一种多方法静态工厂的实现，其中类是这么写的。

package 工厂模式.静态工厂;

/**
 * Author:haozhixin
 * Func: 多方法静态工厂模式
 * Date: 20190814
 */
public class MulWayFactory {
	public static Rice createChikenRice(){
		return new ChikenRice();
	}
	public static Rice createEggRice(){
		return new EggRice();
	}

	public static void main(String[] args){
		createChikenRice().createRice();
	}
}
           

• 普通工厂方法

  （1）普通工厂方法只是将简单工厂的工厂抽象出来，每一种炒饭有一个工厂类

package 工厂模式.抽象工厂;

/**
 * Author:haozhixin
 * Func: 普通工厂模式
 * Date: 20190814
 */
public abstract class RiceFactory {
	public abstract Rice create();
}

           

（2）每个炒饭有自己的工厂类

package 工厂模式.普通工厂;

/**
 * Author:haozhixin
 * Func: 普通工厂
 * Date: 20190814
 */
public class ChikenRiceFacory extends RiceFactory{
	@Override
	public Rice create() {
		return new ChikenRice();
	}
}

           

（2）每个炒饭有自己的工厂类

package 工厂模式.普通工厂;

/**
 * Author:haozhixin
 * Func: 普通工厂
 * Date: 20190814
 */
public class EggRiceFacory extends RiceFactory {
	@Override
	public Rice create() {
		return new EggRice();
	}
}

           

（3）下单的类

package 工厂模式.普通工厂;
/**
 * Author:haozhixin
 * Func: 普通工厂
 * Date: 20190814
 */
public class RiceStore {
	public static void main(String args[]){
		ChikenRiceFacory chikenRiceFacory = new ChikenRiceFacory();
		chikenRiceFacory.create().createRice();
	}
}
           

我们来总结下普通工厂的特点：

产品要抽象， 工厂也需要抽象。

工厂方法使一个产品类的实例化延迟到其具体工厂子类。

工厂方法的好处就是更拥抱变化。当需求变化，只需要增删相应的类，不需要修改已有的类。

• 抽象工厂

抽象工厂的特点是面对多产品系的类设计，这个类的结构复杂，而且使用的不恰当容易引起类爆炸，当前就不介绍了，大家能把以上的掌握了在工作中基本没什么问题。以后有机会我会把抽象工厂的应用场景结合思想及坑点来分析一下。

大家觉得不错的话点个赞哦~

作者：select you from me

来源：CSDN

转载请联系作者获得授权并注明出处。