FACTORY

工厂模式的发展史：

早期人类发展史：原始时代：纯手工劳作
	必须自己手工创建对象：类名  对象名 = new 类名(实参)；
	弊端：创建对象者与开发者同一人，考虑问题较多，麻烦：要清楚如何创建对象?(有参无参构造器)要清楚对象有哪些方法哪些参数都是什么意思?
	XXX x1 = new XXX(x1,x2);	必须请求构造器如何定义，参数是什么什么?有几个参数?
	XXX x2 = new XXX(x1,x2,x3); 
	
	
后期发展1：农业时代：会生产简单工具
	引入一台机器，生产产品。(简单工厂模式)：
	优势：使用机器代替手工创建对象，效率提高，使用机器者(开发人员)与创建对象者(工厂机器)分开(解耦)
	弊端：当需要生产更多类型、更复杂的产品时，需要修改机器。(修改简单工厂模式的代码)
	
	
后期发展2：工业时代：工厂的产生
	引入几条生产线，生产产品。(工厂方法模式)
	优势：每条生产线可以生产不同类型的产品，如果需要成产等多类型的产品，只需要新加一条生产线。
	弊端：需要生产产品类型越多，类越多，就需要创建更多的工厂。
	
	
后期发展3：信息化时代：多元化发展
	引入现代化智能工厂，客户需要不同类型的产品，根据类型将产品及工厂都分类。

简单工厂模式：

//定义工厂要创建的产品的接口，就是给产品定义规范
public interface Car {
	//什么品牌的汽车
    public void name();
    //什么颜色的汽车
    public void color();
}

