kotlin之基本语法

/**
 * fun 表示 声明一个函数
 * 参数类型写在它名称后面，变量声明同
 * 函数不需要定义在类中
 * 数组就是类，kotlin没有声明数组类型和特殊语法
 *
 */
fun main(args: Array<String>) {
    println("hello,Kotlin")
}

函数

/**
 * max 函数名称
 * (a: Int, b: Int)参数列表
 *  Int：返回类型
 *  return if (a > b) a else b函数体
 *  
 *在kotlin中，if不是作为语句，而是有结果的表达式
 */
fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

//简化

fun max(a: Int, b: Int): Int {
   return if (a > b) a else b
}

//再次简化，省略返回类型（只有表达式体函数返回类型可以省略，对于有返回值的代码块函数体必须显式的写出返回类型和return语句）
fun max(a: Int, b: Int) =if (a > b) a else b

变量

/**
 * val 不可变引用。声明后不能在初始化之后再次赋值。对应java的final变量(不可变的变量)，可看作只读
 * var 声明变量值不可以被改变，对应java普通变量（非final）,也可看作可读可写
 */
val kotlin = "kotlin" //类型隐藏
val kotlinNumber=42
var kotlinNumberto:Int=42//显示声明类型

字符串模板

   val name =if(args.size>0) args[0] else "kotlin"
    //等同"hello"+name+"!"
    println("hello,$name！")
//变种
  println("hello,${if (args.size > 0) args[0] else "kotlin"}!")

类和属性

class Person(val name:String,
             var isMarried:Boolean) {

}
//调用

fun main(args: Array<String>) {
    val persion = Person("小白", false);
    println(persion.name)
    println(persion.isMarried)
//重新赋值
    persion.isMarried = true
}

自定义访问器

class Rectangle(val hegiht: Int, val width: Int) {
    val isSquare: Boolean
//    get(){
//        return hegiht==width
//    }
            //简化
        get() = hegiht == width;
}
//调用
fun main(args: Array<String>) {
    val rect = Rectangle(20, 20)
    println(rect.isSquare)
}

目录和包

和java类似，但是kotlin不区分导入的是类还是函数，能导入任何种类声明，可以直接导入顶层函数名称去使用

package test

import java.util.*

class Rectangle(val hegiht: Int, val width: Int) {
    val isSquare: Boolean
//    get(){
//        return hegiht==width
//    }
            //简化
        get() = hegiht == width
}

fun createRandomRectangle(): Rectangle {
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt())
}
//调用
package main

import test.createRandomRectangle //直接导入了函数

fun main(args: Array<String>) {
 println(createRandomRectangle().isSquare)
}

枚举

//简单枚举
enum class Color {
    RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET
}
//带属性的枚举类
//（....）声明枚举常量属性
enum class Color(val r: Int, val g: Int, val b: Int) {

    //每个常量创建时候给定属性值
    RED(255,0,0),ORANGE(255,165,0),YELLOW(255,255,0),GREEN(0,255,0),
    BLUE(0,0,255),INDIGO(75,0,130),VIOLET(238,130,238);

    //给枚举定义一个方法
    fun rgb()=(r*256+g)*256+b
}
//调用

fun main(args: Array<String>) {
    //调用
    println(Color.BLUE.rgb())
}

when

when好比java中的switch，但远比switch要强大

fun getMnemonic(color: Color) =  //直接返回when表达式
        when (color) {
            Color.RED -> "Red"
            Color.ORANGE -> "orange"
            Color.YELLOW -> "yellow"
            Color.GREEN -> "blue"
            Color.INDIGO -> "indigo"
            else -> {
                "noColor"
            }
        }

//when分支合并多个选项
fun getMnemonic(color: Color) =  
        when (color) {
            Color.RED, Color.ORANGE -> "Red and orange"
            Color.YELLOW, Color.GREEN -> "yellow and blue"
            Color.INDIGO -> "indigo"
            else -> "noColor"
       
        }

/**
 * when分支使用不同对象
 * setof函数能创建出一个set,它会包含所有指定函数实参的对象
 * set这种集合条目 顺序不重要，所以setOf(RED, BLUE)等同于setOf(BLUE,RED)
 */
