Kotlin 分享

linhaosheng123456

已于 2022-04-10 21:33:38 修改

阅读量2.7k

点赞数

分类专栏： Android 文章标签： kotlin

于 2022-03-29 19:46:43 首次发布

本文链接：https://blog.csdn.net/linhaosheng123456/article/details/123830136

版权

Android 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Kotlin 分享

一 kotlin简介

Kotlin是由JetBrains公司（IDEA开发者）所开发的编程语言，其名称来自于开发团队附近的科特林岛。

多平台开发
JVM ：Android; Server-Side
Javascript:前端
Native(beta) :开发原生应用 windows、macos、linux

Swift与Kotlin非常像

1. kotlin 发展历程

2. java 发展历程

3. jvm 语言的原理

JVM规范与java规范是相互独立的
只要生成的编译文件匹配JVM字节码规范，任何语言都可以由JVM编译运行.
Kotlin也是一种JVM语言，完全兼容java，可以与java相互调用；Kotlin语言的设计受到Java、C#、JavaScript、Scala、Groovy等语言的启发

二 kotlin 特性

类型推断
空类型设计
函数式编程
设计模式改进
协程

1. 类型推断

java中声明变量的方式是类型写在最前面，后面跟着变量名，这就迫使开发者在声明变量时就要先思考变量的类型要定义成什么，而在一些情况下比如使用集合、泛型类型的变量，定义类型就会变得比较繁琐。

Kotlin中声明变量，类型可以省略，或者放到变量名后面，这可以降低类型的权重，从必选变为可选，降低开发者思维负担。java10中也引入了类型推断。

Javascript中声明变量也是用关键字var,但是还是有本质区别的，Kotlin中的类型推断并不是变成动态类型、弱类型，类型仍然是在编译期就已经决定了的，Kotlin仍然是静态类型、强类型的编程语言。javascript由于是弱类型语言，同一个变量可以不经过强制类型转换就被赋不同数据类型的值

2. 空类型设计

2.1 null引用存在的问题

以java为例，null 会存在空指针问题，在编译时不能对空指针做出检查，运行时访问null对象会出现错误
null本身没有语义，会存在歧义，具体表现在

值未被初始化
值不存在
也许表示另外一种状态

逻辑上漏洞,Java中，null可以赋值给任何引用，比如赋值给String类型变量，String a = null，但是null并不是String类型： a instanceof String 返回的是false，这个其实是有些矛盾的。所以当持有一个String类型的变量，就存在两种情况，null或者真正的String.

2.2 kotlin的空类型设计

Kotlin中引入了可空类型和不可空类型的区分，可以区分一个引用可以容纳null,还是不能容纳null。
String vs String?
String 类型表示变量不能为空，String?则表示变量可以为空 String?含义是String or null.这两种是不同的类型.
比如：

var a:String = “abc” //ok
var a:String = null //不允许
var b :String? = null //ok
a=b  //不允许

String?类型的值不能给String类型的值赋值
这样就将类型分成了可空类型和不可能类型,每一个类型都有这样的处理;Kotlin中访问非空类型变量永远不会出现空指针异常。
同样上面的例子，采用Kotlin去写，就会简洁很多

3 函数式编程

非结构化编程
结构化编程
面向对象编程
命令式编程
函数式编程

3.1 非结构化编程

第一代的高级语言往往是非结构化编程比如 BASIC语言
每一行的代码前面都有一个数字作为行号,通常使用GOTO的跳跃指令来实现判断和循环.
看一下下面这段代码是做什么的：

实际上做的是：程序在屏幕上显示数字 1 到 10 及其对应的平方
采用这种方式写程序，大量的使用goto实现逻辑的跳转，代码一长，可读性和维护性就比较差了，形成“面条式代码”

3.2 结构化编程

采用顺序、分支、循环结构来表达，禁用或者少用GOTO;
并用子程序来组织代码，采用自顶向下的方式来写程序
代表语言是C语言
实现同样的逻辑：

