Android常用设计模式（小白必看）

//Kotlin
object Singleton{

}

//Java
public class Singleton{
  private Singleton(){}
  private static Singleton instace = new Singleton();
  
  public static Singleton getInstance(){
      return instance;
  }
}

2、线程安全的懒汉式

使用同步锁解决懒汉式线程安全问题

//Kotlin 
Class Singleton private constructor(){
  companion object{
     private var instance:Singleton? = null
           get(){
                if(field == null) {
                   field = Singleton()
                }
        return field
   }
  @Synchronized
  fun getInstance() = instance!!
} 


//Java
public class Singleton{
  private Singleton(){}
  private static Singelton instance;
  public static sychronized Singleton getInstance(){
    if(instance==null){
      instance = new Singleton();
    }
    return instance;
  }
}

3、双重校验锁

考虑线程安全，基于同步锁来创建并返回唯一实例对象

//Kotlin
companion object{
     val instance:Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        Singleton()
    }
}


//Java
public class Singleton{
  private volatile static Singleton instance;
  private Singleton(){}
  public static Singleton getInstance(){
    if(instace == null){
      synchronized(Singleton.class){
        if(instance == null){
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

4、静态内部类

静态提供单个实例，实例通过内部类创建

//Kotlin
class Singleton private constructor(){
    companion object{
        val instance = SingletonHolder.holder
    }
    
    private object SingletonHolder{
        val holder = Singleton()
    }
}


//Java
public class Singleton{
  private static class SingletonHolder{
    private static Singleton instance = new Singleton();
  }
  private Singleton(){}
  public static Singleton getInstance(){
    return SingletonHolder.instance;
  }
}

使用经验：

线程安全和性能要求高，使用饿汉式、双重检查锁
需要保证创建单例是第一次访问时，使用了懒汉式、静态内部类

工厂模式

特点：

不直接实例化对象，通过工厂创建对象

实现方式：

1、简单工厂模式

只创建一个工厂，工厂可以产多个产品（利用接口实现统一）

接口：

interface ICar {
    fun printColor()
    fun installEngine()
    fun installWheels()
    fun installSystem()
    fun doit()
}

产品类:

class CarA :ICar {
    private lateinit var color: String
    private lateinit var engine:String
    private lateinit var wheels:String
    private lateinit var system:String


    override fun printColor() {
        color = "red"
        println("it is red")
    }
    override fun installEngine() {
        engine = "EngineA"
        println("it is $engine")
    }
    override fun installWheels() {
        TODO("Not yet implemented")
    }
    override fun installSystem() {
        TODO("Not yet implemented")
    }
    override fun doit(){
        printColor()
        installEngine()
    }
    override fun toString(): String {
        return "$color+$engine"
    }
}

工厂类：

class SimpleFactory {
    companion object{
        val CAR_A = "CarA"
        val CAR_B = "CarB"
        fun buildCar(type:String):ICar?{
            var car:ICar? = null
            when(type){
                CAR_A-> car = CarA()
                CAR_B-> car = CarB()
            }
            car?.doit()
            return car
        }
    }
}

通过工厂创建：

val A = SimpleFactory.buildCar(SimpleFactory.CAR_A)

输出结果：

2、工厂方法模式

多产品类对应多工厂，所有产品类对应一个接口（统一产品大致操作），所有工厂类对应一个接口（统一工厂的大致操作如“生产产品”）

产品接口：

interface ICar {
    fun printColor()
    fun installEngine()
    fun installWheels()
    fun installSystem()
    fun doit()
}

工厂接口：

interface IFactory {
    fun buildCar():ICar
}

工厂类同简单工厂模式一致

新增产品类如CarC，同样实现ICar接口，创建对应工厂C来实现IFactory接口

class CCarFactory:IFactory {
    private val carC = CarC()
    override fun buildCar(): ICar {
        carC.doit()
        return carC
    }
}

3、抽象工厂模式

有多个工厂，一个工厂可以生产多种产品（工厂间一个接口统一，同类产品间一个接口统一）

多产品统一接口：

多个工厂，接口统一:

使用经验:

第一关注接口，同类产品共有方法放产品接口，工厂要生产哪几类产品的方法放同一工厂接口
固定永远只有几种产品。使用简单工厂
随时新建工厂，生产新产品。使用工厂方法
一个工厂可以生产不同种类产品。使用抽象工厂

适配器模式

不修改现有代码，将不兼容的类组合在一起

组成：

目标接口 Target Interface
适配器 Adapter ：充当两个不兼容接口间的桥梁
适配者 Adaptee ：需要被适配的对象，该接口与目标接口不兼容
客户端 Client ：使用目标接口的对象

特点：

当需要将一个已有的类或接口与另一个不兼容的类或接口进行协同工作时
当需要对一个已有的类或接口进行修改，以满足客户端的需求时，但是不希望修改该类或接口的源代码
当需要重新使用一个已有的类或接口，但是不能直接使用该类或接口的方法时

实现方式：

使用经验：

由适配器来间接调用适配者方法
适配者无需实现目标接口，只需要当作参数或成员变量来传入适配器
Java IO流，每个数据源都有不同接口，但是Java IO可以将它们转为统一标准接口
Java Servlet API 定义一组接口处理HTTP请求与相应。每个Servlet都实现这些接口，但是用户只需要实现一部分

代理模式

特点：

跨模块调用
跨进程调用
远程web调用（本地应用与远程web服务）

实现方式：

1、静态代理：

在代理类构造中真实类，最后由调用代理类的同名方法实现真实类的功能

2、动态代理

代理对象不需要接口，利用JDK的API动态构建代理对象

使用经验：

当不能直接访问目标对象，可以访问该目标的代理对象
目标对象实现的同时，还可以在代理类扩展目标对象的功能（静态代理中）
动态代理只有代理类不同，用“ by 目标对象”自动加载代理过程
形式参数（小括号里的）不能直接用，必须先用变量接受保存起来，调用变量使用
形式参数前加val或var为成员变量，可以在类里直接调用
接口可以含参，不可以有方法体

观察者模式

特点：

定义对象之间一对多的依赖关系
目标发生变化，所有依赖它的对象都会得到通知并自动更新

实现方式：

可以手动添加多个观察者，当观察对象调用某些方法，会通知并更新所有观察者的信息

所有观察者以集合形式存储在对象类里

添加观察者：

通知所有观察者数据更新：

使用经验:

事件处理机制：Java中Swing GUI框架基于此实现，当用户与组件交互，组件通知注册的监听器，触发相应事件
日志记录：日志变化通知文件输出流，控制台输出流
用户界面设计：用户与UI元素交互，它们像注册的监听器发送事件通知，出发相应事件
多线程编程：线程发生变化，向其他线程通知，实现线程间协作和同步

zhoujun798

关注

23
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