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 += 1
    println("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: String

    fun 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

java文件转kotlin