可见采用结构化编程，代码的逻辑会更清晰。

3.3 面向对象编程

思想：
将计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
特性：封装性、继承性、多态性。

3.4 命令式编程

把计算机程序视为一系列的命令集合
主要思想是关注计算机执行的步骤，即一步一步告诉计算机先做什么再做什么。 “先做这，再做那”，强调“怎么做”

实现：
用变量来储存数据，用语句来执行指令，改变变量状态。
基本所有的常见的编程语言都具有此范式

3.5 函数式编程

声明式语法，描述要什么，而不是怎么做
函数是第一等公民 (可以赋值给变量，可作为参数传入另一个函数，也可作为函数的返回值)
纯函数 y=f(x) (只要输入相同，返回值不变
没有副作用：不修改函数的外部状态)

4 设计模式改进

4.1 创建型模式

工厂方法模式

以下是kotlin模仿java的写法

interface Computer{
val cpu:String
}
class PC(override val cpu:String = "Core") : Computer
class Server(override val cpu:String = "Xeon") : Computer

enum class ComputerType{
  PC,Server
}

class ComputerFactory {
   fun produce(type:ComputerType) : Computer {
      return when (type) {
         ComputerType.PC -> PC()
         ComputerType.Server -> Server()
      }
   }
}

在不同地方创建Computer的子类对象时候，都需要先创建一个ComputerFactory类对象，那么在kotlin 中可以用object关键字来改进

object ComputerFactory{
  fun produce(type:ComputerType) : Computer {
      return when (type) {
         ComputerType.PC -> PC()
         ComputerType.Server -> Server()
      }
   }
}

然后调用的时候，我们就可以
ComputerFactory.produce(ComputerType.PC)

之外，由于是通过Computer类型来创建不同的对象,所以这里的 product显得多余，可以通过kotlin 的运算符重载进一步的优化

object ComputerFactory{
 operator fun invoke(type:ComputerType): Computer {
      return when (type) {
         ComputerType.PC -> PC()
         ComputerType.Server -> Server()
      }
   }
}

然后调用的时候就可以这样
ComputerFactory(ComputerType.PC)

4.2 抽象工厂模式

抽象工厂模式：为一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。

interface Computer
class Dell : Computer
class Asus : Computer
class Acer : Computer

class DellFactory : AbstractFactory(){
    override fun produce() = Dell()
}

class AsusFactory : AbstractFactory(){
    override fun produce() = Asus()
}

class AcerFactory : AbstractFactory(){
    override fun produce() = Acer()
}

abstract class AbstractFactory{
    abstract fun produce() : Computer
}

companion object{
   operator fun invoke(factory : AbstractFactory) : AbstractFactory{
   return factory
   }
}

fun main (args : Array<String>){
  val dellFactory  = AbstractFactory(DellFactory)
  val dell = dellFactory.produce()
}

每次创建具体的工厂类时，都需要传入一个具体的工程类对象作为参数进行构造，不是很优雅，那么可以用kotlin的内联函数进行改造

kotlin的内联函数有一个很大的作用，是可以具体化参数类型

abstract class AbstractFactory{
    abstract fun produce() : Computer
    
    companion object{
       inline operator fun <reified T : Computer> invoke() :
       AbstractFactory = when(T::class){
        Dell::class -> DellFactory()
        Asus::class -> AsusFactory()
        Acer::class -> AcerFactory()
        else -> throw IllegaArgumentException()
       }
    }
}

通过讲invoke 方法用inline定义为内联函数，那么既可以引入 reified关键字使用具体参数类型的语法特性
通过具体化参数类型为Computer，在invoke方法中通过判断它的具体类型来返回对应的工厂对象

fun main (args : Array<String>){
  val dellFactory  = AbstractFactory<Dell>()
  val dell = dellFactory.produce()
}

