[19/04/23-星期二] GOF23_创建型模式(工厂模式、抽象工厂模式)

一、工厂模式(分为：简单工厂模式、工厂方法模式、抽象工厂模式)

实现了创建者和调用者的分离

核心本质：1、实例化对象，用工厂方法代替new操作；2、将选择实现类、创建对象统一管理和控制，从而将调用者跟实现类解耦。

简单工厂模式：用来生产同一等级结构中的任意产品（对于增加的新的产品，需要修改已有代码）

工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）

抽象工厂模式：用来生产不同产品族中的全部产品（对于增加新的产品，无能为力。支持增加新的产品族）

【扩展】面向对象设计的基本原则(核心就是"分工")

OCP(开闭原则，Open-Closed Principle)：一个软件的实体应当对扩展开放，对修改关闭。

DIP(依赖倒转原则，Dependence Inversion Principe)：要针对接口编程，不要针对实现编程。

LoD(迪米特法则，Law of Demeter)：只与你直接的朋友通信，避免和陌生人通信(某个类尽量与少的类反生依赖关系)。

二、各种模式详解

1、简单工厂模式(静态工厂模式)

/**
 * 一个"汽车"类 接口
 */
package cn.sxt.pattern;

public interface Car {
    void run();
}

/** "奥迪"类
 *
 */
package cn.sxt.pattern;

public class Audi implements Car{

    public void run() {
        System.out.println("奥迪在跑！");
    }
}

/**
 * "比亚迪"类
 */
package cn.sxt.pattern;

public class Byd implements Car{

    public void run() {
        System.out.println("比亚迪在跑！");
    }
}

【没有采用工厂模式】

/***
 * 没有采用工厂模式的情况下
 */
package cn.sxt.pattern;

public class Test_0423_Client01 {//调用者
    public static void main(String[] args) {
        Car car=new Audi();
        Car car2=new Byd();

        car.run();
        car2.run();
    }
}

类图：

【采用简单工厂模式】

/***
 * 简单工厂模式：用来生产同一等级结构中的任意产品（对于增加的新的产品，需要修改已有代码）
 * 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
 * 抽象工厂模式：用来生产不同产品族中的全部产品（对于增加新的产品，无能为力。支持增加新的产品族）
 * 采用简单工厂模式的一个工厂，如果要增加新的子类如“红旗”类，只能修改已有的代码 ("return null") 做修改，但是违反开闭原则
 *
 */
package cn.sxt.pattern;

public class Test_0423_Factory {

    public static Car createCar(String type) {
        if ("奥迪".equals(type)) {
            return new Audi();
        }else if ("比亚迪".equals(type)) {
            return new Byd();
        }else {
            return null;
        }
    }

    //也可以采用这种方式去创建类对象所以也称它为静态方法
/*    public static Car createAudi(){
        return new Audi();
    }

    public static Car createByd() {
        return new Byd();
    }*/
}

/***
 * 采用简单工厂模式的情况下
 */
package cn.sxt.pattern;

public class Test_0423_Client02 {//调用者
    public static void main(String[] args) {
        Car car=Test_0423_Factory.createCar("奥迪");//不用直接与Audi类打交道,而是与工厂类打交道,通过调用方法new对象
        Car car2=Test_0423_Factory.createCar("比亚迪");

        car.run();
        car2.run();
    }
}

类图：

2、工厂方法模式

【一个工厂方法接口和客户类】

/***
 * 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
 */
package cn.sxt.pattern;

public interface Test_0423_Factory2 {
    Car createCar();
}

/***
 * 采用工厂方法模式的情况下
 */
package cn.sxt.pattern;
public class Test_0423_Client03 {//调用者
    public static void main(String[] args) {
        Car car=new AudiFactory().createCar();
        Car car2=new BydFactory().createCar();
        //如果要造奔驰，那么直接增加benz.java和benzFactory.java，这样不需要修改原有代码，符合开闭原则。但是会增加代码量

        car.run();
        car2.run();
    }
}

【各种车型的工厂】

/**
 * "奥迪"专门的工厂
 */
package cn.sxt.pattern;

public  class AudiFactory implements Test_0423_Factory2 {

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

}

/**
 "比亚迪"专门的工厂
 *
 */
package cn.sxt.pattern;

public class BydFactory implements Test_0423_Factory2 {

    public Car createCar() {

        return new Byd();
    }

}

类图：

3、抽象工厂模式

用来生产不同产品族的全部产品

抽象工厂模式是针对产品族的情况，在多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是个很好解决办法。

【产品族】 一个产品族：发动机、座椅、轮胎

由 高级发动机、高级座椅、高级轮胎组成一个高级产品族 ，生成一个高端汽车；

由 低级发动机、低级座椅、低级轮胎组成一个低级产品族 ，生成一个低端汽车。

【一个产品族】

/***
 * "发动机"接口
 */
package cn.sxt.abstractFactory;

public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine{ //"好发动机"类
    public void run() {
        System.out.println("转的快！");
    }
    public void start() {
        System.out.println("启动快！");
    }
}

class LowEngine implements Engine{ //"差发动机"类
    public void run() {
        System.out.println("转的慢！");
    }
    public void start() {
        System.out.println("启动慢！");
    }
}

/***
 * "座椅"接口
 */
package cn.sxt.abstractFactory;

public interface Seat {
    void comfortable();
}

class LuxurySeat implements Seat{ //"好座椅"类
    public void comfortable() {
        System.out.println("坐着舒服！");
    }
}

class LowSeat implements Seat{ //"差座椅"类
    public void comfortable() {
        System.out.println("坐着难受！");
    }
}

/***
 * "轮胎"接口
 */
package cn.sxt.abstractFactory;

public interface Tyre {
    void friction();
}

class LuxuryTyre implements Tyre{ //"好轮胎"类
    public void friction() {
        System.out.println("摩擦力大！");
    }
}

class LowTyre implements Tyre{ //"差轮胎"类
    public void friction() {
        System.out.println("摩擦力小！");
    }
}

【工厂类】

/***
 * "造汽车的工厂"接口
 */
package cn.sxt.abstractFactory;

public interface Test_0423_Factory03 {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

/**
 * //造"高端汽车"的工厂
 */
package cn.sxt.abstractFactory;

public class LuxuryCarFactory implements Test_0423_Factory03{ 

    public Engine createEngine() {
        return new LuxuryEngine();//返回好发动机的对象
    }

    public Seat createSeat() {
        return new LuxurySeat();
    }

    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

/**
 * //造"低端汽车"的工厂
 */
package cn.sxt.abstractFactory;

public class LowCarFactory implements Test_0423_Factory03{ 

    public Engine createEngine() {//返回差发动机的对象
        return new LowEngine();
    }

    public Seat createSeat() {
        return new LowSeat();
    }

    public Tyre createTyre() {
        return new LowTyre();
    }
}

【一个客户对象】

/***
 * 采用抽象工厂模式的情况下
 */
package cn.sxt.abstractFactory;

public class Test_0423_Client04 {//调用者
    public static void main(String[] args) {
        Test_0423_Factory03 factory=new LuxuryCarFactory();
        Engine engine=factory.createEngine();
        engine.run();
        engine.start();

        Test_0423_Factory03 factory2=new LowCarFactory();
        Tyre tyre=factory2.createTyre();
        tyre.friction();

    }
}

【类图】