构造属性

在主构造参数前⾯加上 var/val 使构造参数同时成为成员变量
在这里插入图片描述

data class

数据类同时会⽣⽣成

  • toString()
  • hashCode()
  • equals()
  • copy() (浅拷⻉)
  • componentN()…

相等性

  • == 结构相等 (调⽤ equals() ⽐较 )
  • === 引⽤(地址值)相等

解构

可以把⼀个对象「解构」成很多变量
在这里插入图片描述
对应的 Java 代码
在这里插入图片描述

Elvis 操作符

可以通过 ?: 的操作来简化 if null 的操作
在这里插入图片描述

when 操作符

when 表达式可以接受返回值,多个分⽀相同的处理⽅式可以放在⼀起,⽤逗号分
隔
在这里插入图片描述
when 表达式可以⽤来取代 if-else-if 链。如果不提供参数,所有的分⽀条件
都是布尔表达式
在这里插入图片描述

operator

通过 operator 修饰「特定函数名」的函数,例如 plus 、 get ,可以达到重
载运算符的效果
在这里插入图片描述

lambda

如果函数的最后⼀个参数是 lambda ,那么 lambda 表达式可以放在圆括号之
外:
在这里插入图片描述
如果你的函数传⼊参数只有⼀个 lambda 的话,那么⼩括号可以省略的:

在这里插入图片描述
如果 lambda 表达式只有⼀个参数,那么可以省略,通过隐式的 it 来访问
在这里插入图片描述

infix 函数

定义:Kotlin允许在不使用括号和点号的情况下调用函数,那么这种函数被称为 infix函数。

  • 必须是成员函数或扩展函数
  • 必须只能接受⼀个参数,并且不能有默认值
//示例代码:       
val map = mapOf(1 to "one", 2 to "two")
Log.i(TAG, "onCreate: $map")
//打印onCreate: {1=one, 2=two}
        
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

public data class Pair<out A, out B>(
    public val first: A,
    public val second: B
) : Serializable {

    /**
     * Returns string representation of the [Pair] including its [first] and [second] values.
     */
    public override fun toString(): String = "($first, $second)"
}        

潜逃函数

定义:Kotlin 中可以在函数中继续声明函数

  • 内部函数可以访问外部函数的参数
  • 每次调⽤时,会产⽣⼀个函数对象
    在这里插入图片描述

函数参数默认值

可以通过函数参数默认值来代替 Java 的函数重载
在这里插入图片描述

类委托

可以通过类委托的模式来减少继承
类委托的,编译器会优先使⽤⾃身重写的函数,⽽不是委托对象的函数
在这里插入图片描述

object UserInfoCache {

	 var userName: String by Save("user_name")
	 
	class Save(var key: String) {
        operator fun getValue(userInfoCache: UserInfoCache, property: KProperty<*>): String {
            return SpUtils.getString(key, "")
        }

        operator fun setValue(userInfoCache: UserInfoCache, property: KProperty<*>, s: String) {
            SpUtils.putString(key, s)
        }
    }
}

object关键字

  1. 对象声明
  2. 伴生对象
  3. 对象表达式
//1.对象声明
object Utils {
    fun print(ct: Context, msg: String) {
        Toast.makeText(ct, msg, Toast.LENGTH_SHORT).show()
    }
}
Utils.print(this,"你好")

//2.伴生对象
companion object {
   lateinit var context: Context
}
override fun onCreate() {
    super.onCreate()
    context = applicationContext
}

//3.对象表达式
tv2.setOnClickListener(object : View.OnClickListener{
    override fun onClick(v: View?) {
    }
})

 bindService(
 Intent(this,IService::class.java),
  //3.对象表达式
  object : ServiceConnection{
      override fun onServiceConnected(name: ComponentName?, service: IBinder?) {

      }

      override fun onServiceDisconnected(name: ComponentName?) {

      }

  },
  BIND_AUTO_CREATE
)

this@MainActivity 与 MainActivity@this

  • MainActivity@this
    this名称为“MainActivity”的标签
  • this@MainActivity
    是this来自 MainActivity的实际引用
 tv1.setOnClickListener {
 //this名称为“MainActivity”的标签
  Toast.makeText(MainActivity@this, "jjj", Toast.LENGTH_SHORT).show()
  Toast.makeText(this, "kkk", Toast.LENGTH_SHORT).show()
}

 tv2.setOnClickListener(object : View.OnClickListener{
    override fun onClick(v: View?) {
        //是this来自 MainActivity的实际引用
        Toast.makeText(this@MainActivity, "jj", Toast.LENGTH_SHORT).show()
    }
})

