/**
 * fun 表示 聲明一個函數(shù)
 * 參數(shù)類型寫在它名稱后面，變量聲明同
 * 函數(shù)不需要定義在類中
 * 數(shù)組就是類，kotlin沒有聲明數(shù)組類型和特殊語法
 *
 */
fun main(args: Array<String>) {
    println("hello,Kotlin")
}

函數(shù)

/**
 * max 函數(shù)名稱
 * (a: Int, b: Int)參數(shù)列表
 *  Int：返回類型
 *  return if (a > b) a else b函數(shù)體
 *  
 *在kotlin中，if不是作為語句，而是有結(jié)果的表達(dá)式
 */
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
}

//再次簡化，省略返回類型（只有表達(dá)式體函數(shù)返回類型可以省略，對于有返回值的代碼塊函數(shù)體必須顯式的寫出返回類型和return語句）
fun max(a: Int, b: Int) =if (a > b) a else b

變量

/**
 * val 不可變引用。聲明后不能在初始化之后再次賦值。對應(yīng)java的final變量(不可變的變量)，可看作只讀
 * var 聲明變量值不可以被改變，對應(yīng)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) {

}
//調(diào)用

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;
}
//調(diào)用
fun main(args: Array<String>) {
    val rect = Rectangle(20, 20)
    println(rect.isSquare)
}

目錄和包

和java類似，但是kotlin不區(qū)分導(dǎo)入的是類還是函數(shù)，能導(dǎo)入任何種類聲明，可以直接導(dǎo)入頂層函數(shù)名稱去使用

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())
}
//調(diào)用
package main

import test.createRandomRectangle //直接導(dǎo)入了函數(shù)

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) {

    //每個常量創(chuàng)建時候給定屬性值
    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
}
//調(diào)用

fun main(args: Array<String>) {
    //調(diào)用
    println(Color.BLUE.rgb())
}

when

when好比java中的switch，但遠(yuǎn)比switch要強(qiáng)大

fun getMnemonic(color: Color) =  //直接返回when表達(dá)式
        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函數(shù)能創(chuàng)建出一個set,它會包含所有指定函數(shù)實參的對象
 * 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")
    }

//不帶參數(shù)的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相當(dāng)于java中的instanceOf,不同的是"is"在kotlin中檢查過一個變量是某種類型，后面就不需要轉(zhuǎn)換，可以直接當(dāng)作檢查過的類型使用（前提是變量在is檢查后不會在發(fā)生變化），這種行為也能稱為智能轉(zhuǎn)換
as 是類型轉(zhuǎn)換

val number = 42.0 as Double

While循環(huán)

fun whileTest(){
//滿足條件進(jìn)入while循環(huán)
    while (...){
        ...
    }
循環(huán)體第一次無條件執(zhí)行，此后滿足條件后執(zhí)行
    do {
        
    }while (...)
}

迭代數(shù)字：區(qū)間和數(shù)列

/**
 * 使用..運(yùn)算符表示區(qū)間，1表示起始值，10表示結(jié)束值
 * 區(qū)間是包含或者是閉合的，即第二個值是始終是區(qū)間的一部分
 */
val oneToTen = 1..10

//數(shù)字迭代測試
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倒著迭代，并只需要偶數(shù)
     * (i in 100 downTo 1 step 2)帶步長的數(shù)列，它允許跳過一些數(shù)字
     * 步長也可以是負(fù)數(shù)（這種情況下表明數(shù)列是遞減而不是遞增）
     * 100 downTo 1 是遞減，step把步長絕對值變成2（即步長改變成了-2）
     */
    for (i in 100 downTo 1 step 2){
        println(iterationTest(i))
    }
}
/**
 * ..區(qū)間始終包含創(chuàng)建值和結(jié)束值（..右邊值），而許多情況下我們迭代不包含指定    結(jié)束值半閉合區(qū)間
 * 使用 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>) {
    //使用字符區(qū)間迭代A到Z的字符
    for (c in 'A'..'Z') {
        val binary = Integer.toBinaryString(c.toInt()) //轉(zhuǎn)成二進(jìn)制

        //map[key]可以直接讀取值，map[key]=vaule設(shè)置值
        binaryReps[c] = binary //根據(jù)鍵c存儲對應(yīng)的二進(jìn)制值中
    }
    /**
     * for循環(huán)允許展開迭代中集合元素
     *  letter是鍵，binary是值
     */
    for ((letter, binary) in binaryReps) {
        println("$letter=$binary")
    }

}

我們也可以使用for循環(huán)展開語法迭代集合跟蹤索引，不需要單獨創(chuàng)建變量來存儲索引

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

使用"in"檢查集合和區(qū)間成員

fun isLatter(c:Char)=c in 'a'..'z'||c in 'A'..'Z'
fun isNumberChar(c:Char)=c in '0'..'9'
//是否不在區(qū)間
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"
}

區(qū)間也不僅局限于字符，假如有一個支持實例比較操作的任意類（實現(xiàn)java.lang.Comparable接口），就能創(chuàng)建這種對象區(qū)間，但是并不能列舉出這個區(qū)間所有對象，只能檢查這個對象是否屬于這個區(qū)間

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