//本文參考菜鳥教程
設(shè)計模式主要分為三大類創(chuàng)建型模式，結(jié)構(gòu)型模式，行為型模式，本文主要講創(chuàng)建型模式
創(chuàng)建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

A、創(chuàng)建模式（5種）

工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

1.工廠模式

定義：不會對客戶端暴露創(chuàng)建邏輯，并且是通過使用一個共同的接口來指向新創(chuàng)建的對象。

interface Phone {
    fun call()
}

class HuaWei : Phone {
    override fun call() {
        println("HuaWei")
    }
}

class SanXing : Phone {
    override fun call() {
        println("mate40")
    }
}

class PhoneFactory {
    fun getiPhone(phoneType: String?): Phone {
        return if ("SanXing".equals(phoneType, ignoreCase = true)) {
            HuaWei()
        } else if ("HuaWei".equals(phoneType, ignoreCase = true)) {
            SanXing()
        } else {
            throw RuntimeException("沒有這個產(chǎn)品...")
        }
    }
}

優(yōu)點：一個調(diào)用者想創(chuàng)建一個對象，只要知道其名稱就可以了
缺點：這樣寫如果新增一個phone產(chǎn)品就需要對工廠類進行拓展，違背了開閉原則

2.抽象工廠方法模式

定義：抽象工廠模式（Abstract Factory Pattern）是圍繞一個超級工廠創(chuàng)建其他工廠。該超級工廠又稱為其他工廠的工廠。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。
在抽象工廠模式中，接口是負責創(chuàng)建一個相關(guān)對象的工廠，不需要顯式指定它們的類。每個生成的工廠都能按照工廠模式提供對象。

interface Phone {
    fun call()
}

class HuaWei : Phone {
    override fun call() {
        println("HuaWei")
    }
}

class SanXing : Phone {
    override fun call() {
        println("mate40")
    }
}


interface Ipad {
    fun play()
}

class MeiZhu : Ipad {
    override fun play() {
        println("MeiZhu")
    }
}

class Xiaomi : Ipad {
    override fun play() {
        println("Xiaomi")
    }
}

abstract class ElectronicProduct {
    abstract fun getPhone(type: String): Phone?
    abstract fun getIpad(type: String): Ipad?
}

class IpadFactory : ElectronicProduct() {

    override fun getPhone(type: String): Phone? = null

    override fun getIpad(type: String): Ipad {
        return if ("MeiZhu".equals(type, ignoreCase = true)) {
            MeiZhu()
        } else if ("Xiaomi".equals(type, ignoreCase = true)) {
            Xiaomi()
        } else {
            throw RuntimeException("沒有這個產(chǎn)品...")
        }
    }
}

class PhoneFactory : ElectronicProduct() {
    
    override fun getPhone(type: String): Phone {
        return if ("SanXing".equals(type, ignoreCase = true)) {
            HuaWei()
        } else if ("HuaWei".equals(type, ignoreCase = true)) {
            SanXing()
        } else {
            throw RuntimeException("沒有這個產(chǎn)品...")
        }
    }
    
    override fun getIpad(type: String): Ipad? = null
}

object FactoryProducer {
    fun getFactory(choice: String): ElectronicProduct? {
        if (choice.equals("Phone", ignoreCase = true)) {
            return PhoneFactory()
        } else if (choice.equals("Ipad", ignoreCase = true)) {
            return IpadFactory()
        }
        return null
    }
}

優(yōu)點：當一個產(chǎn)品族中的多個對象被設(shè)計成一起工作時，它能保證客戶端始終只使用同一個產(chǎn)品族中的對象。
缺點：產(chǎn)品族擴展非常困難，要增加一個系列的某一產(chǎn)品，既要在抽象的 Creator 里加代碼，又要在具體的里面加代碼。

總結(jié)

在我看來工廠模式就是，把一類對象的共性抽出來，然后創(chuàng)建這一類對象的時候，通過工廠類實例化統(tǒng)一管理，用戶這樣就不用關(guān)心這一類對象怎么new，直接使用工廠類創(chuàng)建這一類對象就行了

3.單例不介紹

4.建造者模式

建造者模式（Builder Pattern）使用多個簡單的對象一步一步構(gòu)建成一個復(fù)雜的對象。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。
一個 Builder 類會一步一步構(gòu)造最終的對象。該 Builder 類是獨立于其他對象的。參考android的alertdialog

interface Packing {
    fun pack(): String
}

class Wrapper : Packing {
    override fun pack(): String = "Wrapper"
}

class Bottle : Packing {
    override fun pack(): String = "Bottle"
}

interface Item {
    fun name(): String
    fun packing(): Packing
    fun price(): Float
}

abstract class Burger : Item {
    override fun packing(): Packing = Wrapper()
    abstract override fun price(): Float
}

class VegBurger:Burger(){
    override fun price(): Float = 2.5f
    override fun name(): String = "VegBurger"
    override fun packing(): Packing {
        return super.packing()
    }
}

abstract class ColdDrink : Item {
    override fun packing(): Packing = Bottle()
    abstract override fun price(): Float
}


class ChickenBurger : Burger() {
    override fun price(): Float {
        return 50.5f
    }
    override fun name(): String {
        return "Chicken Burger"
    }
}

class Coke : ColdDrink() {
    override fun price(): Float {
        return 30.0f
    }

    override fun name(): String {
        return "Coke"
    }
}

class Pepsi : ColdDrink() {
    override fun price(): Float {
        return 35.0f
    }

    override fun name(): String {
        return "Pepsi"
    }
}

class Meal {
    private val items: MutableList<Item> = ArrayList()
    fun addItem(item: Item) {
        items.add(item)
    }

    val cost: Float
        get() {
            var cost = 0.0f
            for (item in items) {
                cost += item.price()
            }
            return cost
        }

    fun showItems() {
        for (item in items) {
            print("Item : " + item.name())
            print(", Packing : " + item.packing().pack())
            println(", Price : " + item.price())
        }
    }
}

class MealBuilder {
    fun prepareVegMeal(): Meal {
        val meal = Meal()
        meal.addItem(VegBurger())
        meal.addItem(Coke())
        return meal
    }

    fun prepareNonVegMeal(): Meal {
        val meal = Meal()
        meal.addItem(ChickenBurger())
        meal.addItem(Pepsi())
        return meal
    }
}

fun main() {
    val mealBuilder = MealBuilder()
    val vegMeal = mealBuilder.prepareVegMeal()
    println("Veg Meal")
    vegMeal.showItems()
    println("Total Cost: " + vegMeal.cost)
    val nonVegMeal = mealBuilder.prepareNonVegMeal()
    println("\n\nNon-Veg Meal")
    nonVegMeal.showItems()
    println("Total Cost: " + nonVegMeal.cost)
}

總結(jié)

需要生成的對象具有復(fù)雜的內(nèi)部結(jié)構(gòu)，其組合內(nèi)部有一部分是固定的，有一部分是有復(fù)雜變化的

5.原型模式

原型模式（Prototype Pattern）是用于創(chuàng)建重復(fù)的對象，同時又能保證性能。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。這種模式是實現(xiàn)了一個原型接口，該接口用于創(chuàng)建當前對象的克隆。當直接創(chuàng)建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數(shù)據(jù)庫操作之后被創(chuàng)建。我們可以緩存該對象，在下一個請求時返回它的克隆，在需要的時候更新數(shù)據(jù)庫，以此來減少數(shù)據(jù)庫調(diào)用。
沒怎么用到過