package com.init.demo.demo1

import java.io.IOException
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths

//Kotlin中控制流作為表示式
fun main(args: Array<String>) {

    /**
     * when不限制分支的組合次數
     * 混合型型別轉換、語句、函式、常量都可以
     */
if_elseAsExpression()
    try_catchAsExpression
 
()
    println(whenAsReturnExpression(1))
    whenExpression(1)
    println(whenFunAsExpression(0))
    println(whenFunAsExpressionisZereo(0))
    println(isPositive(0))
    println(isPositiveSuo(0))
    println(singleNumber(0))
    println(singleNumberSuo(0))
    println(listNumber(0))
    println(listNumberSuo
 
(0))
    println(isKotlinAny(0))
    println(isKotlinAnySuo(0))

    //無引數when，多用於重大的語句判斷
noParamsWhen(3,4)

   /* 
    輸出：
    true
    false
    false
    a=1
    false
    false
    false
    true
    true
    true
    true
    false
    false
    false
    false
    a>b*/
}

/**
 * 無引數when，多用於重大的語句判斷
 
 */
fun noParamsWhen(x:Int,y:Int){
    when{
        x>y -> println("a<b")
        x<y -> println("a>b")
        else -> println("a=b")
    }
}

/**
 * 智慧轉換型別
 * Any型別：對其實際型別無限制，這樣的型別在執行時用來檢測
 */
fun isKotlinAny(any:Any) :Boolean{
    return  when(any){
        is String -> any.startsWith("Kotlin")
        else -> false
}
}
/**
 * 智慧轉換型別 簡化形式
 * Any型別：對其實際型別無限制，這樣的型別在執行時用來檢測
 */
fun isKotlinAnySuo(any:Any) :Boolean=  when(any){
        is String -> any.startsWith("Kotlin")
        else -> false
}

/**
 * 資料函式Math.abs(x)作為判斷條件
 */
fun isPositive(x: Int):Boolean{
    return  when(x){
        Math.abs(x) -> true
        else -> false
}
}
/**
 * 資料函式Math.abs(x)作為判斷條件
 * 簡化形式
 */
fun isPositiveSuo(x: Int) = when(x){
        Math.abs(x) -> true
        else -> false
}

/**
 * in 判斷值 處於某個區間的範圍內作為判斷條件
 */
fun singleNumber(x: Int):Boolean{
    return  when(x){
        in -9..9 -> true
        else -> false
}
}

/**
 *  in 判斷值 處於某個區間的範圍內作為判斷條件
 * 簡化形式
 */
fun singleNumberSuo(x: Int) = when(x){
    in -9..9 -> true
    else -> false
}
/**
 * 集合形式 作為判斷條件
 */
fun listNumber(x: Int):Boolean{
    return  when(x){
        in arrayOf(1,2,3,4,5,6) -> true
        else -> false
}
}

/**
 * 集合形式 作為判斷條件
 * 簡化形式
 */
fun listNumberSuo(x: Int) = when(x){
    in arrayOf(1,2,3,4,5,6) -> true
    else -> false
}



/*
 *Kotlin 中 if-else ,try-catch控制流本身就是表示式
 * 這種變化可以直接把值賦值給變數，從函式返回值
 * 或者直接把控制流作為函式的引數
 */
fun if_elseAsExpression() {

    val a = 5
val b = 3
val isToday = if (a > b) true else false
println(isToday)
}

fun try_catchAsExpression() {

    val readError = try {

        readFile(Paths.get("D:", "/user/bin/ruby.md"))
        true
} catch (e: IOException) {
        false
}
    println(readError)
}

/**
 * when 是Java語句中switch語句的清理升級版
 * 他可以對一個值細緻化的判斷
 * 但要求把所有情況列舉完畢
 */
fun whenExpression(x: Int) {
    checkNUmber(1)
    val isZereo = when (x) {
        Int.MAX_VALUE ->true
Int.MIN_VALUE ->false
        else ->false
}
    println(isZereo)
}

/**
 * when 語句直接賦值給函式
 */
fun whenFunAsExpressionisZereo(x: Int)=  when (x) {
    Int.MAX_VALUE ->true
Int.MIN_VALUE ->false
    else ->false
}

/**
 * when作為表示式直接返回給函式
 * 整個語句被賦予函式本省
 */
fun  whenAsReturnExpression(x:Int) :Boolean{

    return  when(x){
        Int.MAX_VALUE ->true
Int.MIN_VALUE ->false
        else ->false
}
}

/**
 * 函式：when賦值給變數，然後返回給函式
 */
fun whenFunAsExpression(x: Int): Boolean {
    val isZereo = when (x) {
        Int.MAX_VALUE ->true
Int.MIN_VALUE ->false
        else ->false
}

    return  isZereo
}

/**
 * When語句例項
 * when語句的最後一個分支是else 是所有情況的例外處理
 * 這樣就可以吧x的情況進行例舉和處理
 */
fun checkNUmber(x: Int) {
    when (x) {
        0 -> println("a=0")
        1 -> println("a=1")
        else -> println("a!=1 || a!=0")
    }
}

/**
 * kotlin檔案讀取
 */
fun readFile(path: Path): Unit {

    val input = Files.newInputStream(path)
    var byte = input.read()
    while (byte != -1) {
//        println(byte)
byte = input.read()

    }

}