工廠模式

時間 2019-12-10

標籤工廠模式简体版

原文原文鏈接

簡單工廠

定義：

　　提供一個建立對象實例的功能，而無需關心具體的實現。被建立的實例對象能夠是接口，抽象類，也能夠是具體的類

角色：

　　工廠(creator)角色ide

　　　　簡單工廠的核心，負責具體類的建立，實現建立對象的內部邏輯，返回抽象產品角色。工廠類建立產品的方法能夠被外界直接調用，建立所須要的對象。測試

　　抽象(Product)產品角色this

　　　　簡單工廠建立的全部對象的父類，它描述了全部實例所共有的公共接口。操作系統

　　具體(ConcreteProduct)產品角色對象

　　　　是簡單工廠建立的目標，所建立的對象都是具體類的實例。blog

實現：接口

　　以person爲例，具體產品爲man，women，工廠角色爲personFactory

package com.lxlyq.factoryPattern.simpleFactory;
/**
 * 抽象產品
 */
public abstract class Person {
    private String name;
    private String age;
    public abstract void seeName();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

package com.lxlyq.factoryPattern.simpleFactory;

public class Man extends Person {
    public Man() {}
    public Man(String name){
        this.setName(name);
    }
    @Override
    public void seeName() {
        System.out.println(this.getName());
    }
}

package com.lxlyq.factoryPattern.simpleFactory;

public class Women extends Person {
    public Women(){}
    public Women(String name) {
        this.setName(name);
    }
    @Override
    public void seeName() {
        System.out.println(this.getName());
    }
}

package com.lxlyq.factoryPattern.simpleFactory;

/**
 * 提供一個建立對象實例的功能，而無須關心其具體實現。被建立實例的類型能夠是接口、抽象類，也能夠是具體的類
 */
public class PersonFactory {
    public static final  int MAN = 1;
    public static final int WOMEN = 2;
    public Person createMan(int type, String name) {
        switch (type) {
            case MAN:
                return new Man(name);
            case WOMEN:
                return new Women(name);
            default:
                throw new RuntimeException("don't has type");
        }
    }
}

　　客服端調用

package com.lxlyq.factoryPattern.simpleFactory;

public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Person man = new PersonFactory().createMan(PersonFactory.MAN, "women");
        man.seeName();
    }
}

　優缺點

　　優勢：

　　客戶端只需建立一個工廠，而不用擔憂對象具體怎麼實現。

　　缺點：

　　每次增長一個產品時，都須要更改工廠類，增長case或elseif判斷建立新的產品對象，使得維護變得困難。

使用場景

工廠類負責建立的對象比較少；

客戶只知道傳入工廠類的參數，對於如何建立對象（邏輯）不關心；

因爲簡單工廠很容易違反高內聚責任分配原則，所以通常只在很簡單的狀況下應用。

注：工廠類應該只有一個，實際應用應該考慮成單例。

工廠方法

定義：

工廠方法(Factory Method)模式的意義是定義一個建立產品對象的工廠接口，將實際建立工做推遲到子類當中。

角色：

　　抽象工廠(creator)角色

　　　　工廠方法的核心，與應用程序無關。提供一公共接口建立抽象產品方法，具體的實現由具體工廠實現。

　　具體工廠(ConcreateCreator)角色

　　　　對應簡單工廠的工廠類，負責具體類的建立，實現建立對象的內部邏輯，返回抽象產品角色。工廠類建立產品的方法能夠被外界直接調用，建立所須要的對象。可是不一樣的是，一個具體工廠只建立一個產品。全部的具體工廠都必須實現抽象工廠類。

　　抽象產品(Product)角色

　　　　具體工廠建立的全部對象的父類，它描述了全部實例所共有的公共接口。抽象工廠返回的類型。

　　具體產品(ConcreteProduct)角色

　　　　這個角色實現了抽象產品角色所定義的公共接口。具體工廠建立的目標，所建立的對象都是具體類的實例。

實現：

　　以汽車工廠爲例,有寶馬工廠，有奔馳工廠，汽車抽象類，奔馳，寶馬，具體以下

package com.lxlyq.factoryPattern.factoryMethod;
/**
 * 抽象產品
 */
public abstract class Car {
    private String name;
    public abstract void driver();
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

package com.lxlyq.factoryPattern.factoryMethod;

/**
 * 寶馬
 */
public class BaoMaCar extends Car {
    {
        this.setName("baoMaCar");
    }
    @Override
    public void driver() {
        System.out.println(this.getName());
    }
}

package com.lxlyq.factoryPattern.factoryMethod;

/**
 * 奔馳
 */
public class BenCiCar extends Car {
    {
        this.setName("benCiCar");
    }
    @Override
    public void driver() {
        System.out.println(this.getName());
    }
}

package com.lxlyq.factoryPattern.factoryMethod;
/**
 * 工廠方法(Factory Method)模式的意義是定義一個建立產品對象的工廠接口，將實際建立工做推遲到子類當中。
 */

public abstract class CarFactory {
    private String carName;
    public abstract Car createCar();
    public String getCarName() {
        return carName;
    }
    public void setCarName(String carName) {
        this.carName = carName;
    }
}

package com.lxlyq.factoryPattern.factoryMethod;

/**
 * 奔馳工廠
 */
public class BenCiFactory extends CarFactory {
    {
        this.setCarName("benCi");
    }
    @Override
    public Car createCar() {
        return new BenCiCar();
    }
}

package com.lxlyq.factoryPattern.factoryMethod;

/**
 * 寶馬工廠
 */
public class BaoMaFactory extends CarFactory {
    {
        this.setCarName("baoMa");
    }
    @Override
    public Car createCar() {
        return new BaoMaCar();
    }
}

package com.lxlyq.factoryPattern.factoryMethod;

/**
 * 測試
 */
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Car baoMaCar = new BaoMaFactory().createCar();
        baoMaCar.driver();
        Car benCiCar = new BenCiFactory().createCar();
        benCiCar.driver();
    }
}

　優缺點

　　優勢：

　　客戶端不須要知道具體的產品，只有知道產品對應的工廠類。

　　增長一個產品只用增長一個具體工廠實現抽象工廠，增長一個具體產品實現抽象產品，而不用處理之前的代碼，符合開閉原則。

　　缺點：

　　產品與工廠類都是成對出現，這使得系統中的類愈來愈多。

使用場景

對於某個產品，調用者清楚須要實例化那個具體工廠來生產須要使用的實例；

調用方只是須要一種產品，而不想知道也不須要知道它由那個工廠生產。由生產者根據系統環境或其餘條件建立一個工廠返回給調用方，調用方經過工廠建立對象，這個決策對於調用方是透明的；

注：具體工廠類應該只有一個，實際應用應該考慮成單例。

抽象工廠

定義：

抽象工廠模式（Abstract Factory），提供一個建立一系列相關或互相依賴對象的接口，而無需指定它們具體的類。抽象工廠模式也稱Kit模式，它屬於類建立型模式。

角色：