全民 Kotlin:你没有玩过的全新玩法

  • 第一篇:全民 KotlinJava我们不一样

  • 当前篇:全民 Kotlin:你没有玩过的全新玩法

  • 第三篇:全民 Kotlin:协程特别篇

本文章已授权鸿洋微信公众号转载

开源阅读

  • 空安全

  • 方法支持添加默认参数

  • 方法上面的参数不可变

  • 类方法扩展

  • 函数变量

  • 内联函数

  • 委托机制

    • 类委托

    • 属性委托

    • 懒委托

  • 扩展函数

    • let 函数

    • with 函数

    • run 函数

    • apply 函数

    • also 函数

  • 运算符重载

空安全Kotlin

  • 在 Java 不用强制我们处理空对象,所以常常会导致 NullPoint变量的指针其含义是指该变量的erException 空指针出现,现在 Kotlin 对空对象进行了限定,必须在编译时处理对象是否为空的情况,不然会导致编译不通过开源众包

  • 在对象不可空的情况下,可以直接使用这个对象

fun getText() : String {
    return "text"
}
val text = getText()
print(text.length)
  • 在对象可空的情况下,必须要判断对象是否为空
fun getText() : String? {
    return null
}
val text = getText()
if (text != null) {
    print(text.length)
}
// 如果不想判断是否为空,可以直接这样,如果 text 对象为空,则会报空指针异常,一般情况下不推荐这样使用
val text = getText()
print(text!!.length)
// 还有一种更好的处理方式,如果 text 对象为空则不会报错,但是 text.length 的结果会等于 null
val text = getText()
print(text?.length)

方法支持添加默认参数

  • 在 Java 方法上,我们可能会为了扩展某个方法而进行多次重载
