kotlin学习：val与var区别，by lazy与lateinit区别

本文主要是介绍kotlin学习：val与var区别，by lazy与lateinit区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Kotlin: Java 6 废土中的一线希望

【Bugly 技术干货】Android开发必备知识：为什么说Kotlin值得一试

Kotlin for android developers中文翻译

Kotlin中var和val的区别

Kotlin中有两个关键字定义变量，这两个关键字外形看着差别很小就只差了一个字母，但实际差别很大的。

var是一个可变【变量】，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和java中声明变量的方式一样。

val是一个只读【常量】，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。

var name = "zhang san"
println(name)
name = "li si"
println(name)
val finalValue = "我是不可改变的";
println(finalValue);

/*** var变量*/
fun main(args: Array<String>){var  x = 5 //推导出Int类型x += 1println("x = $x")
}

/*** val常量*/
fun main(args: Array<String>){val a: Int = 1 //立即初始化val b = 2 //推导出Int类型val c: Int //当没有初始化值的时候必须声明类型c = 3 //赋值
}

lateinit （var）和 by lazy（val）

lateinit 和 lazy 是 Kotlin 中的两种不同的【延迟初始化】的实现

1.lateinit 只用于变量 var，而 lazy 只用于常量 val

2.lateinit不能用在可空的属性上和java的基本类型上

val name: String by lazy { "****" }//正确
private val name: Int by lazy { 1 }//正确
private lateinit var test:String //正确lateinit val test:String //错误
lateinit var test:Float //错误

示例


fun main(args: Array<String>) {val country = Country()//    country.name = "India"
//    println(country.name)country.setup()
}class Country {lateinit var name: Stringfun setup() {name = "USA"println("The name of country is $name")}
}// lateinit used only with mutable data type [ var ]
// lateinit used only with non-nullable data type
// lateinit values must be initialised before you use it
// lateinit var
// 只用在var可变值 ， 非空值 ， 再用之前必须初始化否则异常// If you try to access lateinit variable without initializing it
// then it throws UninitializedPropertyAccessException

val pi: Float by lazy {3.14f
}fun main(args: Array<String>) {println("Some initial code.....")// pi is not initialised yet 还未初始化val area1 = pi * 4 * 4// pi gets initialised and assigned the value of 3.14f for the first time// 第一次初始化val area2 = pi * 9 * 9// The value pi is loaded from cache memory// 直接使用缓存值println("Some more code....")
}// ‘lazy initialization’ was designed to prevent unnecessary initialization of objects.
// You variables will not be initialised unless you use it in your code
// It is initialized only once. Next time when you use it, you get the value from cache memory.
// by lazy
// 避免不必要的初始化 ， 初始化只有一次 ， 下次使用缓存// It is thread safe
// It is initialized in the thread where it is used for the first time.
// Other threads use the same value stored in the cache
// 线程安全，在初始化的线程// The variable can be var or val.
// The variable can be nullable or non-nullable
// 可使用在var 或 val

!!. 与 ?. 的区别

?. 与 !!. 都是Kotlin提供的检测空指针的方法。

？”来明确指定一个对象，或者一个属性变量是否可以为空。

private var mContext: Context? = null

"?"加在变量名后，系统在任何情况不会报它的空指针异常。
"!!"加在变量名后，如果对象为null，那么系统一定会报异常！

？.


//kotlin:
a?.run()//与java相同:
if(a!=null){a.run();
}		//不会空指针

!!.

//kotlin:
a!!.run()//与java相同: 
if(a!=null){a.run();
}else{	//会空指针throw new KotlinNullPointException();
}

NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，
字段后加!!像Java一样抛出空异常，
另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

//类型后面加?表示可为空
var age: String? = "23" //抛出空指针异常
val ages = age!!.toInt()//不做处理返回 null
val ages1 = age?.toInt()//age为空返回-1
val ages2 = age?.toInt() ?: -1