4.3 构建者模式

在 java 开发中
Robot robot = new Robot(1,true,false,false,false,true,false)
像蛇一样的构造函数，遇到这种场景，一般是用Builder(构建者)模式来解决

class Robot private constructor(
val code:String?,
val battery :String?,
val height:Int?,
val weight:Int?){
 
 class Builder(val code:String){
    private val battery :String? = null
    private val height :Int? = null
    private val weight :Int? = null 
    
    fun setBattery(battery :String?) : Builder{
      this.battery = battery
      return this
    }
    
     fun setHeight(height :Int?) : Builder{
      this.height = height
      return this
    }
    
   fun setWeight(weight :Int?) : Builder{
      this.weight = weight
      return this
    }
    
    fun builder():Robot{
      return Robot(code,battery,height,weight)
    }
 }
}

这种构建者模式也存在着一些不足：

如果参数过多，代码依然比较冗长
用Builder在最后忘记调用builder()
创建对象的时候，必须先创建构造器，增加多余的开销

以上这些可以用过kotlin的具名的可选参数来解决
具名的特性就是在具体化参数的取值时，可以带上它的参数

class Robot(
val code:String?,
val battery :String?,
val height:Int?,
val weight:Int?
)
val robot1 = Robot(code = "007")
val robot1 = Robot(code = "007",battery="7U")
val robot1 = Robot(code = "007",battery="7U",height=100)

相比构建者模式

代码变得简洁
声明对象，每个参数名都可以是显示，并且无序，灵活
使用 val相比 var，在多线程场景下更加安全

4.4 行为模式

用高阶函数来简化策略模式
1 遵循开闭原则：策略模式
假设现在有一个表示游泳运动员的的抽象类Swimmer,有一个游泳的swim方法，表示如下

class Swimmer {
   fun swim(){
   println("I am swimming...")
   }
}

用 Swimmer 来创建一个对象

val shaw = Swimmer()
shaw.swim()

如果该运动员很快学会了蛙泳，自由泳，仰泳等多种姿势，那么久变成

class Swimmer {

   fun breastStroke(){
    println("I am breastStroke...")
   }
   
   fun backStroke(){
    println("I am backStroke...")
   }
   
    fun freestStroke(){
    println("I am freestStroke...")
   }
   
}

策略模式，分别封装起来，让他们之间相互替换，通过不同的策略进行独立封装，与类在逻辑上进行解耦

以下使用策略模式来写

interface SwimStratory{
   fun swim()
}

class BreastStroke:SwimStratory{
  override fun swim(){
    println("I am breastStroke...")
  }
}


class BackStroke:SwimStratory{
  override fun swim(){
    println("I am backStroke...")
  }
}

class FreestStroke:SwimStratory{
  override fun swim(){
    println("I am freestStroke...")
  }
}

class Swimmer(val strategy:SwimStratory){
     fun swim(){
     strategy.swim() 
  }
}

fun main (args : Array<String>){
  val weekendShaw = Swimmer(FreestStroke())
  weekendShaw.swim()
  
  val weekendShaw = Swimmer(BreastStroke())
  weekendShaw.swim()
}

以上方案实现了解耦与复用，下面是kotlin的写法

fun breastStroke(){
    println("I am breastStroke...")
   }
   
   fun backStroke(){
    println("I am backStroke...")
   }
   
    fun freestStroke(){
    println("I am freestStroke...")
   }
   
class Swimmer(val swimming:() -> Unit){
     fun swim(){
     swimming() 
  }
}
 
fun main (args : Array<String>){
  val weekendShaw = Swimmer(::freestStroke)
  weekendShaw.swim()
  
  val weekendShaw = Swimmer(::breastStroke)
  weekendShaw.swim()
}

使用的是高阶函数讲策略封装为一个函数，然后作为参数进行传递，代码更加简洁

4.5 结构模式

