總章目錄，設計模式（一）基本介紹

一、定義

工廠設計：定義一個創建對象的接口，讓子類覺得實例化哪個類，對象的統一創建交由工廠 完成 ，有良好的的封裝性。

工程模式包含以下三種類型：

二、簡單工廠

2.1、案例分析

這是我們的飲料工廠，為了對應各種飲料，通常我們會創建一個基類，通過多態來創建不同的飲料，現在我們先使用簡單工廠模式完成這部分功能。

2.2、基本介紹

簡單工廠模式是屬于創建型模式，又叫做靜態工廠方法。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。
工廠方法模式的主要角色如下:
工廠（Factory）：提供了創建產品的接口，調用者通過它訪問具體工廠的工廠方法 newProduct() 來創建產品。
具體工廠（ConcreteFactory）：主要是實現抽象工廠中的抽象方法，完成具體產品的創建。
抽象產品（Product）：定義了產品的規范，描述了產品的主要特性和功能。
具體產品（ConcreteProduct）:實現了抽象產品角色所定義的接口，由具體工廠來創建，它同具體工廠之間一一對應。

2.3、案例實現——基本工廠

Product：飲品

public interface Drinks {

    void showDes();
}

ConcreteProduct

public class ColeDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("可口可樂！");
    }
}

public class SpriteDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("雪碧！");
    }
}

public class OriginDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("橘子飲料！");
    }
}

Factory

public abstract class Factory {

    public Drinks orderDrink(String type) {
        System.out.println("點餐");
        //制作
        Drinks drinks = createDrink(type);
        drinks.showDes();
        System.out.println("打包");
        return drinks;
    }

    abstract Drinks createDrink(String  type);
}

/**
 * 可樂工廠生成可樂和雪碧
 */
public  class ColeFactory extends Factory{

    @Override
    Drinks createDrink(String type) {
        Drinks drinks = null;
        switch (type){
            case "cole":
                drinks=new ColeDrink();
            break;
            case "split":
                drinks=new SpriteDrink();
        }
        return drinks;
    }
}

public class OriginFactory extends Factory{

    @Override
    Drinks createDrink(String type) {
        Drinks drinks = null;
        switch (type){
            case "origin":
                drinks=new OriginDrink();
                break;
        }
        return drinks;
    }
}

開始購買

public class Main {
    public static void main(String[] args) {
        Factory coleFactory=new ColeFactory();
        coleFactory.orderDrink("cole");
        Factory originFactory=new OriginFactory();
        originFactory.orderDrink("origin");
    }
}

三、抽象工廠

3.1、基本介紹

抽象工廠模式：提供一個接口，用于創建相關或依賴 對象的 家族，而不需要明確指定具體類。

3.2、案例實現——抽象工廠

ProductA

public abstract class DrinksA {
   public abstract void getDrinks();
}

public class ColaA1 extends DrinksA {
    @Override
    public void getDrinks() {
        System.out.println("可樂A1");
    }
}

public class ColaA2 extends DrinksA {
    @Override
    public void getDrinks() {
        System.out.println("可樂A2");
    }
}

ProductB

public abstract class DrinksB {
   public abstract void getDrinks();
}

public class SpriteB1 extends DrinksB {
    @Override
    public void getDrinks() {
        System.out.println("雪碧B1");
    }
}

public class SpriteB2 extends DrinksB {
    @Override
    public void getDrinks() {
        System.out.println("雪碧B2");
    }
}

Factory

public interface DrinksFactory {
    DrinksA crateDrinksA();

    DrinksB crateDrinksB();
}

public class DrinksFactoryA1 implements DrinksFactory {
    @Override
    public DrinksA crateDrinksA() {
        return new ColaA1();
    }

    @Override
    public DrinksB crateDrinksB() {
        return new SpriteB1();
    }
}


public class DrinksFactoryA2 implements DrinksFactory {
    @Override
    public DrinksA crateDrinksA() {
        return new ColaA2();
    }

    @Override
    public DrinksB crateDrinksB() {
        return new SpriteB2();
    }
}

測試

public class FactoryTest {

    @Test
    public void FactoryTest(){
        DrinksFactory drinksFactoryA1=new DrinksFactoryA1();
        DrinksA drinksA = drinksFactoryA1.crateDrinksA();
        DrinksB drinksB = drinksFactoryA1.crateDrinksB();
        drinksA.getDrinks();
        drinksB.getDrinks();

       new DrinksFactoryA2().crateDrinksA().getDrinks();

    }
}

打?。?可樂A1
雪碧B1
可樂A2