Kotlin：变量、常量、注释

数值类型

内置类型

Byte=> 字节 => 8位
Short => 短整型 => 16位
Int => 整型 => 32位
Long => 长整型 => 64位
Float => 浮点型 => 32位
Double => 双精度浮点型 => 64位

例如：

 var a: Byte = 2
 var b: Short = 2
 var c: Int = 2
 var d: Long = 2L         //长整型由大写字母L标记
 var e: Float = 2f        //单精度浮点型由小写字母f或大写字符F标记
 var f: Double = 2.0
 println(" a => $a \n b => $b \n c => $c \n d => $d \n e => $e \n f => $f);

进制数

var g = 0x0F            //十六进制数
var h = 0b00001011      //二进制数
var k = 123             //十进制数
// ps：Kotlin不支持八进制数
println(" g => $g \n h => $h \n k => $k);

数字类型字面常量的下划线

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010
println("oneMillion => $oneMillion")
println("creditCardNumber => $creditCardNumber")
println("socialSecurityNumber => $socialSecurityNumber")
println("hexBytes => $hexBytes")
println("bytes => $bytes")

装箱与拆箱

在Kotlin中，存在数字的装箱，但是不存在拆箱。因为Kotlin是没有基本数据类型的，Kotlin是万般皆对象的原则。故不存在和Java中的类似int是数据类型，Integer是整型的引用类型。

在Kotlin中要实现装箱操作。首先要了解可空引用。即类似Int?(只限数值类型)这样的。

val aa:Int = 123
val aaBox:Int ?= aa
println("装箱后：aaBox = $aa")

数值比较

判断两个数值是否相等（==）,判断两个数值在内存中的地址是否相等（===）,其实上面的装箱操作之后其内存中的地址根据其数据类型的数值范围而定。

val numValue: Int = 128
val numValueBox: Int? = numValue
/*   比较两个数字  */var result: Boolean result = numValue == numValueBox
// => true,其值是相等的 
println("numValue == numValueBox => $result")  

result = numValue === numValueBox 
/*   上面定义的变量是Int类型，大于127其内存地址不同，反之则相同。   这是`kotlin`的缓存策略导致的，而缓存的范围是` -128 ~ 127 `。   故，下面的打印为false */
println("numValue === numValueBox => $result")

3.lateinit

使用lateinit关键字

必须是可读且可写的变量，即用var声明的变量
不能声明于可空变量。
不能声明于基本数据类型变量。例：Int、Float、Double等，注意：String类型是可以的。
声明后，在使用该变量前必须赋值，不然会抛出UninitializedPropertyAccessException异常。

// 声明组件
private lateinit var mTabLayout : TabLayout
lateinit var a : Int // 会报错。因为不能用于基本数据类型。
// 赋值
mTabLayout = find(R.id.home_tab_layout)
// 使用
mTabLayout.setupWithViewPager(mViewPager)

4.lazy{}函数用于延迟初始化

所谓延迟初始化即：指当程序在第一次使用到这个变量（属性）的时候在初始化。

使用lazy{}高阶函数，不能用于类型推断。且该函数在变量的数据类型后面，用by链接。
必须是只读变量，即用val声明的变量。

// 声明一个延迟初始化的字符串数组变量
private val mTitles : Array<String> by lazy {    
  arrayOf(            
    ctx.getString(R.string.tab_title_android),
    ctx.getString(R.string.tab_title_ios),
    ctx.getString(R.string.tab_title_h5)
    )
}
// 声明一个延迟初始化的字符串
private val mStr : String by lazy{"我是延迟初始化字符串变量"}

常量

简单用法

加上const

const val NUM_A = 6

const 只能修饰val，不能修饰var

声明常量的三种方法

在顶层声明
在object修饰的类中声明，在kotlin中称为对象声明，它相当于Java中一种形式的单例类
在伴生对象中声明

//顶层声明
const val a:String = "顶层声明"

//在object修饰的类中
object TestConst{
  const val aa = "object 修饰的类中"
}

//伴生对象中
class TestClass{
  companion object {
    const val aaa = "伴生对象中声明"
  }
}

fun main(args: Array<String>) {
  println("a = $a")
  println("aa = $aa")
  println("aaa = $aaa")
}

注释

kotlin的注释和java的注释大同小异

kotlin支持嵌套注释,java不支持，冷知识

如:

/*
  第一层注释
  /*
    第二层注释
      /*
        第三层注释
        */
    */
*/

参考资料：https://github.com/Jetictors/KotlinLearn

juliet_caicai

Kotlin学习（数据类型）