public void toast(String text) {
    toast(this, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text) {
    toast(context, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text, int time) {
    Toast.makeText(context, text, time).show();
}
toast("弹个吐司");
toast(this, "弹个吐司");
toast(this, "弹个吐司", Toast.LENGTH_LONG);
  • 但是在 Kotlin 上面,我们无需进行重载,可以直接在方法上面直接定义参数的默apple认值
fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
    Toast.makeText(context, text, time).show()
}
toast(text = "弹个吐司")
toast(this, "弹个吐司")
toast(this, "弹个吐司", Toast.LENGTH_LONG)

方法上面的参数不可变

  • 在 Java 方法上面,我们可以随意修改方法上面参数的赋值,appstore但是到了 Kotlin 这里是不行的,Kotlin 方法参数上面的变量是 val (对应 Java 的 final)类型的,那么这个时候我们有两种解决方案:

  • 第一种,在方法appearance里面定义一个一模一样的变量,具体写法如下:

class XxxView : View {
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        var widthMeasureSpec: Int = widthMeasureSpec
        var heightMeasureSpec: Int = heightMeasureSpec
        if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
            widthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        if (MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.AT_MOST) {
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
    }
}
  • 但是编译器会报警告,提示我们出java语言现了重复变量,但是仍可正常编译和运行,所以不推荐这种写法

  • 第二种,在方法里面定义一个不同开源中国名称的变量,具体写法如下:

class XxxView : View {
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        var finalWidthMeasureSpec: Int = widthMeasureSpec
        var finalHeightMeasureSpec: Int = heightMeasureSpec
        if (MeasureSpec.getMode(finalWidthMeasureSpec) == MeasureSpec.AT_MOST) {
            finalWidthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        if (MeasureSpec.getMode(finalHeightMeasureSpec) == MeasureSpec.AT_MOST) {
            finalHeightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
    }
}
  • 其实就在原来的基础上加一个 final 前缀,这样不仅解决了编译器警告的问题,还解决了我们还要重新想一个名称来给变量命名的烦恼。

  • 那么肯定有人变量名会问了,有没有办法像 Java 一样改呢?关于这个问题我也纠APP结了一阵子,但是查阅了很多文档和资料,最终发现并没有办法,所以只能妥协了,毕竟这个世界上没有什么事物是完美的。

类方application法扩展

  • 可以在不用继承的情况下对扩展原有类的方法,例如对 StrAPPing 类进行扩展方法
fun String.handle() : String {
    return this + "Android轮子哥"
}
// 需要注意,handle 方法在哪个类中被定义,这种扩展只能在那个类里面才能使用
print("HJQ = ".handle())
HJQ = Android轮子哥

函数变量

  • 在 Kotlin 语法中函数Java是可以作为变量进行传递的
var result = fun(number1 : Int, number2 : Int) : Int {
    return number1 + number2
}
  • 使用这个函数变量
println(result(1, 2))

内联函数

  • 有人可能会问了,内联函数是虾米开源节流什么意思?我举个栗子,用 Kotlin 编写以下代码
class Demo {
    fun test() {
        showToast("666666")
    }
    /**
     * 这个就是我们今天的主角:内联函数了,用 inline 关键字来修饰
     */
    private inline fun showToast(message: String) {
        ToastUtils.show(message)
    }
}
  • 经过反编译之后,会变成以下代码:
/* compiled from: Demo.kt */
public final class Demo {
    public final void test() {
        ToastUtils.show("666666");
    }
}
  • 看到这里相信大家应该知道内联函数的用法和作用了,内联函数就是在编译的时候将所有调用 inline 函数的代码直接替换成方法里面的代码,那么大家可能有疑问了,这样做有什么实际好处呢?它其实提升了代码的性能,这跟基本数据类型的常量会在编译的过程中被优化一样,但是如果 inline 函数被许多处地方调用,并且 inline 函数的实现代码比较多的情况变量下,也会相应导致代码量增加。

  • 另外上面的代码示例中,编java语言译器在 inline 关键字上面有一个代码警告,原话是开源阅读app下载安装这样的java编译器

Expected performance impact from inlining is insignificant. Inlining works best for functkotlin为什么流行不起来ions with papplea开源代码网站githubrameters of functional types

内联对性能的预期影响是微不足道的。内联最适用于参数为函数类型的函数

  • 大致的意思是,上面的代码示例中,内联函数能起到开源阅读app下载安装的性变量类型有哪些能优化是微不足道的,它比较适合带有 lambda 参数的函数,根据这个提示,将上面的代码示例修改成下面这样就不会报代码警告了:
class Demo {
    fun test() {
        showToast({
            println("测试输出了")
        }, "7777777")
    }
    private inline fun showToast(function: () -> Unit, message: String) {
        function.invoke()
        ToastUtils.show(message)
    }
}
  • 有人可能会好奇了,这样就能有很大的性能提升?有什么判断依据呢?接下来让我们做变量的定义一组实验,加 inline 和不加 inline 反编变量的指针其含义是指该变量的译出来的代码有什么区别,先来看加 inline 之后反编译出来的代码长啥样
/* compiled from: Demo.kt */
public final class Demo {
    public final void test() {
        System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
        ToastUtils.show("7777777");
    }
}
  • 一切都在java模拟器预料之中,那么不加 inline 反编译出来又是什么效果呢?
/* compiled from: Demo.kt */
public final class Demo {
    public final void test() {
        showToast(1.INSTANCE, "7777777");
    }
    private final void showToast(Function0<Unit> function, String message) {
        function.invoke();
        ToastUtils.show(message);
    }
}
/* compiled from: Demo.kt */
final class Demo$test$1 extends Lambda implements Function0<Unit> {
    public static final Demo$test$1 INSTANCE = new Demo$test$1();
    Demo$test$1() {
        super(0);
    }
    public final void invoke() {
        System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
    }
}
  • 很明显,不加 inline 会导致多生成一个内部类,这个是 lambda 函数多出来的类,并且里面的示例还是静态,这无开源节流什么意思疑会增加内存消耗,另外这样还有另外一个好处,就是能少一层方法栈的调用。

  • 除了 inline (内联)这个关键字,还开源中国有另外一个关键字:noinline(禁止内联),大家可能到这app小胖子里就摸不着头脑了,这个有啥用?我不在方法上面写 inline 不就是不会内联了么?那java培训么这个关键字是有什么作用呢?其实这个关键字不是修饰在方法上面的,开源矿工而是修饰 在 lappointmentambda 参数上面的,假设一个 inline 函数上面有多个 lambda 参数,那么我只想对某个java模拟器 lambda 参数内联,其他 lambda 参数不内联的情况下,就可以使用这个关键字来对不需要进行内联的 lambda 参数进行修饰,大体用法如下:

private inline fun showToast(function1: () -> Unit, noinline function2: () -> Unit, message: String) {
    function1.invoke()
    function2.invoke()
    ToastUtils.show(message)
}

委托机制

类委托
  • 先让我们来看一段代码
// 定义日志策略接口
interface ILogStrategy {
    fun log(message: String)
}
// 实现一个默认的日志策略类
class LogStrategyImpl : ILogStrategy {
    override fun log(message: String) {
        Log.i("测试输出", message)
    }
}
// 创建一个日志代理类
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy
  • 看到这里大家可能有一些疑惑

    • ILogjava面试题Strategyappointment by strategyjava培训 是虾米操作?

    • LogStrategyProxy 这个类不去实现接口方法难道不会导致编译不通过么?

  • 关于这两个问题,我觉得都可以APP用同一个解释,LogStrategyProxy 之所以不用实现 ILogStrategy 的 lappointmentog 方法,是因为在 ILogStrategy 接口后面加了 by strategy,而 strategy 对象就是 LogStrategyProxy 构造函数中的变量,意思是让这个接口的具体实现由变量的指针其含义是指该变量的 strategy 对象帮我实现就可以了APP,我(LogStrategyProxy 类)不需要再实现一遍了,这样是不是跟 Jajava怎么读va 中的静态代理很像?只不过在 Kotlin 类委托特性上面编译器帮我们自动生成接口方法的代码,你可以把它想象下面这样的代码java模拟器

class LogStrategyProxy(val strategy: ILogStrategy) : ILogStrategy {
    override fun log(message: String) {
        strategy.log(message)
    }
}
  • 有人肯定会问了:口说无凭,我凭什么相信你就是这样的代码?

  • 这是个好问题,我提供一下反编译之后的代码,大家看一下就能明白了:

public final class LogStrategyProxy implements ILogStrategy {
    private final /* synthetic */ ILogStrategy $$delegate_0;
    public LogStrategyProxy(@NotNull ILogStrategy strategy) {
        Intrinsics.checkNotNullParameter(strategy, "strategy");
        this.$$delegate_0 = strategy;
    }
    public void log(@NotNull String message) {
        Intrinsics.checkNotNullParameter(message, "message");
        this.$$delegate_0.log(message);
    }
}
  • 是不是就立马顿悟了?调用变量的定义的话也很简单,代码如下:
val logStrategyImpl = LogStrategyImpl()
LogStrategyProxy(logStrategyImpl).log("666666")
  • 最后让我们看看输出的日志:
测试输出: 666666
  • java环境变量配置个我突然有一个kotlin语言大胆的想法,在使用类委托appointment的情况下,再去重写它的接口方法呢?例如下面的:
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy {
    override fun log(message: String) {
        println("测试输出 " + message)
    }
}
  • 关于这个问题我已经做过实践了,是开源矿工木有问题的,大家放心大胆搞。
属性委托
  • 看过了上面的类委托,想必大家对委托有一定的了解了,那么属性委托是什么呢?简单来讲,类委托是为了帮我们减少一些实现代码,而属性委托是为了帮我们控制变量的 Get、Set 的操作了,废话不多说,下面演示一下用法,下面先创建一个委托类
class XxxDelegate {
    // 先给它一个默认值
    private var currentValue: String = "666666"
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("测试字段名为 ${property.name} 的变量被访问了,当前值为 $currentValue")
        return currentValue
    }
    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        currentValue = newValue
        println("测试字段名为 ${property.name} 的变量被赋值了,当前值为 $currentValue" + ",新的值 $newValue")
    }
}
  • 使用代码示例如下:
