设计模式-创建型-CSDN博客

本文链接：https://blog.csdn.net/qq_37219980/article/details/123372803

本质：创建对象的模式：对类的实例化进行抽象。

特点：1 封装了具体类的信息 ; 2 隐藏了类的实例化过程;

单例模式
简单工厂
工厂方法
抽象工厂
建造者模式
原型模式

单例模式

本质：单例模式确保一个类只有一个实例，提供一个全局访问点。

/**
 * 饿汉式
 * 1. 私有化构造方法，不让外部调用
 * 2. 内部创建私有变量 Instance，该类唯一实例。
 * 3. 提供newInstance 方法返回唯一实例。
 */
class SingletonJava1 {

    private SingletonJava1() { }

    private static SingletonJava1 ourInstance  = new  SingletonJava1();

    public static  SingletonJava1 newInstance() { return ourInstance; }
    
    public void println(String hello){ println(hello);}
}

/**
 * 懒汉式
 * 1. 私有化构造方法
 * 2. 单例引用先赋值为 NULL
 * 3. 加入同步锁（先判断单例对象是否为空，避免重复创建）
 */
class SingletonJava2 {
    private SingletonJava2() { }

    private static SingletonJava2 ourInstance = null;

    public static synchronized SingletonJava2 getInstance() {
        if (ourInstance == null) {
            ourInstance = new SingletonJava2();
        }
        return ourInstance;
    }
}

/**
 * 双重校验锁
 * 1. 私有化构造方法
 * 2. 单例引用先赋值为 NULL
 * 3. 先判断单例对象是否为空，不为空直接返回
 * 4. 为空的话同步锁内继续判断是否为空，此时为空进行单例对象的创建
 */
class SingletonJava3 {
    private SingletonJava3() { }

    private static SingletonJava3 ourInstance = null;
    
    public static SingletonJava3 newInstance() {

        if (ourInstance == null) { 
            synchronized (SingletonJava3.class) {
                if (ourInstance == null) {
                    ourInstance = new SingletonJava3();
                }
            }
        }
        return ourInstance;
    }
}

//饿汉式
object SingletonKotlin1 {
    fun println(hello: String) {
        println(hello)
    }
}

//懒汉式加入同步锁
class SingletonKotlin2 {
    private var ourInstance: SingletonKotlin2? = null

    @get:Synchronized
    val instance: SingletonKotlin2?
        get() {
            if (ourInstance == null) {
                ourInstance = SingletonKotlin2()
            }
            return ourInstance
        }
}

//双重校验锁
class SingletonKotlin3 private constructor() {
    companion object {
        val instance: SingletonKotlin3 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            SingletonKotlin3()
        }
    }
}

简单工厂

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

我们有一个咖啡工厂，可以生产美式咖啡和拿铁咖啡。

我们将咖啡生产定义成一个接口，具体生产什么咖啡由具体的实现类决定。

最后咖啡店需要什么咖啡从对应的咖啡工厂拿即可。

const val AMERICAN = "AMERICAN"
const val LATTE = "LATTE"

interface CoffeeFactory {
    fun product()
}

class AmericanCoffee : CoffeeFactory {
    override fun product() {
        println("生产美式咖啡")
    }
}

class CatCoffee : CoffeeFactory {
    override fun product() {
        println("生产拿铁咖啡")
    }
}

class CoffeeStore {
    fun getCoffee(string: String): CoffeeFactory {
        return when (string) {
            AMERICAN -> AmericanCoffee()
            LATTE -> CatCoffee()
            else -> AmericanCoffee()
        }
    }
}

工厂方法

工厂定义创建对象的公共接口，让子类负责生成具体的对象。最后使用哪个工厂调用哪个工厂。

我们有一个蛋糕店，对蛋糕进行售卖。

我们将蛋糕生产定义成一个接口，它有生产蛋糕的方法。

具体生产什么蛋糕，只要继承CakeFactory这个接口对其进行实现即可。

最后客户需要什么蛋糕，蛋糕店只需要调用对应的蛋糕工厂提供就可以了。

const val NAIYOU = "NAIYOU"
const val CAOMEI = "CAOMEI"

class Cake(private val name: String) {
    fun eat() {
        println("$name 很好吃")
    }
}

interface CakeFactory {
    fun product(): Cake
}

class NaiYouCakeFactory : CakeFactory {
    override fun product(): Cake {
        val cs = "奶油蛋糕"
        println("生产$cs")
        return Cake(cs)
    }
}

class CaoMeiCakeFactory : CakeFactory {
    override fun product(): Cake {
        val cs = "草莓蛋糕"
        println("生产$cs")
        return Cake(cs)
    }
}

