Java设计模式——工厂模式

工厂模式的简单概述：工厂模式是使用工厂方法替代new操作产生实例对象的一种设计模式
工厂模式的优势：符合软件开发中的开闭原则，并且降低了代码的耦合性

一、简单工厂模式

实质：工厂类通过工厂方法，由传入参数动态决定创建产品类的实例对象
1.抽象产品类：具有相似的行为（方法），一般声明为接口或抽象类。
2.具体产品类：继承抽象产品类，并且实现自己的行为（方法）
3.工厂类：外部类使用工厂类，通过静态方法返回具体产品类的实例对象。

先看看通过new直接创建对象

/** 奥迪汽车 */
public class AudiCar {
    public void run() {
        System.out.println("奥迪汽车的百公里加速时间为5s");
    }
}

/** 比亚迪汽车 */
public class BYDCar {
    public void run() {
        System.out.println("比亚迪汽车的百公里加速时间为7s");
    }
}

@Test
public void test(){
	/** 直接new比亚迪汽车对象，对比亚迪汽车类的对象产生直接依赖 */
	BYDCar bYDCar = new BYDCar();
	bYDCar.run();
	/**
     * 如果业务需求变更，需要一个新的版本的比亚迪汽车类，又需要new BYDCarV2类的对象实例bYDCarV2，然后bYDCarV2对象调用run()方法
     *
     * 直接new对象的缺点：
     * 1.对实例对象产生直接依赖（强依赖）
     * 2.业务需要变更时，导致其他使用地方也需要修改
     */
}

现在我们通过简单工厂模式创建对象

/** 定义汽车基类接口 */
public interface BaseCar {
    void run();
}

/** 奥迪汽车 */
public class AudiCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("奥迪汽车的百公里加速时间为5s");
    }
}

/** 比亚迪汽车 */
public class BYDCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("比亚迪汽车的百公里加速时间为7s");
    }
}

/** 创建生产汽车的工厂 */
public class CarFactory {
	/** 根据需求返回哪一种汽车的对象实例 */
    public static BaseCar getCarType(String type){
        switch (type){
            case "比亚迪汽车":
            	/** 当哪天业务升级，需要BYDCarV2版本时，可以直接修改代码：return new BYDCarV2(); */
                return new BYDCar();
            case "奥迪汽车":
                return new AuDiCar();
            default:
        }
        return null;
    }
}

@Test
public void test(){
	/** 直接new比亚迪汽车类，会对亚迪汽车类的对象产生直接依赖 */
	CarFactory car = new CarFactory();
	BaseCar bYDCar = car.getCarType("比亚迪汽车");
	bYDCar.run();
	/**
     * 使用简单工厂创建的优点：
     * 1.通过工厂创建对象，不直接依赖于具体类，而依赖于抽象类，是一种弱依赖
     * 2.业务需要变更时，需要使用的对象通过配置获取
     */
}

简单工厂模式的要点：
简单工厂模式适用于具有多态性的对象，它们往往具有相似的特性，一般继承自同一基类，或实现同一接口

二、工厂模式

对于一般的情况，一个工厂只会专门生成一种类别的产品，比如奥迪汽车工厂只会生产奥迪汽车，比亚迪汽车工厂只会生产比亚迪汽车。因此工厂模式只需要关注工厂的选择。

/** 汽车基类 */
public interface BaseCar {
    void run();
}

/** 奥迪汽车 */
public class AudiCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("奥迪汽车的百公里加速时间为5s");
    }
}

/** 比亚迪汽车 */
public class BYDCar implements BaseCar {
    @Override
    public void run() {
        System.out.println("比亚迪汽车的百公里加速时间为7s");
    }
}

/** 汽车工厂基类 */
public interface BaseCarFactory {
    BaseCar createCar();
}

/** 奥迪汽车工厂，专门生产比奥迪汽车 */
public class AudiCarFactory implements BaseCarFactory {
    @Override
    public BaseCar createCar() {
        return new AudiCar();
    }
}

/** 比亚迪汽车工厂，专门生产比亚迪汽车 */
public class BYDCarFactory implements BaseCarFactory {
    @Override
    public BaseCar createCar() {
        return new BYDCar();
    }
}