lateinit 和 by lazy

  • lateinit 只用于变量 var,而 lazy 只用于常量 val
lateinit var context: Context

private val lazyValue :String by lazy {
    "你好"
}

inline

  • 在kotlin中,函数就是对象,当你调用某个函数的时候,就会创建相关的对象
  • inline 关键字的作用,是把 inline 方法以及方法中的 lambda 参数在编译期间复制到调用方,进而减少函数调用以及对象生成。对于有时候我们不想让 inline 关键字对 lambda 参数产生影响,可以使用 noline 关键字。如果想 lambda 也被 inline,但是不影响调用方的控制流程,那么就要是用 crossinline。
  • 部分禁⽤⽤内联
    noinline 可以禁⽌部分参数参与内联编译
    在这里插入图片描述
private val photographDialog: Dialog by lazy(mode = LazyThreadSafetyMode.NONE) {
    DialogFactory().createSelectPhotographDialog(this, {
        Toast.makeText(this, "拍照", Toast.LENGTH_SHORT).show()
    }, {
        Toast.makeText(this, "拍视频", Toast.LENGTH_SHORT).show()
    })
}

override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  photographDialog.show()
}
class DialogFactory {

    inline fun createSelectPhotographDialog(
        context: Context,
        crossinline takePhotosCall: () -> Unit,
        crossinline takeAVideoCall: () -> Unit,
    ): Dialog {
        val dialog = Dialog(context, R.style.common_transparent_dialog)
        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
        dialog.setCanceledOnTouchOutside(true)
        dialog.setContentView(R.layout.study_dialog_select_photograph)

        val mTakePhotosTv = dialog.findViewById<TextView>(R.id.mTakePhotosTv)
        val mTakeAVideoTv = dialog.findViewById<TextView>(R.id.mTakeAVideoTv)
        val mCancelTv = dialog.findViewById<TextView>(R.id.mCancelTv)

        mCancelTv.setOnClickListener { dialog.dismiss() }
        mTakePhotosTv.setOnClickListener {
            dialog.dismiss()
            takePhotosCall.invoke()//与takeAVideoCall()等价
        }
        mTakeAVideoTv.setOnClickListener {
            dialog.dismiss()
            takeAVideoCall()
        }

        return dialog
    }
}

reified关键字

  • reified关键字是用于Kotlin内联函数的,修饰内联函数的泛型,泛型被修饰后,在方法体里,能从泛型拿到泛型的Class对象,这与java是不同的,java需要泛型且需要泛型的Class类型时,是要把Class传过来
inline fun <reified T:Activity> Context.startActivity(vararg params: Pair<String,String>){
    val intent  = Intent(this,T::class.java)
    params.forEach { intent.putExtra(it.first,it.second) }
    startActivity(intent)
}

:: 双冒号操作符 与 lambda表达式

  • 双冒号操作符 表示把一个方法当做一个参数
method("参数1","参数2") {
      Log.i("cyc", "method")
  }

method2("参数1","参数2"){
    Log.i("cyc", "method2$it")
}

method3("参数1","参数2"){
    s1, s2 ->   Log.i("cyc", "method3$s1, $s2")
}

Log.i("cyc", method4("参数1","参数2"){
        s1, s2 -> "我是1$s1 ,我是$s2"
})
Log.i("cyc", method4("2参数1","参数2",::getResult))
Log.i("cyc", method4("3参数1","参数2",this::getResult))
Log.i("cyc", method4("4参数1","参数2",MainActivity@this::getResult))


private fun method(str1: String, str2: String, result: () -> Unit) = result.invoke() //等价于 result()

private fun method2(str1: String, str2: String, result: (s1: String) -> Unit) = result(str1)

private fun method3(str1: String, str2: String, result: (s1: String, s2: String) -> Unit) = result(str1,str2)

private fun method4(str1: String, str2: String, result: (s1: String, s2: String) -> String): String = result(str1,str2)

private fun getResult(s1: String, s2: String): String = "我是$s1 ,我是$s2"
Logo

开源鸿蒙跨平台开发社区汇聚开发者与厂商,共建“一次开发,多端部署”的开源生态,致力于降低跨端开发门槛,推动万物智联创新。

更多推荐