shift +shift  kotlin bytecode  查看字节码

定义常量与变量

可变变量定义：var 关键字

var <标识符> : <类型> = <初始化值>

不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)

val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化

编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

va1 a:Int =1
va1 b = 1 //系统自动推断变量类型为Int
va1 c :Int  // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值

var d=5  // 系统自动推断变量类型为Int
x += 1           // 变量可修改

变量

var 关键字   

        Kotlin 使用 var 关键字定义可变变量(可读可写)，类似Java中的一般变量。

        跟 Java 的区别就是 类型的位置从变量名前面挪到变量名后面了。如下图：

        语法

        实践

fun main() {
    var str:String ="helle world"
    println(str)
    val sr:String = "wo men"
    println(sr)
    str=" ha ha "
    //sr="ss"//错误。常量不可修改
}

val 关键字  仅赋值一次

        Kotlin 使用 val 关键字定义不可变变量，只能赋值一次的变量(类似Java中final修饰的变量)，不是常量不能混淆呦。

        语法

val <变量名> : <类型> = <初始化值>

类型推断
        对于已声明并赋值的变量，它允许你省略类型定义。

  var  str ="hello world" //自动推断类型
  val  age =20//自动推断

编译时常量  const  val 
        编译时常量只能在函数之外定义,为什么？

        因为编译时常量必须在编译时赋值，而函数都是在运行时才调用，函数内的变量也是在运行时赋值。

        编译时常量只能是常见的基本数据类型:String、 Int、Double、Float、Long.Short、Byte、Char、Boolean。

        类似Java的public static final。

const val MAX = 65535
fun main() {
    println(MAX)
}

 

延迟初始化lateinit

• 使用lateinit关键字相当于做了一个约定:在用它之前负责初始化

• lateinit用于延迟属性初始化的，语法如下所示：

  lateinit var 变量名 : 非基本类型

class lateinitClass{

lateinit var   s


}
fun main(){
var lateinitc =lateInit()
lateinitc.s =" 延迟加载"
println(lateinitc.s)
}

• 执行islnitialized检查lateinit变量是否完成初始化

   lateinit var bookAnthor:String

//检查延迟加载
    @JvmName("setBookAnthor1")
    fun setBookAnthor(anthor:String){
        bookAnthor=anthor
    }
    fun getBoookAnthor(): String {
       return if(::bookAnthor.isInitialized){
              bookAnthor
       }else{
           ""
       }
    }

惰性初始化by lazy 只能是常量

        你可以暂时不初始化某个变量，直到首次使用它再进行初始化，这个叫作惰性初始化。

class LateinitClass {
    lateinit var name:String

    fun setNames(_name:String){
        this.name =_name
    }
    fun readNmae(){
        if(::name.isInitialized) {
            println(name)
        }else{
            println("name is null")
        }
    }


    val age by lazy{addage()}
    //惰性初始化
    //如果不调用age， ageAdd()函数永远不执行

    fun addage():Int{
        return 8
    }
}

fun main(args:Array<String>){
    var LateinitClass = LateinitClass()
    LateinitClass.setNames("wo shi luo j")
    LateinitClass .readNmae()

    println("-----------")
    println(LateinitClass.age)
}

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)
    //[0,2,4]
    val b = Array(3, { i -> (i * 2) })

    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}

如上所述，[] 运算符代表调用成员函数 get() 和 set()。

注意: 与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

创建数组的几种方式

1.arrayOf()

   

 /*通过arrayof()函数创建数组，数组里面可以放任何类型的数据*/
    var arrA = arrayOf(1, 2, "3", true)

2.arrayOfNulls()

    /*创建一个空数组并指定其数据类型和长度*/
    var arrB = arrayOfNulls<String>(3)
    /*赋值*/
    arrB[0] = "1"
    arrB[1] = "2"
    arrB[2] = "3"

3.Array（size，fun）

    /*通过构造函数 指定size和一个表达式=  index为下标  从0开始一直到size-1  */
    var arrC = Array(3, { index -> index })  //[0,1,2]

4.原始类型数组函数

Kotlin 也有无装箱开销的专门的类来表示原生类型数组，并提供了相应的函数用于构建这些数组

    /*创建一个ByteArray*/
    var byteArr = byteArrayOf(1, 2, 3, 4, 5)
    /*创建一个ShortArray*/
    var shortArr = shortArrayOf(1, 2, 3, 4, 5)
    /*创建一个IntArray*/
    var intArr = intArrayOf(1, 2, 3, 4, 5)
    /*创建一个LongArray*/
    var longArr = longArrayOf(1L, 2L, 3L)
    /*创建一个FloatArray*/
    var floatArr = floatArrayOf(1.0f, 2.0f, 3.0f)
    /*创建一个DoubleArray*/
    var doubleArr = doubleArrayOf(1.0, 2.0, 3.0)
    /*创建一个CharArray*/
    var charArr = charArrayOf('1', '2', '3')