装饰者模式中，可以通过类委托减少样板代码

在Java中，当要给一个类扩展行为的时候，通常有两种选择

设计一个新的类继承它的子类
使用装饰者模式对该类进行装饰，然后对功能进行扩展

那么装饰者模式做的主要是以下几点：

创建一个装饰类，包含一个需要被装饰类的实例
装饰类重写所有被装饰的类的方法
在装饰类中对需要被增强的功能进行扩展

interface MacBook{
   fun getCost(): Int
   fun getDesc(): String
   fun getProdDate():String
}

class MacBookPro:MacBook{
   override fun getCost() = 1000
   override fun getDesc() = "MacBookPro"
   override fun getProdDate() = "Late 2021"
}
//装饰类
class ProcessorUgradeMacbookPro(val macbook:MacBook):MacBook by macBook{
     override fun getCost() = macbook.getCost() + 200
 
    override fun getDesc() = macbook.getDesc() + "1 G Memery"
     
}

所以通过Kotlin 的委托语法，只需要重写需要改变的方法，像getProdDate 生产日期不会改变，因此不需要重写。

5 协程

5.1 协程特点

轻量：可以在单个线程上运行多个协程，因为协程支持挂起，不会使正在运行协程的线程阻塞。挂起比阻塞节省内存，且支持多个并行操作。
内存泄漏更少：使用结构化并发机制在一个作用域内执行多项操作。
取消操作会自动在运行中的整个协程层次结构内传播。
Jetpack 集成：许多 Jetpack 库都包含提供全面协程支持的扩展。某些库还提供自己的协程作用域，可供您用于结构化并发。

5.2 android上的简单使用

5.2.1 声明

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9")
}

5.2.2 网络请求

如果在主线程上发出网络请求，则主线程会处于等待或阻塞状态，直到收到响应。由于线程处于阻塞状态，因此操作系统无法调用 onDraw()，这会导致应用冻结，并有可能导致弹出“应用无响应”(ANR) 对话框。为了提供更好的用户体验，我们在后台线程上执行此操作。

sealed class Result<out R> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

class LoginRepository(private val responseParser: LoginResponseParser) {
    private const val loginUrl = "https://example.com/login"

    // Function that makes the network request, blocking the current thread
    fun makeLoginRequest(
        jsonBody: String
    ): Result<LoginResponse> {
        val url = URL(loginUrl)
        (url.openConnection() as? HttpURLConnection)?.run {
            requestMethod = "POST"
            setRequestProperty("Content-Type", "application/json; utf-8")
            setRequestProperty("Accept", "application/json")
            doOutput = true
            outputStream.write(jsonBody.toByteArray())
            return Result.Success(responseParser.parse(inputStream))
        }
        return Result.Error(Exception("Cannot open HttpURLConnection"))
    }
}

makeLoginRequest 是同步的，并且会阻塞发起调用的线程。为了对网络请求的响应建模，创建了自己的 Result 类。

ViewModel 会在用户点击（例如，点击按钮）时触发网络请求：

class LoginViewModel(
    private val loginRepository: LoginRepository
): ViewModel() {

    fun login(username: String, token: String) {
        val jsonBody = "{ username: \"$username\", token: \"$token\"}"
        loginRepository.makeLoginRequest(jsonBody)
    }
}

使用上述代码，LoginViewModel 会在网络请求发出时阻塞界面线程。如需将执行操作移出主线程，最简单的方法是创建一个新的协程，然后在 I/O 线程上执行网络请求：

class LoginViewModel(
    private val loginRepository: LoginRepository
): ViewModel() {

    fun login(username: String, token: String) {
        // Create a new coroutine to move the execution off the UI thread
        viewModelScope.launch(Dispatchers.IO) {
            val jsonBody = "{ username: \"$username\", token: \"$token\"}"
            loginRepository.makeLoginRequest(jsonBody)
        }
    }
}