//要生产的产品1
public class Benz implements  Car{
    private String name;
    private String color;
    public Benz(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}

//要生产的产品2
public class BMW implements  Car{
    private String name;
    private String color;
    public BMW(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}
//要生产的产品3
public class Audi implements  Car{
    private String name;
    private String color;
    public Audi(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}



//工厂类
public class CarFactory {
    public Car createCar(String type) throws Exception {
        if("Benz".equals(type)){
            return  new Benz("奔驰","黑色");
        }else if("BMW".equals(type)){
            return  new BMW("宝马","红色");
        }else if("Audi".equals(type)){
            return  new Audi("奥迪","白色");
        }else{
            throw  new Exception("参数错误");
        }
    }
}

//应用者：
public class Test {
    public static void main(String[] args) throws Exception {
       	CarFactory factory = new CarFactory();
        Car car = factory.createCar("BMW");
        car.name();
        car.color();
		System.out.println("=================================================");
        CarFactory factory2 = new CarFactory();
        Car car2 = factory.createCar("Audi");
        car2.name();
        car2.color();
    }
}

客户只需要关心工厂需要什么参数，传入正确的参数，就可以创建对象了，不用知道对象创建的具体过程。
弊端：需要创建更多类型的产品时，需要对该工厂模式代码进行修改。如何创建BYD汽车？只能修改工厂源码，多个判断，那就意味需要修改源码，重建工厂，不合适。所以引入工厂模式。

工厂模式(工厂方法模式)：

将工厂改成抽象类，可以新建有多个工厂，不影响老工厂。


//定义工厂要创建的产品的接口，就是给产品定义规范
public interface Car {
    public void name();
    public void color();
}
//产品1
public class Benz implements Car {
    private String name;
    private String color;
    public Benz(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}
//产品2
public class BMW implements Car {
    private String name;
    private String color;
    public BMW(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}
//产品3
public class Audi implements Car {
    private String name;
    private String color;
    public Audi(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}
//产品4
public class BYD implements Car{
    private String name;
    private String color;
    public BYD(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void name() {
        System.out.println("创建了"+name+"汽车");
    }
    public void color() {
        System.out.println("是"+color+"的");
    }
}

//工厂不再生产具体产品，变为接口
public interface CarFactory {
    public Car createCar();
}
//工厂1：
public class BeazCarFactory implements CarFactory{
    public Car createCar() {
        return new Benz("奔驰","黑色");
    }
}

//工厂2
public class BMWCarFactory implements CarFactory{
    public Car createCar() {
        return new Benz("宝马","红色");
    }
}

//工厂3
public class AudiCarFactory implements CarFactory{
    public Car createCar() {
        return new Benz("奥迪","白色");
    }
}

//工厂4
public class BYDCarFactory implements CarFactory{
    public Car createCar() {
        return new Benz("比亚的","绿色");
    }
}


//应用者
public static void main(String[] args) {
        CarFactory carFactory = new BeazCarFactory();
        Car car = carFactory.createCar();
        car.name();
        car.color();
        System.out.println("===========================");
        CarFactory carFactory2 = new BYDCarFactory();
        Car car2 = carFactory2.createCar();
        car2.name();
        car2.color();
    }

优点：需要创建的产品变化时，不需要改源码，只需要添加一个对应的工厂(类)即可，因为工厂已经变为接口，可以有多个实现类(满足大多数应用)。
缺点：当生产的产品的颜色和品牌都增加时怎么办？改为抽象工厂模式。
意味着：当产品的等级有多个分类时需要抽象工厂，当产品等级单一时工厂模式即可

抽象工厂模式：

将要生产什么类型？什么品牌？全部抽象：就是抽象工厂。

//定义产品
public interface Chanpin {
    public abstract void color();
    public abstract void pinpai();
}
//产品颜色分类1
public abstract class Chanpin1 implements Chanpin{
    public  void color(){
		System.out.println("黑色");
	}
    public abstract void pinpai();
}
//产品颜色分类2
public abstract class Chanpin2 implements Chanpin{
    public void color(){
		System.out.println("红色");
	}
    public abstract void pinpai();
}
//产品颜色分类3
public abstract class Chanpin3 implements Chanpin{
    public void color(){
		System.out.println("白色");
	}
    public abstract void pinpai();
}

//产品颜色分类1对应的具体产品1
public  class Benz extends Chanpin1{
    public void pinpai(){
    	System.out.println("生产了奔驰");
    }
}
//产品颜色分类1对应的具体产品2
public  class BMW extends Chanpin1{
    public  void pinpai(){
    	System.out.println("生产了宝马");
    }
}
//产品颜色分类1对应的具体产品3
public  class Audi extends Chanpin1{
    public void pinpai(){
    	System.out.println("生产了奥迪");
    }
}

//产品颜色分类2对应的具体产品1
public  class Benz2 extends Chanpin2{
    public  void pinpai(){
    	System.out.println("生产了奔驰");
    }
}
//产品颜色分类2对应的具体产品2
public  class BMW2 extends Chanpin2{
    public  void pinpai(){
    	System.out.println("生产了宝马");
    }
}
//产品颜色分类2对应的具体产品3
public  class Audi2 extends Chanpin2{
    public  void pinpai(){
    	System.out.println("生产了奥迪");
    }
}

//产品颜色分类3对应的具体产品1
public  class Benz3 extends Chanpin3{
    public  void pinpai(){
    	System.out.println("生产了奔驰");
    }
}
//产品颜色分类3对应的具体产品2
public  class BMW3 extends Chanpin3{
    public  void pinpai(){
    	System.out.println("生产了宝马");
    }
}
//产品颜色分类3对应的具体产品3
public  class Audi3 extends Chanpin3{
    public  void pinpai(){
    	System.out.println("生产了奥迪");
    }
}


所有的产品分类：
interface Chanpin{
	public abstract void color();
    public abstract void pinpai();
}


abstract class：
    Chanpin1:黑色
    Chanpin2:红色
    Chanpin3:白色

class:
	Benz:奔驰
	bmw:宝马
	audi:奥迪
	
	Benz2:奔驰
	bmw2:宝马
	audi2:奥迪
	
	Benz3:奔驰
	bmw3:宝马
	audi3:奥迪
====================================================


//抽象工厂:
public interface Factory {
    public Chanpin createBenz();
    public Chanpin createBMW();
    public Chanpin createAudi();
}

//抽象工厂子工厂1:
public class BlackFactory implements Factory {
    public Chanpin createBenz(){
    	return new Benz();
    }
    public Chanpin createBMW(){
    	return new BMW();
    }
    public Chanpin createAudi(){
    	return new Audi();
    }
}

//抽象工厂子工厂2:
public class RedFactory implements Factory {
    public Chanpin createBenz(){
    	return new Benz2();
    }
    public Chanpin createBMW(){
    	return new BMW2();
    }
    public Chanpin createAudi(){
    	return new Audi2();
    }
}

//抽象工厂子工厂3:
public class WhiteFactory implements Factory {
    public Chanpin createBenz(){
    	return new Benz3();
    }
    public Chanpin createBMW(){
    	return new BMW3();
    }
    public Chanpin createAudi(){
    	return new Audi3();
    }
}


public class Test{
	public static void main(String[] args){
		Factory factory1 = new WhiteFactory();
		Chanpin c1 = factory1.createBenz();
		
		Factory factory2 = new RedFactory();
		Chanpin c2 = factory2.createBMW();
		
	}
}