设计模式：简单工厂模式/工厂方法模式/抽象工厂模式

简单工厂模式

• 简单工厂模式：并不是23种设计模式的一种
• 而是一种常用的开发编码方式，简单来说就是编写一个类专门用来创建其他类的实例，被创建的实例通常都具有共同的父类
• 示例：创建一个鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标

类图：
示例代码实现：

/**
 * 简单工厂模式：并不是23种设计模式的一种
 * 而是一种常用的开发编码方式，简单来说就是编写一个类专门用来创建其他类的实例，被创建的实例通常都具有共同的父类
 * 示例：创建一个鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标
 */
public class SimpleFactory {
	public static void main(String[] args){
		Mouse m1 = new MouseFactory().createMouse(0);
		m1.sayHi();
		Mouse m2 = new MouseFactory().createMouse(1);
		m2.sayHi();
	}
}

//工厂类->负责创建具体鼠标类的实例
class MouseFactory{
	public Mouse createMouse(int i){
		
		Mouse mouse = null;
		
		switch (i) {
		case 0:
			mouse = new DellMouse();
			break;
		case 1:
			mouse = new HpMouse();
			break;
		default:
			break;
		}
		return mouse;
	}
}
//抽象鼠标类->父类
abstract class Mouse{
	abstract void sayHi();
}

//具体鼠标类(继承抽象父类)->戴尔鼠标
class DellMouse extends Mouse{
	@Override
	public void sayHi() {
		System.out.println("Make DellMouse");
	}
}

//具体鼠标类（继承抽象父类）->惠普鼠标
class HpMouse extends Mouse{
	@Override
	public void sayHi() {
		System.out.println("Make HpMouse");
	}
}

工厂方法（工厂模式）

• 设计模式：工厂模式（工厂方法模式）
  抽象工厂类（定义公用的抽象方法，返回抽象产品类对象）
  具体工厂类（继承抽象工厂类，各自实现其抽象方法：创建各自的具体产品实例）
  抽象产品类（定义公用的抽象方法）
  具体产品类（继承抽象产品类，各自实现其抽象方法）

• 如果我下一步想扩展，需要另外一种新产品，在不改变原来的产品和工厂的基础上，我只需要新增一种具体工厂用于创建新增的具体产品即可（满足开闭原则）

• 特点分析：
  一个抽象工厂父类可以有多个具体工厂子类
  一个抽象产品父类可以有多个具体产品子类
  但是一个具体工厂类对应一个具体产品类

类图

示例代码：

/**
* 设计模式：工厂模式（工厂方法模式）
* 抽象工厂类（定义公用的抽象方法，返回抽象产品类对象）
* 具体工厂类（继承抽象工厂类，各自实现其抽象方法：创建各自的具体产品实例）
* 抽象产品类（定义公用的抽象方法）
* 具体产品类（继承抽象产品类，各自实现其抽象方法）
* 如果我下一步想扩展，需要另外一种新产品，在不改变原来的产品和工厂的基础上，我只需要新增一种具体工厂用于创建新增的具体产品即可（满足开闭原则）
* 
* 特点分析：一个抽象工厂父类可以有多个具体工厂子类
*       一个抽象产品父类可以有多个具体产品子类
*       但是一个具体工厂类对应一个具体产品类
* 
* 
*/
public class MethodFactory {

   public static void main(String[] args){
   	//客户要产品A
   	//先创建产品A的具体工厂
   	ConcreteFactoryA concreteFactoryA = new ConcreteFactoryA();
   	//通过工厂创建具体产品对象实例
   	ConcreteProductA concreteProductA = concreteFactoryA.creatConcreteProduct();
   	//调用其中方法
   	concreteProductA.show();
   	
   	// 客户要产品B
   	// 先创建产品B的具体工厂
   	ConcreteFactoryB concreteFactoryB = new ConcreteFactoryB();
   	// 通过工厂创建具体产品对象实例
   	ConcreteProductB concreteProductB = concreteFactoryB.creatConcreteProduct();
   	// 调用其中方法
   	concreteProductB.show();
   	
   }
   
}

//抽象工厂类
abstract class AbstractFactory{
   //定义公用的抽象方法-->返回抽象产品对象
   abstract AbstracteProduct creatConcreteProduct();
}

//抽象产品类
abstract class AbstracteProduct{
   //定义公用的抽象方法
   abstract void show();
}

//具体产品类A
class ConcreteProductA extends AbstracteProduct{

