Kotlin常用语法规则进阶
·
构造属性
在主构造参数前⾯加上 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.对象声明
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"
更多推荐
所有评论(0)