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

最新推荐文章于 2022-10-16 23:08:12 发布

zhang英杰

最新推荐文章于 2022-10-16 23:08:12 发布

阅读量1.4k

点赞数

分类专栏： kotlin 文章标签： kotlin kotlin基础

本文链接：https://blog.csdn.net/jie1123161402/article/details/81740215

版权

kotlin 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

整数型和类型推断

/**
     * 数字类型
     * 类型名             含义                 位数
     * 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)
    }
}