viewModelScope 是预定义的 CoroutineScope，包含在 ViewModel KTX 扩展中。请注意，所有协程都必须在一个作用域内运行。一个 CoroutineScope 管理一个或多个相关的协程。
launch 是一个函数，用于创建协程并将其函数主体的执行分派给相应的调度程序。
Dispatchers.IO 指示此协程应在为 I/O 操作预留的线程上执行。
login 函数按以下方式执行：

应用从主线程上的 View 层调用 login 函数。
launch 会创建一个新的协程，并且网络请求在为 I/O 操作预留的线程上独立发出。
在该协程运行时，login 函数会继续执行，并可能在网络请求完成前返回。请注意，为简单起见，我们暂时忽略掉网络响应。
由于此协程通过 viewModelScope 启动，因此在 ViewModel 的作用域内执行。如果 ViewModel 因用户离开屏幕而被销毁，则 viewModelScope 会自动取消，且所有运行的协程也会被取消。

前面的示例存在的一个问题是，调用 makeLoginRequest 的任何项都需要记得将执行操作显式移出主线程。下面我们来看看如何修改 Repository 以解决这一问题。

5.2.3 使用协程确保主线程安全

如果函数不会在主线程上阻止界面更新，我们即将其视为是主线程安全的。makeLoginRequest 函数不是主线程安全的，因为从主线程调用 makeLoginRequest 确实会阻塞界面。可以使用协程库中的 withContext() 函数将协程的执行操作移至其他线程：

class LoginRepository(...) {
    ...
    suspend fun makeLoginRequest(
        jsonBody: String
    ): Result<LoginResponse> {

        // Move the execution of the coroutine to the I/O dispatcher
        return withContext(Dispatchers.IO) {
            // Blocking network request code
        }
    }
}

withContext(Dispatchers.IO) 将协程的执行操作移至一个 I/O 线程，这样一来，我们的调用函数便是主线程安全的，并且支持根据需要更新界面。

makeLoginRequest 还会用 suspend 关键字进行标记。Kotlin 利用此关键字强制从协程内调用函数。

class LoginViewModel(
    private val loginRepository: LoginRepository
): ViewModel() {

    fun login(username: String, token: String) {

        // Create a new coroutine on the UI thread
        viewModelScope.launch {
            val jsonBody = "{ username: \"$username\", token: \"$token\"}"

            // Make the network call and suspend execution until it finishes
            val result = loginRepository.makeLoginRequest(jsonBody)

            // Display result of the network request to the user
            when (result) {
                is Result.Success<LoginResponse> -> // Happy path
                else -> // Show error in UI
            }
        }
    }
}

5.2.4 处理异常

为了处理 Repository 层可能抛出的异常，使用 Kotlin 对异常的内置支持。在以下示例中，使用的是 try-catch 块：

class LoginViewModel(
    private val loginRepository: LoginRepository
): ViewModel() {

    fun makeLoginRequest(username: String, token: String) {
        viewModelScope.launch {
            val jsonBody = "{ username: \"$username\", token: \"$token\"}"
            val result = try {
                loginRepository.makeLoginRequest(jsonBody)
            } catch(e: Exception) {
                Result.Error(Exception("Network request failed"))
            }
            when (result) {
                is Result.Success<LoginResponse> -> // Happy path
                else -> // Show error in UI
            }
        }
    }
}

linhaosheng123456

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Kotlin 分享

Kotlin 分享一 kotlin简介Kotlin是由JetBrains公司（IDEA开发者）所开发的编程语言，其名称来自于开发团队附近的科特林岛。多平台开发JVM ：Android; Server-SideJavascript:前端Native(beta) :开发原生应用 windows、macos、linuxSwift与Kotlin非常像1. kotlin 发展历程2. java 发展历程3. jvm 语言的原理JVM规范与java规范是相互独立的只要生成的编译文件匹配JV
复制链接

扫一扫