轻松掌握工厂模式的三种实现方案（简单工厂、工厂方法、抽象工厂）

提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离

包括简单工厂模式、工厂方法模式、抽象工厂模式三种。

1、简单工厂

简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）

• 简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。

//创建工厂

public interface Car {
	public void run();
}


// 创建工厂的产品（宝马）

public class Bmw implements Car {
	public void run() {
		System.out.println("我是宝马汽车...");
	}
}

//创建工另外一种产品（奥迪）

public class AoDi implements Car {
	public void run() {
		System.out.println("我是奥迪汽车..");
	}
}



//创建核心工厂类，由他决定具体调用哪产品
// 工厂类集中了所有实例的创建逻辑，容易违反高内聚的责任分配原则
public class CarFactory {

	 public static Car createCar(String name) {
		if ("".equals(name)) {
             return null;
		}
		if(name.equals("奥迪")){
			return new AoDi();
		}
		if(name.equals("宝马")){
			return new Bmw();
		}
		return null;
	}
}


//演示创建工厂的具体实例

public class Client01 {

	public static void main(String[] args) {
		Car aodi  =CarFactory.createCar("奥迪");
		Car bmw  =CarFactory.createCar("宝马");
		aodi.run();
		bmw.run();
	}
}

2、工厂方法

工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）

工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

//创建工厂

public interface Car {
	public void run();
}

// 创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法）
public interface CarFactory {

	Car createCar();

}

// 创建工厂的产品（奥迪）
public class AoDi implements Car {
	public void run() {
		System.out.println("我是奥迪汽车..");
	}
}
// 创建工厂另外一种产品（宝马）
public class Bmw implements Car {
	public void run() {
		System.out.println("我是宝马汽车...");
	}
}

// 创建工厂方法调用接口的实例（奥迪）
public class AoDiFactory implements CarFactory {

	public Car createCar() {
	
		return new AoDi();
	}
}

// 创建工厂方法调用接口的实例（宝马）
public class BmwFactory implements CarFactory {

	public Car createCar() {

		return new Bmw();
	}

}


// 演示创建工厂的具体实例
public class Client {

	public static void main(String[] args) {
		Car aodi = new AoDiFactory().createCar();
		Car jili = new BmwFactory().createCar();
		aodi.run();
		jili.run();
	}
}

3、抽象工厂

抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。

// 创建第一个子工厂，及实现类
//汽车
public interface Car {
	   void run();
}

 class CarA implements Car{

	public void run() {
		System.out.println("宝马");
	}
	
}
 class CarB implements Car{

	public void run() {
		System.out.println("摩拜");
	}
	
}

// 创建第二个子工厂，及实现类
/发动机
public interface Engine {

    void run();

}

class EngineA implements Engine {

    public void run() {
        System.out.println("转的快!");
    }

}

class EngineB implements Engine {

    public void run() {
        System.out.println("转的慢!");
    }

}

// 创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）
public interface TotalFactory {
	// 创建汽车
	Car createChair();
	// 创建发动机
	Engine createEngine();
}

//总工厂实现类，由他决定调用哪个工厂的那个实例
class TotalFactoryReally implements TotalFactory {

	public Engine createEngine() {

		return new EngineA();
	}

	public Car createChair() {

		return new CarA();
	}
}

// 运行测试
public class Test {

    public static void main(String[] args) {
        TotalFactory totalFactory2 = new TotalFactoryReally();
        Car car = totalFactory2.createChair();
        car.run();

        TotalFactory totalFactory = new TotalFactoryReally();
        Engine engine = totalFactory.createEngine();
        engine.run();
    }
}