//本文参考菜鸟教程
设计模式主要分为三大类创建型模式，结构型模式，行为型模式，本文主要讲创建型模式
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
A、创建模式（5种）
工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
1.工厂模式
定义：不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
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("没有这个产品...")
}
}
}
优点：一个调用者想创建一个对象，只要知道其名称就可以了
缺点：这样写如果新增一个phone产品就需要对工厂类进行拓展，违背了开闭原则
2.抽象工厂方法模式
定义：抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
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("没有这个产品...")
}
}
}
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("没有这个产品...")
}
}
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
}
}
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
总结
在我看来工厂模式就是，把一类对象的共性抽出来，然后创建这一类对象的时候，通过工厂类实例化统一管理，用户这样就不用关心这一类对象怎么new，直接使用工厂类创建这一类对象就行了
3.单例不介绍
4.建造者模式
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 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)
}
总结
需要生成的对象具有复杂的内部结构，其组合内部有一部分是固定的，有一部分是有复杂变化的
5.原型模式
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
没怎么用到过
