- 工厂模式 Factory Pattern
- 构筑者模式 Builder Pattern
- 观察者模式 Builder Pattern
- 单例模式 Singleton Pattern
- 代理模式 Proxy Pattern
- 原型模式 Prototype Pattern
- 策略模式 Strategy Pattern
- 中介者模式 Mediator Pattern
- 命令模式 Command Pattern
- 责任链模式 Command Pattern
- 装饰模式 Decorator Pattern
- 适配器模式 Adapter Pattern
- 迭代器模式 Iterator Pattern
- 模版方法模式 Template Method Pattern
- 组合模式 Composite Pattern
工厂模式 Factory Pattern
将不同的数据类抽象出来，比如电脑的CPU，有AMD和英特尔的，都有不同的功能，但是主板是一样的，就要构造一个能同时接收多种CPU的主板接口类
interface Computer{
val __cpu: String
//增加Factory名字
companion object Factory{
operator fun invoke(type: ComputerType): Computer{
return when(type){
ComputerType.PC -> PC()
ComputerType.SERVER ->Server()
}
}
}
}
class PC(override val __cpu: String = “Core”): Computer
class Server(override val __cpu: String = “Xeon”): Computer
enum class ComputerType{
PC,SERVER
}
�同时，电脑的品牌相对应工厂也是可以抽象出来的，这样子可以保证工厂代码的简洁，降低耦合度，如果一个电脑品牌出问题不会影响别的品牌,区别为接收的判断是类而不是字符串
abstract class AbstractFactory{
abstract fun produce(): Computer//制造一个电脑的方法
companion object{
//普通，调用方法
// val abstractFactory = AbstractFactory(D)
operator fun invoke(factory: AbstractFactory): AbstractFactory{
return factory
}
}
//简化，调用方法
// val abstractFactory = AbstractFactory
// val produce = abstractFactory.proudce()
///Dell::class -> DellFactory()
else -> throw IllegalAccessException()
}
}
构筑者模式 Builder Pattern
1.折叠构造模式
/**
java版
/
public class Computer {
public Computer(String cpu, String ram) {
this(cpu, ram, 0);
}
public Computer(String cpu, String ram, int usbCount) {
this(cpu, ram, usbCount, “罗技键盘”);
}
public Computer(String cpu, String ram, int usbCount, String keyboard) {
this(cpu, ram, usbCount, keyboard, “三星显示器”);
}
public Computer(String cpu, String ram, int usbCount, String keyboard, String display) {
this.cpu = cpu;
this.ram = ram;
this.usbCount = usbCount;
this.keyboard = keyboard;
this.display = display;
}
}
缺点，当参数增多且参数类型相同时，人员
2.javabean模式
public class Computer {
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getRam() {
return ram;
}
public void setRam(String ram) {
this.ram = ram;
}
public int getUsbCount() {
return usbCount;
}
}
�缺点，因为属性是分步设置的，所以容易在改变状态的时候出问题
3.builder模式
__/*
例
*/
class Person private constructor(){
private lateinit var name: String
private lateinit var job: String
companion object{<br /> fun build(): Builder{<br /> return return Builder()<br /> }<br /> }<br /> //建造者类<br /> class Builder{<br /> var mPerson = Person() //实例化人物类<br /> //每次调用类里面的方法的时候都会返回一个实例化了某个属性的Builder,链式调用<br /> fun setName(name: String): Builder{//设置名字<br /> mPerson.name = name<br /> return this<br /> }<br /> fun setPrice(job: String): Builder{//设置职位<br /> mPerson.job = job<br /> return this //返回了添加了属性的Builder对象<br /> }<br /> fun create(): Person{//创建Computer类的实例化<br /> return mPerson<br /> }<br /> }<br /> fun show(): String{//功能 -输出属性值<br /> return "Person(name = '$name', job = '$job')"<br /> }<br />}<br />//调用<br />var person = Person<br /> .build()<br /> .setName("")<br /> .setPrice("")<br /> .create()_
观察者模式 Builder Pattern
目标对象和观察者，目标对象可以被多个观察者观察，以数组的形式存中目标对象中，有更新的时候通知所有的观察者更新了
/
观察者
/
interface Observer{
fun
}
/
观察者1,2,3
/
class Ob1(private val id:Int = 0) : Observer{
**override fun **<T> update(msg: T) {<br /> println(**"接收消息,观察者$id:$**msg**"**)<br /> }<br />}<br />//这里是kotlin的类委托<br /> //<br />**class **Ob2 : Observer **by **Ob1(2)<br />**class **Ob3 : Observer **by **Ob1(3)<br /> /**<br /> *被观察者（被订阅）<br /> */<br />**class **Subject{<br /> //存放观察者<br /> **private var observers **= ArrayList<Observer>()<br />//订阅观察者<br /> **fun **attach(ob: Observer){<br /> **observers**.add(ob)<br /> }<br /> //设置数据<br /> **fun**<T : Any?> setMsg(msg: T){<br /> **this**.notify(msg)<br /> }<br /> //更新数据<br /> **private fun **<T: Any?> notify(msg: T){<br /> **for**(iOb **in this**.**observers**){<br /> iOb.update(msg)<br /> }<br /> }<br /> }<br />**fun **main(){<br /> **val **sub = Subject().apply **{<br /> **attach(Ob1())<br /> attach(Ob2())<br /> attach(Ob3())<br /> **}<br /> **with(sub)**{<br /> **setMsg(123)<br /> setMsg(**"hello world"**)<br /> setMsg(**'A'**)<br /> setMsg(**null**)<br /> **}<br />**}
单例模式 Singleton Pattern
1.饿汉模式
object SingletonDemo
转化为字节码可发现与java中的饿汉模式相同，都是使用前先初始化，占用内存
2.懒汉模式
这个filed是防止递归调用的属性，防止在set和get方法时不断递归导致的StackOverFlow
其作用是指代自身对象时直接指向this.的属性
class SingletonPattern private constructor(){
companion object{//伴生匿名对象
private var __instance: SingletonPattern? = null
__ get(){
if(field == null){
field = SingletonPattern()
}
return field
}
fun get(): SingletonPattern{
//伴生对象声明时，不用getInstance作为方法名
//伴生对象声明的时候已经带了getInstance方法了
return __instance!!
}
}
}
3.线程安全的懒汉模式
相比于上述的添加了@Synchronized的关键字，保证是线程可以同步的
class SingletonPattern private constructor(){
companion object{
private var __instance: SingletonPattern? = null
__ get() {
if(field == null){
field = SingletonPattern()
}
return field
}
@Synchronized
fun get(): SingletonPattern{
return __instance!!
}
}
}�
�4.双重安全锁DCL
by lazy是委托模式，传入mode = Lazy…保证了只会在一个进程计算，所有进程看到的值相同
class SingletonPattern private constructor(){
companion object{}
val __instance: SingletonPattern by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){
__ SingletonPattern()
}
}
�
代理模式 Proxy Pattern
1.类代理
_interface Base{
fun print()
}
class BaseImpl(val **x:Int) : Base{
override fun print() {
print(x)
}
}
//将base由b代理，b内的值可以直接传入Derived
//方法也在
class Derived(b: Base): Base by **b
fun main() {
val b = BaseImpl(10)
Derived(b).print()//输出10
}_
2.属性代理
原型模式 Prototype Pattern
1.浅拷贝
将克隆的对象指向原先的对象，之前的对象改变，新克隆的对象也会改变
abstract class Prototype(var __name: String, var __list: ArrayList
/*
提供克隆对象的方法
*/
override fun toString(): String {
return “$name,${name.hashCode()},$list,${list.hashCode()}“
}
}
/*
具体的原型类1
*/
class ConcretePrototype1(name: String,list: ArrayList
return this.clone() as Prototype
}
}
fun main() {
val obj = ConcretePrototype1(“tom”, arrayListOf(“1”))
val cloneObj = obj.cloneObj()
}
��2.深拷贝
策略模式 Strategy Pattern
1.简单实现
将不同的行为策略独立封装，与类的逻辑上解藕，根据不同的上下文，对类进行调用
创建一个接口，再创建不同的策略类去实现这些接口，最后再创建一个类来接收调用这些类的方法
interface SwimStrategy{
fun swim()
}
class Breaststroke : SwimStrategy{
override fun swim() {
println(“Breaststroke”)
}
}
class Backstroke : SwimStrategy{
override fun swim() {
println(“Backstroke”)
}
}
class Swimmer(val strategy: SwimStrategy){
fun swim(){
strategy.swim()
}
}
fun main() {
Swimmer(Breaststroke()).swim()
Swimmer(Backstroke()).swim()
}
2.用高阶函数实现
fun breaststroke(){
println(“breaststroke”)
}
fun backstroke(){
println(“backstroke”)
}
class Swimmer(val __swimming: () -> Unit){
//高阶函数
fun swim(){
swimming_()//调用传进来作为参数的函数
}
}
**_fun **main() {
//双冒号为引用一个方法
Swimmer(::breaststroke).swim()
Swimmer(::backstroke).swim()
}
�
中介者模式 Mediator Pattern
要解决的问题：类与类之间耦合度高，关系繁多而复杂
解决方法：根据迪米特法则，如果两个类之间没有直接的彼此通信，就不应该有直接的作用，而转用第三个类来实现中介
abstract class Mediator{
/*
抽象转发消息的方法，得到同事对象和转发消息
*/
abstract fun forward(msg: String,colleague: Colleague)
}
abstract class Colleague(private val __mediator: Mediator){
abstract fun send(msg: String)
abstract fun receive(msg: String)
}
class ConcreteMediator: Mediator(){
var __colleagueA: Colleague? = null
var colleagueB: Colleague? = null
__ override fun forward(msg: String, colleague: Colleague) {
when(colleague){
colleagueA ->{
colleagueB?.receive(msg)
}
colleagueA ->{
colleagueA?.receive(msg)
}
}
}
}
命令模式 Command Pattern
将每个方法的请求者和实现者分离开来，解除耦合，在需要撤销或者重做的场合非常有用
(长得像建造者模式?)
�interface OrderCommand{
fun execute()
}
class OrderAddCommand(val __id: Long ): OrderCommand{
override fun execute() {
println(“adding order with id:$id__”)
}
}
class OrderPayCommand(val __id: Long): OrderCommand{
override fun execute() {
println(“paying for order with id: $id__”)
}
}
class CommandProcessor{
private val __queue = ArrayList
queue.add(orderCommand)
}
fun processCommands(): CommandProcessor = apply {
queue.forEach(){
__ it.execute()
}
queue.clear()
}
_}
**_fun **main() {
CommandProcessor()
.addToQueue(OrderAddCommand(1L))
.addToQueue(OrderPayCommand(1L))
.processCommands()
}
�
责任链模式 Command Pattern
创建一个抽象handler，然后再由具体类实现，每个类都保存着下个类的实例，如果无法处理则调用下个类的处理方法
abstract class Handler{
protected var __mSuccessor: Handler? = null
__ /*
设置继承者
/
fun setSuccessor(successor: Handler): Handler{
this.mSuccessor = successor
return this
__ }
/*
处理方法
*/
abstract fun handlerRequest(requestCode: Int)
}
class ConcreteHandler1 : Handler(){
override fun handlerRequest(requestCode: Int) {
when(requestCode){
in 0 until 10 -> println(“0-10”)
else -> {
println(“concretehandler1无法处理”)
mSuccessor?.handlerRequest(requestCode)
}
}
}
}
class ConcreteHandler2 : Handler(){
override fun handlerRequest(requestCode: Int) {
when(requestCode){
in 10 until 20 -> println(“10-20”)
else -> {
println(“2无法处理”)
mSuccessor_?.handlerRequest(requestCode)
}
}
}
}
**_fun main() {
var handler1 = ConcreteHandler1()
var handler2 = ConcreteHandler2()
handler1.setSuccessor(handler2)
for(requestCo de in **0..10 step 5){
handler1.handlerRequest(requestCode)
}
}
装饰模式 Decorator Pattern
如果正常的扩展是需要继承的，但是不是所有的场景都可以继承，所以这时我们需要装饰者模式，用by将装饰类的方法委托给一个被装饰的类对象，然后只要写装饰的方法即可
如果不用委托，在不继承Macbook类的前提下，那么我们需要创建一个装饰类和被装饰类的公共父类抽象
interface MacBook{
fun getCost():Int
fun getDesc():String
fun getProDate():String
}
class MacBookPro:MacBook{
override fun getCost() = 1000
override fun getDesc() = “MacBook Pro”
override fun getProDate() = “Late 2011”
_}
/
包装类
/
_class ProcessorUpgradeMacbookPro(val __macbook: MacBook):MacBook by macbook{
override fun getCost() = macbook.getCost() + 299
override fun getDesc() = macbook.getDesc() + “1G Memory”
**_}
**_fun main() {
val macBook = MacBookPro()
val **updataMacbookPro = ProcessorUpgradeMacbookPro(macBook)
}
�
适配器模式 Adapter Pattern
将一个类的接口转换成用户需要的另一个接口，使得接口原本不兼容的类能一起工作，相当于
不同的插口通过转接线让同一个接口能使用
/*
目标类，客户期待的接口或抽象类
*/
open class Target{
open fun request(){
println(“普通请求”)
}
}
/*
需要适配的类
*/
class Adaptee{
fun specificRequest(){
println(“特殊请求”)
}
}
/*
适配器类
在内部包装一个需要适配的类Adaptee对象，目标类调用指定的方法时，内部执行适配的方法达到适配的效果
/
class Adapter : Target(){
private val __adaptee = Adaptee()
override fun request() {
adaptee_.specificRequest()//表面是Target的request,实际变成调用类想要适配的类的方法
}
}
**_fun main() {
val **target = Adapter()
target.request()
}
�
迭代器模式 Iterator Pattern
提供一个方法访问容器类对象中的各个元素,而又不需要暴露该对象的内部细节
模版方法模式 Template Method Pattern
模版方法
一个类里面的模版方法也可以有多个
定义在抽象类里，把基本方法组合在一起，但是基本方法也是抽象的，组合在一起完成一个特定的算法.这个方法子类一般是不加修改的继承下来
基本方法
抽象方法
具体方法
钩子函数
组合模式 Composite Pattern
将对象组织到树中，可以表示部分与整体的关系
基本对象可以被组合成更复杂的对象，更复杂的对象可以被不断组合下去，客户端只要保持对待单个对象和组合对象的一致性即可
注意：需要描述对象整体和部分的等级结构
需要客户端忽视整体和部分的区别
/*
组合对象声明的接口
*/
abstract class Component (val __name: String){
abstract fun add(component: Component)
abstract fun remove(component: Component)
abstract fun display(compoent: Component)
}
/*
叶子节点
*/
class Leaf(name: String) : Component(name){
override fun add(component: Component) {
println(“无法从叶子类中添加组件”_)
}
_**_override fun _**_remove(component: Component) {<br /> println(_**_"无法从叶子类中移除组件"_**_)<br /> }_**_override fun _**_display(compoent: Component) {<br /> println(_**_"展示"_**_)<br /> }<br />}<br />_**_class _**_Composite(name: String) : Component(name){<br /> //孩子节点<br /> _**_private val __children _**_= arrayListOf<Component>()<br /> _**_override fun _**_add(component: Component) {<br /> _**_children_**_.add(component)<br /> }_**_override fun _**_remove(component: Component) {<br /> _**_children_**_.remove(component)<br /> }_**_override fun _**_display(compoent: Component) {<br /> println(_**_"输出本身"_**_)<br /> _**_for _**_(child _**_in __children_**_){<br /> child.display(compoent)<br /> }<br /> }<br />}_<br />�
安全式合成
因为树叶类不可能还会有子节点，所以聚合类方法对它是没有意义的还会报错，所以组合的方法全放到树枝构建类中
透明式合成
一视同仁
若有收获，就点个赞吧
0 人点赞