@Test
pulic void Test(){
	BaseCarFactory auDiCarFactory = new AudiCarFactory();
	BaseCarFactory bYDCarFactory = new BYDCarFactory();
	BaseCar auDiCar = auDiCarFactory.createCar();
	BaseCar bYDCar = bYDCarFactory.createCar();
	auDiCar.run();
	bYDCar.run();
}

工厂模式的要点：
在工厂模式中，用户只需要关注产品由哪种工厂生产，而不需要关注产品的具体创建过程。

三、抽象工厂模式

在系统内存在一系列相互依赖的对象，在创建这样一组对象时，使用抽象工厂模式就十分方便。以使用不同材料生产汽车各个模块来说明抽象工厂模式
1.汽车各个模块的基类

/** 汽车的发动机基类 */
public abstract class BaseEngine{
	public abstract void Create();
}

/** 汽车的坐垫基类 */
public abstract class BaseCushion{
    public abstract void Create();
}

/** 汽车的窗户基类 */
public abstract class BaseWindow{    
	public abstract void Create();
}

2.使用国外材料的汽车模块

/** 发动机(国外材料) */
public class AbroadEngine extends BaseEngine {
    @Override    
    public void Create() {
		System.out.println("使用国外材料的发动机");
    }
}

/** 坐垫(国外材料) */
public class AbroadCushion extends BaseCushion {
    @Override
    public void Create() {
		System.out.println("使用国外材料的坐垫");
	}
}

/** 窗户(国外材料) */
public class AbroadWindow extends BaseWindow {
    @Override
    public void Create() {
		System.out.println("使用国外材料的窗户");
	}
}

3.使用国产材料的汽车模块

/** 发动机(国产材料) */
public class ChineseEngine extends BaseEngine {
    @Override
    public void Create() {
		System.out.println("使用国产材料的发动机");
	}
}

/** 坐垫(国产材料) */
public class ChineseCushion extends BaseCushion {
    @Override
    public void Create() {
		System.out.println("使用国产材料的坐垫");
	}
}

/**窗户(国产材料)*/
public class ChineseWindow extends BaseWindow {
    @Override
    public void Create() {
		System.out.println("国产材料的窗户");
	}
}

4.创建基类工厂

/** 抽象工厂基类 */
public abstract class BaseFactory {    
	/** 发动机 */    
	public abstract BaseEngine CreateEngine();
	    
	/** 坐垫 */    
	public abstract BaseCushion CreateFloor();
	
	/** 窗户 */
	public abstract BaseWindow CreateWindow();

}

5.创建使用国外材料的工厂对象

/** 创建对象工厂(国外材料) */
public class AbroadFactory extends BaseFactory {
    /** 发动机(国外材料) */
    @Override
    public BaseEngine CreateEngine() {
        return new AbroadEngine();
    }

    /** 坐垫(国外材料) */
    @Override
    public BaseCushion CreateCushion() {
        return new AbroadCushion();
    }

    /** 窗户(国外材料)*/
    @Override
    public BaseWindow CreateWindow() {
        return new AbroadWindow();
    }
}

6.创建中式工厂对象

/** 创建对象工厂(国产材料) */
public class ChineseFactory extends BaseFactory {
    /** 发动机(国产材料) */
    @Override
    public BaseEngine CreateEngine() {
        return new ChineseEngine();
    }

    /** 坐垫(国产材料) */
    @Override
    public BaseCushion CreateCushion() {
        return new ChineseCushion();
    }

    /** 窗户(国产材料) */
    @Override
    public BaseWindow CreateWindow() {
        return new ChineseWindow();
    }
}

7.抽象工厂使用

@Test
public void testCreateCar() {
    //创建汽车工厂(国外材料)
    BaseFactory AbroadFactory = new AbroadFactory();
    AbroadFactory.CreateEngine().Create();
    AbroadFactory.CreateCushion().Create();
    AbroadFactory.CreateWindow().Create();

    //创建汽车工厂(国产材料)
    BaseFactory chineseFactory = new ChineseFactory();
    chineseFactory.CreateRoof().Create();
    chineseFactory.CreateFloor().Create();
    chineseFactory.CreateWindow().Create();
}

三种工厂模式的适用场景：
1.对于简单业务可以采用简单工厂模式，这也是最常用的工厂。
2.对于专业对象，建议采用工厂模式。
3.需要创建一系列相互依赖对象，建议采用抽象工厂模式。