Kotlin实战(一)

1、简介

Kotlin 是一个用于现代多平台应用的静态编程语言，由 JetBrains 开发。
Kotlin可以编译成Java字节码，也可以编译成JavaScript，方便在没有JVM的设备上运行。
Kotlin已正式成为Android官方支持开发语言(Google IO 2017宣布)。

分享关于kotlin的几个网站

kotlin官方网站:https://kotlinlang.org/
kotlin官方网站(中文翻译版):https://www.kotlincn.net/
kotlin在线工具网站(可执行kotlin代码):https://try.kotlinlang.org/

2、基本使用

2.1、第一个Kotlin程序(定义函数)

使用控制台打印出“Hello，Kotlin！”

fun main(args: Array<String>): Unit {
    //打印Hello，Kotlin！
    println("Hello,Kotlin!")
}

fun 固定写法

main 函数名(main函数)

args 函数参数名,可以随便写(如a,bb)

Array 参数类型此处表示字符串数组类型

Unit 函数返回值 ,此处Unit表示无返回值,可以省略不写

println(“Hello,Kotlin!”) 函数体

2.2、基本数据类型

Kotlin 提供了如下的内置类型来表示数字（与 Java 很相近）：

类型(Type)	位宽度(Bit width)
Double	64
Float	32
Long	64
Int	32
Short	16
Byte	8

//基本数据类型定义如下
val byte:Byte=10
val int:Int=100
val long:Long=1L
val double:Double=1.123
val float:Float=1.21212F
val short:Short=10

//布尔(Boolean)类型 它有两个值：true 与 false
val boolean:Boolean=false
//字符(Char)类型 它有两个值：true 与 false
val char:Char='A'

2.3、字面常量

数值常量字面值有以下几种:

十进制: 123
Long 类型用大写 L 标记: 123L
十六进制: 0x0F
二进制: 0b00001011

注意: 不支持八进制

Kotlin 同样支持浮点数的常规表示方法:

默认 double：123.5、123.5e10
Float 用 f 或者 F 标记: 123.5f

2.4、数字字面值中的下划线(自1.1版本起)

可以使用下划线使数字常量更易读

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)//1000000
println(creditCardNumber)//1234567890123456
println(socialSecurityNumber)//999999999
println(hexBytes)//4293713502
println(bytes)//3530134674

2.5、" == " 和 " === "的区别

kotlin	java
==	equal
===	==

val a: Int = 999
val b: Int? = a
val c: Int? = a
println(b == c)    //true
println(b === c)   //false

这个和java中运行结果是在意料之中, == 比较数值, 而===比较的是地址, 前者为true, 后者为false. 那么看下面这段代码的运行情况:

val a: Int = 999
val b: Int = a
val c: Int = a
println(b == c)     // true
println(b === c)    // true

这段代码和第一段代码的区别就是Int和Int?的区别, 为什么=== 的运算结果会不一样呢? 再看下面这段代码

val a: Int? = 999
val b: Int? = a
val c: Int? = a
println(b == c)    //true
println(b === c)   //true

这段代码和第一段代码的区别就是第一行的Int?和Int的区别, 而运行出来的结果 === 也是true。

下面这个就是对上述现象的最好的解释

注意一点: 在 java 平台上，数值被 JVM 虚拟机以字节码的方式物理存储的，除非我们需要做可空标识(比如说 Int?) 或者涉及泛型，在后者中数值是装箱的。也就是说如果我们使用的是val a : Int = 999, 这种方式, 其实a就是个数值, 不涉及装箱的问题, 不是个对象, 而如果我们使用的是val a: Int? = 999, 这样的话, a是一个Int型对象, 涉及到装箱问题, 这样就很好解释为什么第一段代码的===是false, 因为a是数值, 而b, c是装箱后的对象, 而第二段代码a, b, c都是数值, 第三段代码a, b, c都是同一个对象

2.6、基本数据类型取值范围

val maxShort=Short.MAX_VALUE
val minShort=Short.MIN_VALUE
//Short最小值-32768,最大值32767
println("Short最小值$minShort,最大值$maxShort")

val maxInt=Int.MAX_VALUE
val minInt=Int.MIN_VALUE
//Int最小值-2147483648,最大值2147483647
println("Int最小值$minInt,最大值$maxInt")

val maxByte=Byte.MAX_VALUE
val minByte=Byte.MIN_VALUE
//Byte最小值-128,最大值127
println("Byte最小值$minByte,最大值$maxByte")

val maxLong=Long.MAX_VALUE
val minLong=Long.MIN_VALUE
//Long最小值-2147483648,最大值2147483647
println("Long最小值$minInt,最大值$maxInt")

val maxFloat=Float.MAX_VALUE
val minFloat=Float.MIN_VALUE
//Float最小值-2147483648,最大值2147483647
println("Float最小值$minInt,最大值$maxInt")

val maxDouble=Double.MAX_VALUE
val minDouble=Double.MIN_VALUE
//Double最小值-2147483648,最大值2147483647
println("Double最小值$minInt,最大值$maxInt")

2.7、Kotlin调用Java

val m=212.3234343454546546
println(m)
//省略new关键字
val bigDecimal = BigDecimal("212.3234343454546546")
println(bigDecimal)

2.8、智能类型推断和类型转换

/*----------------------kotlin智能类型推断------------------------*/
//    类型安全的语言:类型一但确定,不再改变了
// kotlin 自动推断为Int类型
    var a=10
    var b:Byte=10
    var c=10L//Long
    var d=20F//Float
    var e=1.234//Double

    /*----------------------类型转换------------------------*/
    // String和int类型转换
    val a1="10"
    println(a1.toInt())
    //long类型和int类型转换
    val a2=100L
    print(a2.toInt()
    //int类型和long类型转换
    val a3=10
    print(a3.toLong())

每个数值类型都支持下面的转换:

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

2.9、可变变量和不可变变量

//可变变量
var a=10
a=11
//不可变变量
val b=1

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

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

不可变对象也可以说是线程安全的，因为它们无法去改变，也不需要去定义访问控制，因为所有线程访问到的对象都是同一个。所以在Kotlin中，如果我们想使用不可变性，我们编码时思考的方式需要有一些改变。一个重要的概念是：尽可能地使用val。除了个别情况（特别是在Android中，有很多类我们是不会去直接调用构造函数的），大多数时候是可以的。如果使用var一般都需要判空。