android开发之&android中的swift，kotlin基础语法（二）

整数型和类型推断

/**     
* 数字类型     
* 类型名             含义                 位数     
* Long             长整型                 64     
* Int              整数                   32     
* Short            短整数                 16     
* Byte             字节                   8     
* Double           双精度小数              64     
* Float            浮点数（小数）          32     
*/    var name: Int =3            
//由于kotlin有类型推断系统，所以Int可以不用写    var longNumber = 1266666L    var doubleNumber = 22.64    var floatNumber = 12.3F    var byteNumber = 0xACF     //kotlin不支持自动扩展数字范围，转换必须手动进行    //toByte()  toShort()   toInt()     toLong()    toFloat()   toDouble()  toChar()     var int1 = 9999    var long = int1.toLong()     var float1 = 78.7674F    var double = float1.toDouble()     //位运算：左移运算、右移运算、无符号右移运算、逻辑与运算、逻辑或运算、异或运算和取反运算。和java不同的是，这些不是内建运算符    //而是用中缀函数来代替的    var number1 = 1 shl 2           //左移二    var number2 = 1 shr 2           //右移二    var number3 = 1 ushr 2          //无符号右移二    var number4 = 1 and 0x00001111  //逻辑与1111    var number5 = 1 or 0x00001111   //逻辑或1111    var number6 = 1 xor 0x00001111  //异或1111    var number7 = 1.inv()           //取反

浮点数（小数）

Kotlin中小数默认是Double类型,可以使用toInt()方法把小数截断成整数，不是四舍五入，而是完全砍掉。如：3.14.toInt()结果是3

fun main(args: Array<String>) {    
    var pi = 3.141592653589793238    
    println(pi) 
}

布尔类型：Boolean

fun main(args: Array<String>) {    
    var vip = false    
    vip = true    
    var price = false   
    price =true     
    if (vip){        
        println("欢迎vip会员")    
    }else{        
        println("请充值")    
    }
}

元组：可以把多个值同时赋值给一个变量，或者给多个变量同时赋值

Kotlin中元组只有二元和三元，也就是最多一次容纳3个值

fun main(args: Array<String>) {    
    var course = Triple(3,"学会","Kotlin")    
    var price = Pair("学费",0)    
    println("${course.first}天${course.second}${course.third}}")    
    println(",${price.first}${price.second}元！") 
}

可空类型：所有"实体的"类型与空的组合

写法：Int?  String?    Boolean?     ？指空值null

fun main(args: Array<String>) {    
    var addr:String? = "北京朝阳望京soho"    
    var sex:Boolean?     
    sex = false     
    if (sex != null && sex == true){        
        println("先生，您好")    
    }else{        
        println("美女，您好！")    
    }
}

基础操作符：有一元、二元、三元操作符。三元操作符只有一个、基本不用

fun main(args: Array<String>) {    
    /**     
    * 一元操作符     
    * 对于一个变量值取负数，只需要在前面跟一个"-"号     
    */    
    var a = 3    
    a = -100    
    var b = + a    
    var c = - a    
    println("${b},${c}")     
    /**     
    * 二元操作符         
    */    
    var d = a + c    
    println(d)      
    /**     
    * 比较操作符：有4种，>  >=  <   <=     
    */    
    println(2 > 3)    
    println(3 >= 3)    
    println(2 < 3)    
    println(2 <= 3)
}

异常处理和类初始化

Kotlin中异常处理和java几乎一模一样，kotlin中所有的异常都是非必检的

必检异常：必须定义成方法的一部分或者在方法内部处理

非必检异常：没什么必要加入到方法中的异常

fun main(args: Array<String>) {    
    //类初始化：不需要new    
    var file1 = File("/usr/bin/ruby")    
    var data = Date(20170702)} 
    //异常处理fun 
    readFile(path :Path):Unit{    
        val input = Files.newInputStream(path)    
        try {        
            var byte = input.read()        
            while (byte != -1){            
                println(byte)            
                byte = input.read()        
            }   
        }catch (e : IOException){ 
           println("读取文件错误，因为：${e.message}")    
        }finally {        
            input.close()    
        }
}

引用相等和结构相等

引用相等：是指两个无关联的对象指向了内存中的同一个实例

结构相等：两个对象分别位于内存中的不同区域但是他们的值是相同的

fun main(args: Array<String>) {    
    //引用相等，使用=== 或 !==操作符    
    var file1 = File("/usr/bin/ruby")    
    var file2 = File("/usr/bin/ruby")    
    var sameRefer = (file1 === file2)    
    println(sameRefer)      
    //打印false     
    //结构相等，使用== 和 != 操作符    
    val sameStruct = (file1 == file2)    
    println(sameStruct)   //打印true
}