fun mix(c1: Color, c2: Color) =
    when (setOf(c1, c2)) {
        setOf(RED, BLUE) -> ORANGE
        setOf(YELLOW, BLUE) -> GREEN
        setOf(BLUE, VIOLET) -> INDIGO
        else -> throw Exception("no color")
    }

//不带参数的when（不推荐此写法）
fun mixOptimized(c1: Color, c2: Color) =
    when  {
        (c1==RED&&c2==YELLOW)||(c1==YELLOW&&c2==RED) -> ORANGE
                ...
        else -> throw Exception("no color")
    }

"is"和"as"

is相当于java中的instanceOf,不同的是"is"在kotlin中检查过一个变量是某种类型，后面就不需要转换，可以直接当作检查过的类型使用（前提是变量在is检查后不会在发生变化），这种行为也能称为智能转换
as 是类型转换

val number = 42.0 as Double

While循环

fun whileTest(){
//满足条件进入while循环
    while (...){
        ...
    }
循环体第一次无条件执行，此后满足条件后执行
    do {
        
    }while (...)
}

迭代数字：区间和数列

/**
 * 使用..运算符表示区间，1表示起始值，10表示结束值
 * 区间是包含或者是闭合的，即第二个值是始终是区间的一部分
 */
val oneToTen = 1..10

//数字迭代测试
fun iterationTest(i: Int) = when {
    i % 15 == 0 -> "hello,kotlin"
    i % 3 == 0 -> "hello"
    i % 5 == 0 -> "kotlin"
    else -> "$i"
}
fun main(args: Array<String>) {
//迭代0到100
    for (i in 1..100) {
        println(iterationTest(i))
    }
    /**
     * 0 -100倒着迭代，并只需要偶数
     * (i in 100 downTo 1 step 2)带步长的数列，它允许跳过一些数字
     * 步长也可以是负数（这种情况下表明数列是递减而不是递增）
     * 100 downTo 1 是递减，step把步长绝对值变成2（即步长改变成了-2）
     */
    for (i in 100 downTo 1 step 2){
        println(iterationTest(i))
    }
}
/**
 * ..区间始终包含创建值和结束值（..右边值），而许多情况下我们迭代不包含指定    结束值半闭合区间
 * 使用 for(i in 0 until size)等同于for (i in 0..size-1)和java的for(int i = 0;i<size-1;i++)
 */
 for (i in 0 until 100){
        println(i)
    }

迭代map

val binaryReps = TreeMap<Char, String>()

fun main(args: Array<String>) {
    //使用字符区间迭代A到Z的字符
    for (c in 'A'..'Z') {
        val binary = Integer.toBinaryString(c.toInt()) //转成二进制

        //map[key]可以直接读取值，map[key]=vaule设置值
        binaryReps[c] = binary //根据键c存储对应的二进制值中
    }
    /**
     * for循环允许展开迭代中集合元素
     *  letter是键，binary是值
     */
    for ((letter, binary) in binaryReps) {
        println("$letter=$binary")
    }

}

我们也可以使用for循环展开语法迭代集合跟踪索引，不需要单独创建变量来存储索引

val list= arrayListOf("hello","kotlin","hello,kotlin!")
fun main(args: Array<String>) {
    for ((index,vaule)in list.withIndex()){
      println("$index:$vaule")
    }
}

使用"in"检查集合和区间成员

fun isLatter(c:Char)=c in 'a'..'z'||c in 'A'..'Z'
fun isNumberChar(c:Char)=c in '0'..'9'
//是否不在区间
fun isNumberStr(c:Char)=c !in '0'..'9'

fun main(args: Array<String>) {
      println(isLatter('X'))
      println(isNumberChar('X'))
      println(isNumberStr('X'))
}
//也可以用in检查作为when分支
fun main(args: Array<String>) {

   println(recognize('B'))
}

fun recognize(c: Char) = when (c) {
    in '0'..'9' -> "is NumberChar"
    in 'a'..'z', in 'A'..'Z' -> "is Letter"
    else ->"sorry"
}

区间也不仅局限于字符，假如有一个支持实例比较操作的任意类（实现java.lang.Comparable接口），就能创建这种对象区间，但是并不能列举出这个区间所有对象，只能检查这个对象是否属于这个区间

   println("Kotlin" in "Java".."Scala")
    //试用于集合
   println("Kotlin" in setOf("Java","Scala"))