var temp: String by XxxDelegate()
println("测试输出 " + temp)
temp = "55555"
println("测试输出 " + temp)
  • 具体日志输出如下:
System.out: 测试字段名为 temp 的变量被访问了,当前值为 666666
System.out: 测试输出 666666
System.out: 测试字段名为 temp 的变量被赋值了,当前值为 55555,新的值 55555
System.out: 测试字段名为 temp 的变量被访问了,当前值为 55555
System.out: 测试输出 55555
  • 看到这里你是否明白了,这个 XxxDelegate 类里面只有两个方法,一个是 getValue,另外一个是 setValue,从方法命名上我们已经能大致得出它的作用了,这里就不再多讲解了,var temp: String by XxxDelegate(开源节流) 表示这个 temp 对象的创建会全权委托app小胖子XxxDelegate 这个类来做。
懒委托
  • 什么是懒委托呢?大家开源阅读app下载安装知道单例模式中的懒汉式吧?这个跟它差不多,只不过我们不需要写静态方法和锁机制了,只需要像下面这样写:
val temp: String by lazy {
    println("测试变量初始化了")
    return@lazy "666666"
}
  • 调用代码如下:
println("测试开始")
println("测试第一次输出 " + temp)
println("测试第二次输出 " + temp)
println("测试结束")
  • 输出日志如下:
System.out: 测试开始
System.out: 测试变量初始化了
System.out: 测试第一次输出 666666
System.out: 测试第二次输出 666666
System.out: 测试结束
  • 是不变量4是真的跟懒汉式差不多?只不过这种写法简化了很多,另外在日常开发中我们可以用它来做 findViewById 是最适合不过的。
private val viewPager: ViewPager? by lazy { findViewById(R.id.vp_home_pager) }
  • 另外懒委托还提供了几种懒加载模式供我们选择,

    • LazyTh开源软件readSafetyMode.SYNCHRONIZED:同步模式,确保只有单个线程可以初始化实例,这种模式下初始化时线程安全的,当 by lazy 没有指定模式的时候,就是默认用的这种模式。

    • LazyThreadSafetyMode.PUBLICATkotlin和javaION:并发模式,在多线程下允许并发初始化,但是只有第一个返回的值作为实例,这种模式下是线程安全的,和 LazyThreadSafetyMode.SYNCHRONIZED 最大区Java别是,这种模式在多线程并发访问下初始化效率是最高的,本质上面是用空间换时间,哪个的线程执行快就让哪个先返回结果,其他线程执行的结果抛弃掉。

    • LazyThreadSafetyMode.NONE:普通模式,这种模式不会使用锁来限制多线程访问java模拟器,所以是线程不安全的,所以请勿在多线程并发的情况下使用。

  • 具体使用的方式也很简单,如下:

val temp: String by lazy(LazyThreadSafetyMode.NONE) {
    println("测试变量初始化了")
    return@lazy "666666"
}
  • 另外有一点需要注意,使用懒委托的变量必须声明为kotlin下载 val(不可变的),因为它只能被赋值一次。

扩展函数

  • 扩展函数是 KoKotlintlin 用于简化一些代码的书写产生的,其中有 let、with、rkotlin语言un、apply、also 五个函数
let 函数
  • 在函数块内可以变量名的命名规则通过 it 指代该对象。返回值为函数块的最后一行或指定 return 表达式

  • 一般写法

fun main() {
    val text = "Android轮子哥"
    println(text.length)
    val result = 1000
    println(result)
}
  • let 写法
fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result)
}
  • 最常用的场景就是使用let函数处理需要针对一个可 null 的对象统一做判空处理
