数据类型

数组

fun main() {
    //使用Array
    val arr1 = arrayOf(1, 2, 3)
    val arr2 = arrayOfNulls<Int>(5)
    val arr3 = Array(3) { it + 1 }
    arr1.forEach { println(it) }
    arr2.forEach { println(it) }
    arr3.forEach { println(it) }
    //可以用[]取值，重载的运算符
    println(arr1[0])
    //使用原生的无装箱的数组
    val array1 = intArrayOf(1, 2, 3)
    //五个0
    val array2 = IntArray(5)
    //五个相同的数
    val array3 = IntArray(5) { 11 }
    //1，2，3，4，5
    val array4 = IntArray(5) { it * 1 }
}

控制流程

IF

val a = 3
val b = 4
//作为三目运算符使用
val max1 = if (a>b) a else b
//把最后的表达式作为方法的返回值
val max2 = if(a>b){
    print("a is bigger")
    a
}else{
    print("b is bigger")
    b
}

FOR

//一般的for循环
for (item: Int in ints) {
    //To do
}
//如果想拿到索引下标i
for (i in array.indices) {
    println(array[i])
}
for ((index, value) in array.withIndex()) {
    println("$index : $value")
}

区间与数列

fun main() {
    for (i in 1..4){
        println(i) //1,2,3,4
    }
    for (i in 4 downTo 1){
        println(i) //4,3,2,1
    }
    for (i in 1..8 step 2){
        println(i) //1,3,5,7
    }
    for (i in 8 downTo 1 step 2){
        println(i) //8,6,4,2
    }
    //左闭右开
    for (i in 1 until 10){
        println(i) //[1,10)
    }
    //自动生成的区间
    val range = IntProgression.fromClosedRange(1, 10, 1)
    for (i in range){
        println(i)
    }
}

When 表达式

与传统的switch相似，大大提升的选择的功能

fun main() {
    //只会匹配第一个符合条件的分支，如果没有身符合条件的走else分支
    when(val x  = 10){
        0,1 -> println("x ==0 or x==1")
        10 -> println("$x is 10")
        in 3..10 -> println("$x 在[3,10]之间")
        is Int -> "$x 是 Int类型的数据"
        else -> println("这是switch中的default")
    }
}

fun main() {
    val x = 10
    val y = 3
    //可以把when当作if else的简写版，不给when的参数，
    //-> 左边写一个返回值为Boolean的表达式即可。
    when {
        x !in 0..9 -> println("$x !in [1,9]")
        y == 3 -> println("$x is 10")
        else -> print("x+y is ${x+y}")
    }
}

类与对象

fun main() {
    //因为有初值，其它的参数可以不赋值
    var p1 = Person(name = "tom")
    var p2 = Person("tom", 12, LocalDate.now())
    var p3 = Person()
    var p4 = Person("tom",LocalDate.of(1893,12,26))
    println(p3)
}
/**
 * 在类声明后的constructor()为主构造方法，
 * 类定义时主构造方法参数可以不给初值，但在调用时必须给
 * 如果想生成一个无参构造函数，构造方法中的参数必须有默认值
 * 类里的属性必须初始化，初始化一般在init()里
 */
class Person constructor(
        var name: String = "ziv",
        var age: Int = 0,
        var birth: LocalDate = LocalDate.of(2020, 10, 10)) {
    /**
     *  延迟初始化，可以不用在对象初始化时使用
     *  必须是val类型
     *  在首次调用时才会初始化，初始化后不会改变
     */
    val isAdult: Boolean by lazy {
        age >= 18
    }
    init {
        //可以使用主构造方法里的参数，也可以对其进行初始化
        println("初始化函数启用")
    }
    /**
     *  从构造函数，把其它类型的参数转换成主构造函数知道的类型，最终是用主构造函数执行的。
     *  是一种委托的关系
     */
    constructor(name:String, birth: LocalDate):this(name,LocalDate.now().year-birth.year,birth)
    override fun toString(): String {
        return "Person(name='$name', age=$age, birth=$birth)"
    }
}

可见性修饰符

接口

interface Flyer{
    fun fly()
    fun kind() = "flying animals"
}
interface Animal{
    val name:String
    fun eat()
    fun kind(): String {
      return  "flying animals"
    }
}
class Bird(override val name:String):Flyer,Animal{
    override fun fly() {
        println("I can fly")
    }
    override fun eat() {
        println("I can eat")
    }
    //选择用哪个接口的方法
    override fun kind() = super<Flyer>.kind()
}
fun main() {
    val bird = Bird("bird1")
    println(bird.kind())
}

委托

// 创建接口
interface Base {
    fun printMessage()
    fun printMessageLine()
}
// 实现此接口的被委托的类
class BaseImpl(val x: Int) : Base {
    override fun printMessage() {
        print(x)
    }
    override fun printMessageLine() {
        println(x)
    }
}
/**
 * 通过关键字 by 建立委托类，
 * Derived 的超类型列表中的 by-⼦句表⽰ b 将会在 Derived 中内部存储，
 * 并且编译器将⽣成转发给 b 的所有 Base 的⽅法。
 */
class Derived(b: Base) : Base by b{
    override fun printMessage() {
        print("override printMessage")
    }
}
fun main() {
    //b 是类实例
    val b = BaseImpl(10)
    val derived = Derived(b)
    derived.printMessage() //"override printMessage"
    derived.printMessageLine() //10
}

数据类

即为JavaBean，内置了许多方法

data class User(val name:String,val age:Int)

编译器会自动从主构造函数中拿属性并生成许多如equals()、hashCode()方法

• equals()、hashCode()
• toString()
• copy()

在类中声明的属性

如果不想让编译器对属性生成方法，可以把属性写在类的内部。

//只会生成name的方法
data class Person(val name:String){
    var age: Int = 0
}

Copy()

val jack = User(name = "Jack", age = 10)
val adultJack = jack.copy(age = 18)

数据类的解构声明

就是拿出数据类中存放的数据

fun main(){
    val jack = User(name = "Jack", age = 10)
    val (name,age) = jack
}

Object

与Java中的Static的作用相似，用来表示单例

//单例
object DatabaseConfig {
    val host:String = "localhost"
    val port:Int = 3306
    var username:String = "root"
    var password:String = "root"
}
data class User(val name:String,val age:Int){
    //静态的属性或方法
    companion object{
        val TYPE = "人类"
        fun sayHello(): String {
           return "Hello"
        }
    }
}
fun main(){
    println(User.TYPE)
    println(User.sayHello())
    println(DatabaseConfig.username)
    println(DatabaseConfig.password)
}