与java不同点

• 不需要;

• 不能使用int a = 1这样的定义变量，改为类似ts的风格val a: Int = 1

  • val：定义常量和const类似
  • var：可以被赋值

• 没有了new

基本类型

在Kotlin中，所有东西都是对象

数字

整型

• Int
• Byte
• Short
• Long

浮点型

• Float
• Double

位运算：1 shl 1：结果为2

• shl(bits) – 有符号左移
• shr(bits) – 有符号右移
• ushr(bits) – 无符号右移
• and(bits) – 位与
• or(bits) – 位或
• xor(bits) – 位异或
• inv() – 位非

布尔

• Boolean：基本操作和java一样

字符

没啥变的，多了js的模板字面量

val letters = listOf("a","b","c","d","e")
println("Letters: $letters")

数组

没了new，通过使用方法，或Array的构造方法

访问是一样的

// 创建一个包含3个整数的数组，所有元素都初始化为0
val numbers = Array(3) { 0 }
// 创建一个包含3个整数的数组
val numbers = arrayOf(1, 2, 3)
// 创建一个包含3个整数的数组
val intArray = intArrayOf(1, 2, 3)
// 创建一个包含3个字符的数组
val charArray = charArrayOf('a', 'b', 'c')
// 创建一个包含3个布尔值的数组
val booleanArray = booleanArrayOf(true, false, true)

类型检测

• is：obj is String
• !is：obj !is String

控制流程

switch变成了when，还更强大，自带break，当if-else的替代也行

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    0, 1 -> print("x == 0 or x == 1") // 多条件满足
    in 1..10 -> print("x is in the range")// 表达式也行
    else -> { // 类似java的default
        print("x is neither 1 nor 2")
    }
}
var x = 0
when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

for

区间..类似py中的range

for (i in 1..3) {
        println(i)
}
for (i in 6 downTo 0 step 2) {
        println(i)
}
// 上面的两种都行
// 还有py的pairwise一样的效果
for ((index, value) in array.withIndex()) {
        println("the element at $index is $value")
}

程序入口

任意一个文件中的main函数

函数

fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}
fun sum(a: Int, b: Int) = a + b // 简写
public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型
fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}
// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}
// 函数的变长参数可以用 vararg 关键字进行标识：
fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}
// lambda(匿名函数)
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 输出 3
}

变量

可变变量定义 var <标识符> : <类型> = <初始化值>
不可变变量定义 val <标识符> : <类型> = <初始化值> 类似java的final

NULL检查机制

就像ts的?一样，可以测试是否为空

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

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

类

class Person {
// 每个变量后面都有get,set函数，val没有set
    // 每个紧跟着的就是对应的set，get，其中还有自带的field表示对应的变量
    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

    var heiht: Float = 145.4f
        private set
}

如果构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。

class Person constructor(firstName: String) {
    init { // 创建对象的时候，每一个init块都会执行
        println("FirstName is $firstName")
    }
}

类的修饰符

• classModifier: 类属性修饰符，标示类本身特性。

  abstract    // 抽象类  
  final       // 类不可继承，默认属性
  enum        // 枚举类
  open        // 类可继承，类默认是final的
  annotation  // 注解类

• accessModifier: 访问权限修饰符

  private    // 仅在同一个文件中可见
  protected  // 同一个文件中或子类可见
  public     // 所有调用的地方都可见
  internal   // 同一个模块中可见

扩展函数

扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式：

fun receiverType.functionName(params){
    body
}

• receiverType：表示函数的接收者，也就是函数扩展的对象
• functionName：扩展函数的名称
• params：扩展函数的参数，可以为NULL