videoPlayer?.setVideoView(activity.course_video_view)
videoPlayer?.setControllerView(activity.course_video_controller_view)
videoPlayer?.setCurtainView(activity.course_video_curtain_view)
videoPlayer?.let {
   it.setVideoView(activity.course_video_view)
   it.setControllerView(activity.course_video_controller_view)
   it.setCurtainView(activity.course_video_curtain_view)
}
  • 又或者是需要去明确一个变量所处特定的作用域范围内可以使用
with 函数
  • 前面的几个函数使用方式略有不同,因变量4为它开源节流什么意思不是以扩展java环境变量配置的形式存在的。它是将某对象作为函数的参数,在函数块变量与函数内可以通过 this 指代该对象,返回值为函数块的最后一行或指定 return 表达式

  • 定义 Person 类

class Person(var name : String, var age : Int)
  • 一般写法
fun main() {
    var person = Person("Android轮子哥", 100)
    println(person.name + person.age)
    var result = 1000
    println(result)
}
  • with 写法
fun main() {
    var result = with(Person("Android轮子哥", 100)) {
        println(name + age)
        1000
    }
    println(result)
}
  • 适用于调用同一个类的多kotlin为什么流行不起来个方appointment法时,可以省去类名重复,直接调用类的方法即可,经常用于 Android 中 RecyclAPPerVijava面试题ew.onBinderViewHolder 中,数据 model 的属性映射到 UI 上
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名:${item.name}"
    holder.ageView.text = "年龄:${item.age}"
}

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    with(item){
        holder.nameView.text = "姓名:$name"
        holder.ageView.text = "年龄:$age"
    }
}
run 函数
  • 实际上可以说是 let 和 with 两个变量英文函数的结合体,run 函数只接收一个 lambda 函数为参数,以闭包开源形式返回,返回值为最后一行的值或者指定的 return 的表达式

  • 一般写法

var person = Person("Android轮子哥", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)
  • run 写法
var person = Person("Android轮子哥", 100)
var result = person.run {
    println("$name + $age")
    1000
}
println(result)
  • 适用于 let,with 函数任何场景。因为 run 函数是let,with两个函数结合体kotlin现在不火了,准确来说它弥补了 let 函数在函数体javascript百炼成仙内必须使用 it 参数替代对象,在 run 函数中可以像 with 函数一样可以省略,直接访问实例的公有属性和方法,另一方面它弥补了 with开源阅读app下载安装 函数传入对象判空问题,在 run 函数中可以像l et 函数一样做判空处理,这里变量4还是借助 onBindViewHolder 案例进行简化
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名:${item.name}"
    holder.ageView.text = "年龄:${item.age}"
}

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    item?.run {
        holder.nameView.text = "姓名:$name"
        holder.ageView.text = "年龄:$age"
    }
}
apply 函数
  • 从结构上来看 apply 函数和 run 函数很像,唯一不同点就是它们各自返回的值不一样,run 函数变量的定义是以闭包形式返回最后一行代码的值,而 apply 函数的返回的是传入对象的本身

  • app小胖子般写法

val person = Person("Android轮子哥", 100)
person.name = "HJQ"
person.age = 50
  • apply 写法Java
val person = Person("Android轮子哥", 100).apply {
    name = "HJQ"
    age = 50
}
  • 整体作用功能和 run 函数很像,唯开源节流什么意思一不同点就是它返回的值是对象本身,而 ru开源软件n 函数是一个闭包形式返回,返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与 run 函数有点不一样。apply 一般用于一个变量的定义对象实例初始化的时候,需要对对象中的属性进行赋值。或者动javaee态 inflat变量的定义e 出一个 XMappearL 的 View 的时候需要给 View 绑定数据也会用到,这种javascript情景非常常见。特别是在我变量的定义们开发中会有一application些数据 model 向 V变量4iew model 转化实例化的过程中需要用到
mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0
  • 使用 apply 函数后java面试题的代码是这样的