class CakeStore() {

    fun orderCake(cakeFactory: CakeFactory) {
        val cake = cakeFactory.product()
        cake.eat()
    }
}

fun testCake() {
    val cakeStore = CakeStore()
    cakeStore.orderCake(NaiYouCakeFactory())
    cakeStore.orderCake(CaoMeiCakeFactory())
}

生产奶油蛋糕
生产草莓蛋糕

抽象工厂

我的理解抽象工厂是工厂的工厂，在抽象工厂中我们可以创建一系列的产品。比如甜品店不仅可以提供咖啡还能提供蛋糕。不像工厂方法中蛋糕店仅能提供蛋糕这一种产品。

interface TianPinFactory {
    fun productCoffee(type: String = ""): CoffeeFactory
    fun productCake(type: String = ""): CakeFactory
}

class TianPinStore : TianPinFactory {
    override fun productCoffee(type: String): CoffeeFactory {
        return when (type) {
            AMERICAN -> AmericanCoffee()
            LATTE -> CatCoffee()
            else -> AmericanCoffee()
        }
    }

    override fun productCake(type: String): CakeFactory {
        return when (type) {
            NAIYOU -> NaiYouCakeFactory()
            CAOMEI -> CaoMeiCakeFactory()
            else -> NaiYouCakeFactory()
        }
    }
}

fun testTianPinStore() {
    val tianPinStore = TianPinStore()
    tianPinStore.productCoffee().product()
    tianPinStore.productCoffee(LATTE).product()
    tianPinStore.productCake().product()
    tianPinStore.productCake(CAOMEI).product()
}

生产美式咖啡
生产拿铁咖啡
生产奶油蛋糕
生产草莓蛋糕

建造者模式

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

class ComputerController {
    object Computer {
        var tag = "自定義主機"
        var cpu: String = ""
        var mainboard: String = ""
        var gpu: String = ""
    }
}

class ComputerBuilder private constructor() {
    private var tag: String = ""
    private var cpu: String = ""
    private var gpu: String = ""
    private var mainboard: String = ""

    constructor(builder: Builder) : this() {
        cpu = ComputerController.Computer.cpu
        tag = ComputerController.Computer.tag
        gpu = ComputerController.Computer.gpu
        mainboard = ComputerController.Computer.mainboard
    }

    object Builder {
        fun setCPU(string: String): Builder {
            println("${ComputerController.Computer.tag} 正在组装CPU $string")
            ComputerController.Computer.cpu = string
            return this
        }

        fun setMainBoard(string: String): Builder {
            println("${ComputerController.Computer.tag} 正在组装主板 $string")
            ComputerController.Computer.mainboard = string
            return this
        }

        fun setGPU(string: String): Builder {
            println("${ComputerController.Computer.tag} 正在组装显卡 $string")
            ComputerController.Computer.gpu = string
            return this
        }

        fun create(): ComputerBuilder {
            println("${ComputerController.Computer.tag} 已安装完成 可以通知客户取货")
            return ComputerBuilder(this)
        }
    }

    fun show() {
        println("$tag $cpu $mainboard $gpu 展示")
    }
}

fun testBuilder() {
    ComputerBuilder.Builder
        .setCPU("ok")
        .setMainBoard("HD4000")
        .setGPU("GTX 650")
        .create()
        .show()
}

自定義主機正在组装CPU ok
自定義主機正在组装主板 HD4000
自定義主機正在组装显卡 GTX 650
自定義主機已安装完成可以通知客户取货
自定義主機 ok HD4000 GTX 650 展示

原型模式

用于创建重复的对象。原型模式本质是原型实例对象的clone。

原型实例需要实现Cloneable接口并覆写clone方法，实现对象的拷贝。

class Apple : Cloneable {
    var description = ""
    var images = ArrayList<String>()

    public override fun clone(): Apple {
        val clone = super.clone() as Apple
        clone.description = this.description
        clone.images = this.images.clone() as ArrayList<String>
        return clone
    }

    override fun toString(): String {
        return "$description ${hashCode()} $images"
    }
}

fun testApple() {
    val apple = Apple()
    apple.description = "红苹果"
    apple.images.add("图片1")
    apple.images.add("图片2")
    val apple2 = apple.clone()
    apple2.description = "青苹果"
    apple2.images.clear()
    apple2.images.add("图片5")
    apple2.images.add("图片6")
    println(apple.toString())
    println(apple2.toString())
    println("apple 和 apple2 是同一个对象吗？ ${apple2 === apple}")
}