前言
设计模式是我们Android成长之路必备的一项技能，相信很多同学都已经Get了，现在让我们来看看在Kotlin中设计模式是如何表达的呢。
单例模式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例 。
使用场景： 确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源。
- Java单例模式回顾
懒汉式：
public class Singleton{
private volatile static Singleton sInstance;
private Singleton() {}
public static Singleton getInstance() {
if (sInstance == null) {
synchronized (Singleton.class) {
if (sInstance == null) {
sInstance = new Singleton();
}
}
}
return sInstance;
}
}
饿汉式：
public class Singleton {
public static Singleton getInstance() {
return SingletonInstance.sInstance;
}
private static class SingletonInstance {
private static final Singleton sInstance = new Singleton();
}
}
- Kotlin单例模式写法
object Singleton {
}
kotlin写法是不是简单直接越看越喜欢，一句话就概括了。
来看一下官方的说明
Singleton may be useful in several cases, and Kotlin (after Scala) makes it easy to declare singletons, This is called an object declaration, and it always has a name following the object keyword.Object declaration's initialization is thread-safe.
在 Kotlin 当中直接通过关键字 object 声明一个单例，并且它是线程安全的，并且object 声明的方式也是延迟加载的。
代理模式（委托模式）
代理模式是为其他对象提供一种代理以控制对这个对象的访问
代理模式是使用一个代理对象来访问目标对象的行为，Kotlin 下的实现与 Java 基本类似
抽象类
abstract class Notify(var context: Context) {
var notificationManager: NotificationManager? = null
var builder: NotificationCompat.Builder? = null
init {
notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
builder = NotificationCompat.Builder(context)
builder?.apply {
setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(PendingIntent.getActivity(context, 0,
Intent(context, NotifyActivity::class.java),
PendingIntent.FLAG_UPDATE_CURRENT))
}
}
/**
* 发送一条通知
*/
abstract fun send()
/**
* 取消一条通知
*/
abstract fun cancel()
}
被代理类
class NotifyNormal(context: Context) : Notify(context) {
override fun send() {
builder?.let {
it.setContent(RemoteViews(context.packageName, R.layout.layout_notify_normal))
val notification = it.build()
notificationManager?.notify(0, notification)
}
}
override fun cancel() {
notificationManager?.cancel(0)
}
}
class NotifyBig(context: Context) : Notify(context) {
override fun send() {
builder?.let {
it.setContent(RemoteViews(context.packageName, R.layout.layout_notify_normal))
it.setCustomBigContentView(RemoteViews(context.packageName, R.layout.layout_notify_normal))
val notification = it.build()
notificationManager?.notify(0, notification)
}
}
override fun cancel() {
notificationManager?.cancel(0)
}
}
class NotifyHeadersUp(context: Context) : Notify(context) {
override fun send() {
builder?.let {
it.setContent(RemoteViews(context.packageName, R.layout.layout_notify_normal))
it.setCustomBigContentView(RemoteViews(context.packageName, R.layout.layout_notify_normal))
it.setCustomHeadsUpContentView(RemoteViews(context.packageName, R.layout.layout_notify_normal))
val notification = it.build()
notificationManager?.notify(0, notification)
}
}
override fun cancel() {
notificationManager?.cancel(0)
}
}
代理类
class NotifyProxy(context: Context) : Notify(context) {
private var notify: Notify? = null
init {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
notify = NotifyHeadersUp(context)
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
notify = NotifyBig(context)
} else {
notify = NotifyNormal(context)
}
}
override fun send() {
notify?.send()
}
override fun cancel() {
notify?.cancel()
}
}
调用
NotifyProxy(this@MainActivity).send()
通过代理模式可以把复杂的判断和生成通知的逻辑都屏蔽了，让代码更加清晰
建造者模式
建造者模式是将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示
比如我们常用的 AlertDialog 、universal-image-loader就是使用的建造者模式，让我们看看kotlin中该怎么表达
class Dog private constructor(builder: Builder) {
internal var name: String? = null
init {
name = builder.name
}
class Builder {
internal var name: String? = null
fun name(name1: String): Builder {
name = name1
return this
}
fun build(): Dog {
return Dog(this)
}
}
}
使用方法与Java一样
Dog.Builder().name("旺财").build()
其实Kotlin 的 apply 扩展原生也支持 Builder 模式
class Cat {
var name: String = "miaomiao"
var age = 0
}
Cat().apply {
name = "momo"
age = 1
}
观察者模式
观察者模式是定义对象间的一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新
常见的观察者模式如RecyclerView的Adapter的notifyDataSetChanged更新方法、BroadcastReceiver、开源库EventBus、RxJava等等
Kotlin的写法与Java类似
通过UnReadMessageObserver 单例来实现全局观察管理未读消息
object UnReadMessageObserver {
private var map = mutableMapOf<String, UnReadMessageListener>()
fun addUnReadMessageListener(listenerKey: String, listener: UnReadMessageListener) {
map[listenerKey] = listener
}
fun updateUnReadMessage(count: Int) {
map.forEach {
it.value.updataUnReadMessage(count)
}
}
fun removeUnReadMessageListener(listenerKey: String) {
if (map.containsKey(listenerKey)) {
map.remove(listenerKey)
}
}
}
interface UnReadMessageListener {
fun updataUnReadMessage(unReadCount: Int)
}
被观察者
UnReadMessageObserver.updateUnReadMessage(1)
观察者
UnReadMessageObserver.addUnReadMessageListener(MainActivity::class.java.name, object : UnReadMessageListener {
override fun updataUnReadMessage(unReadCount: Int) {
Toast.makeText(this@MainActivity, "count:$unReadCount", Toast.LENGTH_SHORT).show()
}
})
观察者模式是我们经常使用的模式，它的一个重要作用就是解耦，将观察者个被观察者解耦
适配器模式
适配器模式把一种接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作
举个栗子：手机普通充电需要5V的电压，而生活用电电压是220V,而我们的充电器就充当了转换适配的作用，
这里的适配器也是一个道理
适配器模式中的目标接口也就是 5V电压的接口
interface VoltageFive {
fun Voltage5(): Int
}
适配器模式中需要被适配的接口,日常220V电压
class VoltageDaily {
fun Voltage220(): Int {
return 220
}
}
适配器
class VoltageAdapter(var voltageDaily: VoltageDaily) : VoltageFive {
override fun Voltage5(): Int {
return 5
}
fun getVoltage220(): Int {
return voltageDaily.Voltage220()
}
}
以上就是适配器模式在Kotlin上的简单实现了，适配器模式的原理在于把原本不兼容的接口融合在了一起，使之能更好的协作。
总结
以上几种设计模式是我们经常会用到的，Kotlin的大多设计模式基本与Java实现大致相同，灵活的使用设计模式能让我们代码更加的灵活，便于管理。本次学习就到这了，同学们下次再见。
