本文链接： https://blog.csdn.net/weixin_42331540/article/details/102717354

一：简单工厂

1：简单工厂模式的定义：

把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类

2：简单工厂模式的特点：

违背开闭原则，不属于设计模式的一种。

3：简单工厂模式的实现：

Product：抽象产品类，将具体产品类公共的代码进行抽象和提取后封装在一个抽象产品类中。
ConcreteProduct：具体产品类，将需要创建的各种不同产品对象的相关代码封装到具体产品类中。
Factory：工厂类，提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工厂方法，该方法可以根据所传入参数的不同创建不同的具体产品对象。
Client：客户端类，只需调用工厂类的工厂方法并传入相应的参数即可得到一个产品对象。
abstract class product {
	abstract void productState();
}
class product1 extends product {
	@Override
	void productState() {
		System.out.println("简单工厂的product111");
	}
}
class product2 extends product {
	@Override
	void productState() {
		System.out.println("简单工厂的product222");
	}
}
class productFactory {
	public static product createProduct(int num) {
		switch (num) {
		case 1:return new product1();
		case 2:return new product2();
		default:break;
		}
		return null;
	}
}
public class SimpleFactory {
	public static void main(String[] args) {
		product p1 = productFactory.createProduct(1);
		product p2 = productFactory.createProduct(2);
		p1.productState();
		p2.productState();
	}
}

二：工厂方法

1：工厂方法模式的定义：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到子类中。将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。主要解决了简单工厂模式的缺点（工厂一旦需要生产新产品就需要修改工厂类的方法逻辑，违背了“开放 - 关闭原则）。

2：工厂方法模式的特点：

定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。主要是通过反射的方式创建。在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

3：工厂方法模式的实现：

product：抽象产品，具体产品的父类，描述具体产品的公共接口
concrete product：具体产品，抽象产品的子类，工厂类创建的目标类，描述生产的具体产品
Factory：抽象工厂，具体工厂的父类，描述具体工厂的公共接口
concrete Factory：具体工厂，抽象工厂的子类，被外界调用，描述具体工厂，创建产品的实例
public abstract class Product{
		public void method1{
Syso(“产品的公共业务逻辑处理”);		
	}
		public abstract void method2();
}
public class ConcreteProduct extends Product{
	public void method2(){
Syso(“自定义逻辑处理”);
}
}
public abstract class Factory{
	public abstract <T extends Product> T createProduct(Class<T> c);
}
public class ConcreteFactory extends Product{
	public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try{
product=(Product)Class.forname(c.getName()).newInstance();
}catch(Exception e){
}
return (T)product;
}
}
public class Test{
		public static void main(String[] args) {
Factory factory=new ConcreteFactory();
Product product=factory.createProduct(ConcreteProduct.class)
}
}

三：抽象工厂

1、抽象工厂模式定义：

为创建一组相关或者相互依赖的对象提供一个接口，并且无需指定他们的具体类

2、抽象工厂模式特点：

提供一个接口，用于创建相关的对象家族 。抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

3、抽象工厂模式的实现：

抽象工厂：interface ComputerFactory {
	keyboard createKeyBoard();
	mouse createMouse();
}
对象家族1：interface keyboard {
	void keyboardState();
}
对象家族2：interface mouse {
	void mouseState();
}:
class AKeyboard implements keyboard {
	@Override
	public void keyboardState() {
		System.out.println("抽象工厂Akeyboard");
	}
}
class Bkeyboard implements keyboard {
	@Override
	public void keyboardState() {
		System.out.println("抽象工厂Bkeyboard");
	}
}
class Amouse implements mouse {
	@Override
	public void mouseState() {
		System.out.println("抽象工厂Amouse");
	}
}
class Bmouse implements mouse {
	@Override
	public void mouseState() {
		System.out.println("抽象工厂Bmouse");
	}
}
对象家族1工厂：家族中每一个对象的创建和工厂方法一样
class AComputerFactory implements ComputerFactory {
	@Override
	public keyboard createKeyBoard() {
		return new AKeyboard();
	}
	@Override
	public mouse createMouse() {
		return new Amouse();
	}
}
对象家族2工厂：家族中每一个对象的创建和工厂方法一样
class BComputerFactory implements ComputerFactory {
	@Override
	public keyboard createKeyBoard() {
		return new Bkeyboard();
	}
	@Override
	public mouse createMouse() {
		return new Bmouse();}}
public class AbstractFactory {
	public static void main(String[] args) {
		ComputerFactory cfa = new AComputerFactory();
		ComputerFactory cfb = new BComputerFactory();
		cfa.createKeyBoard().keyboardState();
		cfa.createMouse().mouseState();
		cfb.createKeyBoard().keyboardState();
		cfb.createMouse().mouseState();
	}
}

工厂模式（简单工厂，工厂方法，抽象工厂）