mRootView = View.inflate(activity, R.layout.example_view, null).apply {
   tv_cancel.paint.isFakeBoldText = true
   tv_confirm.paint.isFakeBoldText = true
   seek_bar.max = 10
   seek_bar.progress = 0
}
  • 多层级判空问题
if (sectionMetaData == null || sectionMetaData.questionnaire == null || sectionMetaData.section == null) {
    return;
}
if (sectionMetaData.questionnaire.userProject != null) {
    renderAnalysis();
    return;
}
if (sectionMetaData.section != null && !sectionMetaData.section.sectionArticles.isEmpty()) {
    fetchQuestionData();
    return;
}
  • kotjavascriptlin 的 apply 函数优化
sectionMetaData?.apply {
	// sectionMetaData 对象不为空的时候操作sectionMetaData
}?.questionnaire?.apply {
	// questionnaire 对象不为空的时候操作questionnaire
}?.section?.apply {
	// section 对象不为空的时候操作section
}?.sectionArticle?.apply {
	// sectionArticle 对象不为空的时候操作sectionArticle
}
also 函数
  • also 函数的结构实际上和 lappearet 很像唯一的区别就是返回值的不一样,let 是以闭包的形式返回,返回函数体内最后一行的值,如果最后一行为空就返回一个 Unit 类型的默认值。而 als开源众包o 函数返回的则是传入对象的本身
fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result) // 打印:1000
}
fun main() {
    val result = "Android轮子哥".also {
        println(it.length)
    }
    println(result) // 打印:Android轮子哥
}
  • 适用于 let 函数的任何场景,also 函数和 let 很像,只是唯一的不同点就是 let 函数最开源是什么意思后的返回值是最后一行的返回值而 also 函数的返回值是返回java环境变量配置当前的这个对象。一般可用于多个扩展函数链式调用

运算符重载

  • 在 Kotlin 中使用运算符最终也会调用对appear象对应的方法,我们可以通过重写这些方法使得这个对象支持运算符,这开源阅读app下载安装里不再演示代码
运算符调用方法
+aa.unaryPlus()
-aAPPa.unaryMinus()
!aa.not()
运算符调用方法
a++a.inc()
a–a.dec()
运算符调用方法
a + ba.plus(b)
a – ba.minapple苹果官网us(b)
a * ba.变量值times(b)
a / ba.div(b)
a % ba.rem(b), a开源中国.mod(b) (depr开源众包ecated)
a..ba.rangeTo(b)
运算符调用方APP
a in bb.contains(a)
a !in b!b.contains(a)
运算符调用方法
a[i]a.getJava(i)
a[i, j]a.get(i, j)
a[i_1, …, i_n]a.get(i_1, …, i_njava模拟器)
a[i] = ba.set(i, b)
a[i, j] = ba.set(i, j, b)
a[i_1, …, i_n] = ba.set(i_1, …, i_n, b)
运算符调用方法
a()a.invoke开源中国()
a(i)a.inv开源阅读oke(i)
a(i, j)a.invoke(i, j)
a(i_1, …, i_n)a.invoke(i_1java编译器, .javascript百炼成仙.., i_n)
运算符调用方法
a +=javascript ba.pluskotlin现在不火了Assign(b)
a -= ba.minusAssign(b)
a *= ba.timesAssign(b)
a /= ba.divAssign(b)
a %= ba.remAssign(b), a.modAssign(b) (deprecated)
运算符调用方法
a == ba?.equalsjava模拟器(b) ?: (b === null)
a != b!(a?.equals(b) ?: (b === null))
运算符调用方法
a > ba.compareTo(b) > 0
a < ba.compareTo(b) < 0
a >= ba.compareTo(b) >= 0
a <= ba.compareTo(b) &lkotlin下载t;= 0

下一篇:全民 Kkotlin现在不火了otlin:协程特别篇

另外推荐一个 Kotlin 语言编写的开源项目,大家感变量兴趣可以看看:AndroidProject-Kotlin

Androijava面试题d 技术分享 QQ 群:78797078

发表评论

提供最优质的资源集合

立即查看 了解详情