   //继承抽象产品类，各自实现其抽象方法
   @Override
   public void show() {
     System.out.println("我是产品A \t 由具体工厂A创建");		
   }
   
}

//具体产品类B
class ConcreteProductB extends AbstracteProduct{

   //继承抽象产品类，各自实现其抽象方法
   @Override
   public void show() {
     System.out.println("我是产品B \t 由具体工厂B创建");		
   }
   
}

//具体工厂类A->创建具体产品A的实例
class ConcreteFactoryA extends AbstractFactory{
   //继承抽象工厂类，各自实现其抽象方法：创建各自的具体产品实例
   @Override
   public ConcreteProductA creatConcreteProduct() {
        return new ConcreteProductA();
   }
}
//具体工厂类B->创建具体产品B的实例
class ConcreteFactoryB extends AbstractFactory{

   //继承抽象工厂类，各自实现其抽象方法：创建各自的具体产品实例
   @Override
   public ConcreteProductB creatConcreteProduct() {
   	return new ConcreteProductB();
   }
}

抽象工厂方法

• 抽象工厂模式：有多个系列产品，每个系列的产品下面又有多个具体的产品
  抽象工厂父类：（生产多个系列产品的接口方法）
  具体工厂子类：（针对某一个系列的产品，对多个具体产品进行实例化）
• 示例：
  一个PC工厂,不仅生产鼠标，同时生产键盘
  具体戴尔工厂，惠普工厂都继承PC工厂，可以分别生产戴尔鼠标+戴尔键盘，惠普鼠标+惠普键盘

类图

示例代码

/**
 * 抽象工厂模式：有多个系列产品，每个系列的产品下面又有多个具体的产品
 * 抽象工厂父类：（生产多个系列产品的接口方法）
 * 具体工厂子类：（针对某一个系列的产品，对多个具体产品进行实例化）
 * 示例：一个PC工厂,不仅生产鼠标，同时生产键盘
 *    具体戴尔工厂，惠普工厂都继承PC工厂，可以分别生产戴尔鼠标+戴尔键盘，惠普鼠标+惠普键盘
 */
public class AbstractFactoryDemo {
	
	public static void main(String[] args){
		
		Mouse dellMosse = new DellFactory().createMouse();
		dellMosse.sayHi();
		Keybo dellKeybo = new DellFactory().createKeybo();
		dellKeybo.sayHi();
		
		Mouse hpMosse = new HpFactory().createMouse();
		hpMosse.sayHi();
		Keybo hpKeybo = new HpFactory().createKeybo();
		hpKeybo.sayHi();
	}
	
}

//抽象工厂父类：（生产多个系列产品的接口方法）
abstract class PcFactory{
	abstract Mouse createMouse();
	abstract Keybo createKeybo();
}

//具体戴尔工厂类
class DellFactory extends PcFactory{

	@Override
	public Mouse createMouse() {
		return new DellMouse();
	}

	@Override
	Keybo createKeybo() {
		return new DellKeybo();
	}
	
}

//具体惠普工厂类
class HpFactory extends PcFactory{

	@Override
	public Mouse createMouse() {
		return new HpMouse();
	}

	@Override
	Keybo createKeybo() {
		return new HpKeybo();
	}
	
}


//抽象鼠标类->鼠标产品父类
abstract class Mouse{
	abstract void sayHi();
}

//抽象键盘类->键盘产品父类
abstract class Keybo{
	abstract void sayHi();
}

//具体鼠标类(继承抽象鼠标父类)->戴尔鼠标
class DellMouse extends Mouse{
	@Override
	public void sayHi() {
		System.out.println("Make DellMouse");
	}
}

//具体鼠标类（继承抽象鼠标父类）->惠普鼠标
class HpMouse extends Mouse{
	@Override
	public void sayHi() {
		System.out.println("Make HpMouse");
	}
}

//具体键盘类（继承抽象键盘父类）->戴尔键盘
class DellKeybo extends Keybo{
	@Override
	public void sayHi() {
		System.out.println("Make DellKeybo");
	}
}

//具体键盘类（继承抽象键盘父类）->惠普键盘
class HpKeybo extends Keybo{
	@Override
	public void sayHi() {
		System.out.println("Make HpKeybo");
	}
}

在抽象工厂模式中，假设我们需要增加一个工厂

• 假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。
• 之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

类图

在抽象工厂模式中，假设我们需要增加一个产品

• 假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。
• 之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。

类图