区间：区间是有一个起始值和终止值的间隔。

任意可以比较大小的类型都可以创建一个区间，使用".."操作符

fun main(args: Array<String>) {    
    val v = "a".."z"    
    val y = 1..100    
    //一旦区间创建好，就可以用in操作符来测试指定的一个值是否包含在其中     
    var d = "d" in v    
    var c = 38 in y     
    //downTo()函数可以创建一个倒序排列的区间    
    val f = 10.downTo(0)     
    //一旦区间创建，可以更改区间生成一个新区间。更改区间中的每一个单项前进的幅度，即步进(step)，使用step函数    
    val z = y.step(2) //1到100间的奇数     
    for (i in z){       
        println(i)        
        if (i == 99)break        
            println(",")    
    }    
    //不能用负数创建一个递减的区间，区间可以用reversed()函数进行翻转，这个函数返回一个从终止值到起始值、步进反向的区间    
    var a = (1..100).step(2).reversed()    
    for (i in a){        
        print(i)        
        if (i == 1) break        
        print(",")    
    }
}

控制流作为表达式

fun main(args: Array<String>) {    
    val a = 5    
    var b = 3    
    val isToday = if (a > b) true else false    
    println(isToday)     
    //同样的技巧也可以用在try-catch中    
    val readSuccess = try {        
        return    
    }catch (e : IOException){        
        false    
    }     
    //when表达式    
    isMinOrMax(5)    
    isZeroOrOne(2)    
    isPositive(3)}

when表达式:是java中switch的升级版，不仅可以对值进行判断，还可以对函数判断和区间判断

fun isMinOrMax(x : Int) :Boolean{    
    val isZero = when (x) {        
        Int.MIN_VALUE -> true        
        Int.MAX_VALUE -> true        
        else -> false    
    }    
    return isZero
}
fun isZeroOrOne(x:Int) = when (x) {    
    0,1 -> true    
    else -> false
}
fun isPositive(x: Int)= when (x){        
    Math.abs(x) -> true        
    else -> false
}
fun aa(x: Int)= when (x){        
    in -9..9 -> true        
    else -> false
}
fun bb(x: Int)=when (x){    
    in arrayOf(1,2,3,4,5,6) -> true    
    else -> false
}
//when中还可以用只能类型转换，只能类型转换可以让编译器在运行时校验变量类型
fun cc(any :Any):Boolean{    
    return when(any){        
        is String -> any.startsWith("Kotlin")        
        else -> false    
    }
} 
//无参数when语句：类似于多分支的if(){}else{}语句
fun dd(a:Int,b:Int){    
    when{        
        a < b -> println("a小于b")        
        a > b -> println("a大于b")        
        else -> println("a等于b")    
    }
}

函数返回：使用return关键字

fun main(args: Array<String>) { }
fun addTwoDouble(a:Double,b:Double):Double{    
    return a + b
}
fun maxNumber(a:Int,b:Int,c:Int):Int{    
    fun maxNumber(a: Int,b: Int):Int{        
        if (a > b)            
            return a        
        else            
            return b    
    }    
    return maxNumber(maxNumber(a,b),maxNumber(b,c))
} 
fun number(){    
    val list = listOf(-1,0,2,5,99)    
    list.forEach(fun (x){        
        if (x < 9) 
            println(x)        
        else 
            return    
    })    
    println("此行继续会执行！")
}

kotlin超类：any

ktolin中最上层类型是Any,任意类型，相当于java中的object

Unit类型等价于java中的void

kotlin增加了一个最底层类型--Nothing,这个类型没有实例

any类型是所有类型的父类，Nothing类型是所有类型的子类

fun main(args: Array<String>) { }

循环：kotlin中有两种循环：while和for循环

fun main(args: Array<String>) {    
    while (true){        
        println("这个事无限循环")    
    }    
    //kotlin中for循环用于迭代任何一个预定义或者扩展了一个名为iterator的函数，所有集合类型都提供了这个函数    
    val list1 = listOf(1,2,3,4)    
    for (k in list1){        
        println(k)    
    }     
    var set1 = setOf(1,2,3,4)    
    for (k in set1){        
        println(k)    
    }     
    var array1 = arrayOf(1,2,3,4)    
    for (k in array1){        
        println(k)    
    }     
    var aa = 1..10    
    for (k in aa){        
        for (j in 1..8){            
            println(k * j)        
        }    
    }     
    val slogan = "123456"    
    for (char in slogan){        
        println(char)    
    }    
    //数组有一个索引集合的扩展函数indices，可以用来迭代一个数组的索引    
    val fiveNumbers = arrayOf(1,2,3,4,5)    
    for (index in fiveNumbers.indices){        
        println(index)   
    }
}