[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();

    }

}

【类图】

巴特西

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

最新文章

热门文章