设计模式适配场景
设计模式共有23种，根据目的准则分类，分为三大类、、
创建型设计模式 / 结构性设计模式 / 行为型设计模式
创建型设计模式 5种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
结构型设计模式 7种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型设计模式 11种：策略模式、模版方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式，解释器模式、、
接下来都将使用 kotlin做演示
一 大类：创建型设计模式
- 单例模式
单例的创建方式有很多种，不管是ios 或 android，但是我们要的是结果而不是你会很多种（最终的结果是相同的，所以没有意义，有的只是扯淡浪费时间罢了），我只要你那一种
Ktlin 中 Object 创建的类就是单例
- 简单工厂模式 & 抽象类工厂模式
- 抽象类
open class Computer {}
- 具体产品类
class AppleComputer: Computer(){
}
- 工厂类
abstract class Computer {
open fun start(){
println(" 原始型号计算机正在启动..")
}
enum class CType{
apple,
huawei,
sanxing,
huipu,
huasuo
}
}
class AppleComputer:Computer(){
override fun start() {
println("苹果XX型号计算机正在启动..")
}
}
class HuaweiComputer:Computer() {
override fun start() {
println("华为XX型号计算机正在启动..")
}
}
class ComputerFactory {
companion object {
val createComputer = { what:Computer.CType ->
when(what){
Computer.CType.apple -> AppleComputer()
Computer.CType.huawei -> HuaweiComputer()
Computer.CType.sanxing -> TODO()
Computer.CType.huipu -> TODO()
Computer.CType.huasuo -> TODO()
}
}
}
}
- 建造者模式 + 代理模式
// 1. 创建产品原型类
class ComputerCore(var coreCPU:String = "",var coreMainBoard:String = "",var coreRam:String = "") {
init{
}
}
// 2. 创建Builder类，规范产品的组建
interface BuilderCore {
fun buildCPU(cpu:String)
fun buildMainboard(board:String)
fun buildRam(ram:String)
fun create():ComputerCore
}
// 3.创建 MoonComputerBuilder 用于生产计算机
class MoonComputerBuilder:BuilderCore {
private val computer = ComputerCore()
override fun buildCPU(cpu: String) {
computer.mCpu = cpu
}
override fun buildMainboard(board: String) {
computer.mBoard = board
}
override fun buildRam(ram: String) {
computer.coreRam = ram
}
override fun create(): ComputerCore {
return computer
}
}
// 4. 用集成类统一组装过程
class CombineCore(val build:BuilderCore) {
var mBuild:BuilderCore? = null
init {
mBuild = build
}
fun CombineComputer(core:ComputerCore):ComputerCore? {
mBuild.let {
it?.buildCPU(core.mCpu)
it?.buildMainboard(core.mBoard)
it?.buildRam(core.mRam)
return it?.create()
}
}
}
// 5. 客户端持有组装好的计算机
class HoldComputer {
companion object {
// 这里的build只需要创建一次可以复用
val mBuilder = MoonComputerBuilder()
fun hold(cpu: String,board: String,ram: String):ComputerCore?{
// 生产同一种类型的产物只需要一条产线就可以了
val core = ComputerCore(cpu,board,ram)
val computer = CombineCore(mBuilder).CombineComputer(core)
return computer
}
}
}
// 6. 使用
fun HoldMainActivity(){
val computer = HoldComputer.hold("M2","apple mac pro","samsung")
}
- 动态代理设计模式
// 1.创建代理实现类
interface Shop {
fun buy()
}
class Hong:Shop {
override fun buy() {
println("我就不买...")
}
}
// 2.动态代理实现类
class DynamicPurchasing(obj:Any? = null):InvocationHandler {
var obj:Any?
init {
this.obj = obj
}
override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
val result = method?.invoke(obj,args)
if (method?.name == "buy") {
println("买买买...")
}
result.let {
return it!!
}
}
}
class ClientToBuy {
val hong = Hong()
val dynamicProxy = DynamicPurchasing(hong)
val loader:ClassLoader = hong.javaClass.classLoader
val what = (Proxy.newProxyInstance(loader, arrayOf(Shop::class.java),dynamicProxy) as Shop).buy()
}
- 装饰设计模式 (动态扩展一个对象的能力，是继承的替代方案之一)
// 1. 抽象组件
abstract class KungfuModel {
abstract fun attacMagic()
}
// 2. 组件具体实现类
class JasonStatham:KungfuModel(){
override fun attacMagic() {
println("这位硬汉貌似很能啊...")
}
}
// 3. 抽象装饰者 (大师需要了解杰森斯坦森)
abstract class MasterOf(jason:JasonStatham? = null):KungfuModel(){
private var jason:JasonStatham? = null
init {
this.jason = jason
}
override fun attacMagic() {
jason?.attacMagic()
}
}
// 4. 装饰着的具体实现（史泰龙是功夫大师）
class Stallone(kungfu:KungfuModel):MasterOf(jason = kungfu as JasonStatham){
var kungFu:KungfuModel? = null
init {
this.kungFu = kungfu
}
fun teachAttackMagic(){
println("史泰龙教你打飞机..")
println("杰森斯坦森学会了打飞机")
}
override fun attacMagic() {
super.attacMagic()
teachAttackMagic()
}
}
class JetLi(kungfu: KungfuModel):MasterOf(jason = kungfu as JasonStatham){
var kungfu:KungfuModel? = null
init {
this.kungfu = kungfu
}
fun teachAttackMagic(){
println("李连杰教你九阳神功..")
println("杰森斯坦森学会了九阳神功")
println("此后打飞机更厉害了，哈哈哈")
}
override fun attacMagic() {
super.attacMagic()
teachAttackMagic()
}
}
// 5. 客户端调用
class ClientOfHong {
// 创建杰森斯坦森
val jason = JasonStatham()
// 史泰龙传授杰森打飞机的技巧
val stallone = Stallone(jason).let {
it.attacMagic()
}
// 李连杰传授杰森九阳神功，避免玩得太虚了
var jetLi = JetLi(jason).let {
it.attacMagic()
}
}
- 6.外观设计模式 (以掌握的技能做推导)
// UI系统、语言系统、网络系统
class TechnologyForUI{
fun masteringTechnologyForUIKit(){
println("掌握UIkit技术")
}
fun masteringTechnologyForSwiftUI(){
println("掌握SwiftUI技术")
}
fun masteringTechnologyForComposeUI(){
println("掌握ComposeUI技术")
}
}
class TechnologyForLanguage {
fun masteringTechnologyForCPP(){
println("掌握C++技术")
}
fun masteringTechnologyForSwift(){
println("掌握Swift技术")
}
fun masteringTechnologyForKotlin(){
println("掌握Kotlin技术")
}
}
class TechnologyForNet {
fun masteringTechnologyAlamofire(){
println("掌握Alamofire技术")
}
fun masteringTechnologyAFNetWorking(){
println("掌握AFNetWorking技术")
}
fun masteringTechnologyRetrofit(){
println("掌握Retrofit技术")
}
}
// 外观类
class TechnologyOfHong {
private var uiTechnology:TechnologyForUI? = null
private var lgTechnology:TechnologyForLanguage? = null
private var ntTechnology:TechnologyForNet? = null
init {
uiTechnology = TechnologyForUI()
lgTechnology = TechnologyForLanguage()
ntTechnology = TechnologyForNet()
}
//使用技能
fun useSkills(){
lgTechnology?.let {
it.masteringTechnologyForSwift()
it.masteringTechnologyForKotlin()
}
uiTechnology?.let {
it.masteringTechnologyForSwiftUI()
it.masteringTechnologyForComposeUI()
}
ntTechnology?.let {
it.masteringTechnologyAlamofire()
it.masteringTechnologyRetrofit()
}
}
}
// 客户端调用
class ClientFetchTechnology {
val hong = TechnologyOfHong().let {
it.useSkills()
}
}
- 7.享元设计模式
// 享元模式是池技术的重要实现方式，可以减少程序创建的对象，降低程序内存的占用，提高程序性能
// 定义：使用共享对象有效地的支持大量细粒度的对象（相当于现在的女孩子，都有很多老公。。）
要求细粒度对象，那么不可避免地会使得对象数量多且性质相近。这些对象分为两个部分：
- 内部状态和外部状态。
- 内部状态：是对象可以共享出来的信息，存储在享元对象的内部并且不会跟随环境的改变而改变。
- 外部状态：是对象依赖的一个标记，它是随着环境的改变而改变，并且不可以共享的状态。
interface FlyweightRole {
fun showWhat(what:String)
}
class ConcreteFlyweightRole(name: String = ""):FlyweightRole{
private var name:String = ""
private var version:String = ""
init {
this.name = name
}
override fun showWhat(what: String) {
when(what){
"32G" -> println("price is 5199")
"128G" -> println("price is 5999")
}
}
}
// 享元工厂
class FlyweightFactory {
companion object {
private val pool:MutableMap<String,ConcreteFlyweightRole> = HashMap<String,ConcreteFlyweightRole>()
fun getConcreteFlyweightRoles(key: String):ConcreteFlyweightRole? {
if (pool.containsKey(key)) {
return pool.get(key)
} else {
return pool.getOrPut(key){// 添加一个当前key的键值对，并且返回value
return null
}
}
}
}
}
// 客户端调用
class ClientForFlyweight {
val ff1 = FlyweightFactory.getConcreteFlyweightRoles("iphone 13").let {
it?.showWhat("32G")
}
val ff2 = FlyweightFactory.getConcreteFlyweightRoles("iphone x pro").let {
it?.showWhat("128G")
}
}
行为设计模式
- 策略设计模式
好处：隐藏具体策略的实现细节，彼此完全独立
坏处：一个策略一个类，复用性小（但其实我们真正要隐藏的细节没那么多，OK）
interface FightingStrategy {
fun fighting()
}
// 具体策略实现
class WeakRivalStrategy:FightingStrategy {
override fun fighting() {
println("遇到了较弱的对手..")
}
}
class StrongRivalStrategy:FightingStrategy {
override fun fighting() {
println("遇到了较强的对手..")
}
}
// 上下文角色
class ContextStrategy(fs:FightingStrategy) {
private var fs:FightingStrategy? = null
init {
this?.fs = fs
}
fun contextFighting(){
this.fs?.fighting()
}
}
// 客户端调用
class ClientForStrategy {
var contextOf = ContextStrategy(WeakRivalStrategy()).let {
it.contextFighting()
ContextStrategy(StrongRivalStrategy()).let {
it.contextFighting()
}
}
}
- 模版方法设计模式
在程序开发中，有时候会遇到某个方法的实现需要多个步骤，其中有些步骤是固定的（好比：VideoToolBox的编码步骤，
而有些步骤并不固定，存在可变行为，为了提高代码的复用性和系统的灵活性，可以使用模版模式来匹配这种情况。
定义：一个操作中的算法框架，将一些步骤延迟到子类中，使得子类不改变算法的结构，也可重定义算法的某些特定步骤。
abstract class AlgorithmKit {
protected abstract fun one()
protected abstract fun two()
protected abstract fun three()
protected abstract fun four()
protected abstract fun five()
protected abstract fun six()
protected abstract fun seven()
protected abstract fun eight()
protected abstract fun nine()
protected abstract fun ten()
protected abstract fun moves()
protected fun hasWeapons():Boolean {
return false
}
protected abstract var hook:(()->Unit)?
protected fun meridian(){
println("子午线")
}
fun start(){
one()
two()
three()
meridian()
if (hasWeapons()){
four()
five()
}
six()
seven()
moves()
eight()
nine()
}
}
// 具体实现类
class ConcreteAlgorithm01:AlgorithmKit(){
override fun one() {
}
override fun two() {
}
override fun three() {
}
override fun four() {
}
override fun five() {
}
override fun six() {
}
override fun seven() {
}
override fun eight() {
}
override fun nine() {
}
override fun ten() {
}
override fun moves() {
}
override var hook: (() -> Unit)? = {
println("算错了")
}
init {
this.hasWeapons().also {
if (it == true) !it
}
// 这一步放在let中执行，性能更好
this.hook?.let { it() }
}
}
class ConcreteAlgorithm02:AlgorithmKit() {
override fun one() {
}
override fun two() {
}
override fun three() {
}
override fun four() {
}
override fun five() {
}
override fun six() {
}
override fun seven() {
}
override fun eight() {
}
override fun nine() {
}
override fun ten() {
}
override fun moves() {
}
override var hook: (() -> Unit)? = {
println("算对了")
}
init {
this.hasWeapons().also {
if (it == true) !it
}
this.hook?.let { it() }
}
}
// 客户端调用
class ClientForAlgorithm {
val client01 = ConcreteAlgorithm01().start()
val client02 = ConcreteAlgorithm02().start()
}
- 观察者设计模式
观察者模式又被称为发布--订阅模式，属于行为设计模式的一种，是项目中经常使用的模式。
定义：定义对象间一种
一种一对多的依赖关系，每当一个对象的状态改变时，所有依赖于它的对象都会收到通知并自动更新
// 抽象观察者
interface ObserverMode {
fun update(message:String)
}
// 具体观察者
class GeneralUser(name:String):ObserverMode {
var name:String? = null
override fun update(message: String) {
println(message)
}
init {
this.name = name
}
}
// 抽象被观察者 提供了attach\detach\notify 三个方法
interface SubjectMode {
fun attachObserver(er:ObserverMode) // 添加观察者
fun detachObserver(er:ObserverMode) // 删除观察者
fun notifySubscribe(message:String) // 通知更新消息
}
// 具体被观察者
class BeingObserverForUser:SubjectMode {
// 存储订阅的用户
private val userList:MutableList<ObserverMode> = mutableListOf<ObserverMode>()
override fun attachObserver(er: ObserverMode) {
userList.add(er)
}
override fun detachObserver(er: ObserverMode) {
userList.remove(er)
}
override fun notifySubscribe(message: String) {
userList.forEach {
it.update(message)
}
}
}
//客户端使用
class ClientForObserver {
// 创建用户
val user01 = GeneralUser(name = "hong")
val user02 = GeneralUser(name = "yxm")
val user03 = GeneralUser(name = "lina")
// 创建被观察者 以及 完成订阅：被观察者去添加观察者
val what = BeingObserverForUser().let {
it.attachObserver(user01)
it.attachObserver(user02)
it.attachObserver(user03)
it.notifySubscribe("Hong Lina")
}
}
