第一天

2019-07-20 本文已影响0人 Anwfly

概述：

Kotlin基础
面向过程
面向对象
接口、扩展、泛型

为什么学习Kotlin

1.Google官方指定
2.简介、现代、安全
3.无缝兼容Java

基础（base）

IDE安装
常量、变量、赋值、常量与变量的关系、代码注释

常量
定义：预期范围内恒定不变的量，val 常量名
注意：一旦定义了就确定了类型，不能改变，只有js可以
赋值：给常量一个值交赋值，形式：val 常量名=值

val str1 = "常量";
val π = 3.141592

变量

//1. 定义变量，自动推到类型,不需要自己指明,也可以自己指明，类型一旦确定即定
var str = "变量";
//?表示可为空空，必须指明类型
var str2: String? = "变量";

整数型、浮点型、类型安全、布尔型、元组、可空类型

整数型Int
定义：var 变量名:Int = 2
注意：由于Kotlin有类型推断，类型可以忽略不写
浮点型Double(64)/Float(32)
注意：默认的浮点型的Double
类型安全：类型一旦定义，类型不可更改
布尔值：Boolean
两个值：false和true
元组（Tuple），给多个变量同时赋值，分二元（Pair）和三元（Triple）

    //二元
    val(name,age) = Pair("大飞", 12)
    
    //三元
    val (name, age, sex) = Triple("大飞", 12, "男")
    println("${name}")
    
    //只用一个变量名称
    val fly = Pair("大飞", 12)
    println("${fly.first}")

可空类型
代表一个变量可能没有值
如：用户资料的选填部分，如住址可空
定义：var 变量名 : 类型? = "大飞"

操作符和类型（Operator & Type）

操作符：一个符号或者一个单词，用于运算或者操作。同时操作的对象的数目，被称作几元操作符。

一元操作符：操作一个目标，= - +

var a = 1
var b = -a

二元操作符：操作两个目标，在两个目标之间

var c = a + b

赋值操作符：用等号右边的值来更新左边变量的值

var d = a

数学操作符：+ - * / % ，使用和Java中一样
赋值操作符与书序操作符的组合，比如+=

var add += 1000

比较操作符：> >= < <=，结果返回false或者true
逻辑操作符：布尔值的组合，与/或/非，&& || !，跟Java使用一样

String（处理文字和字符）：字符串（string）和字符（char）

字符串：""表示，使用+拼接

var title : String = "小白"
//判空
println(title.isEmpty())
//计数
println(title.count())
//使用字符串的toCharArray()方法，把字符串转换为字符数组
val toCharArray = title.toCharArray()
for (word in toCharArray) {
    println(word)
}
//字符串获或者字符使用+拼接
//字符串模板：可以把各种变量组合成一个动态的字符串
val endTime = Triple(6,2,4)
    val company1 = "顺丰"
    val company2 = "菜鸟"
    val company3 = "邮局"
    val newTile = "${endTime.first}月${endTime.second}日，${company1}大战${company2}正酣，${endTime.third}${company3}日紧急叫停"
    print(newTile)

字符：使用''表示，只能包含一个

 var title : Char ='a'
    //是否是数字
    println(title.isDigit())
    //是否是字母或者汉字
    println(title.isLetter())

Collection（一次处理多个类型的元素）：数组、map、集合

定义：同类型值的组合
分类：
①有序可重复：Array，索引从0开始

    //创建大小固定数组：arrayOf("", "")
    //特点：大小固定，元素类型不可变
    var nollStations = arrayOf("北京站", "北京南站")

    //创建一个有默认值的数组：Array<String>(计数, { 默认值 })
    var nollStations1 = Array<String>(2, { "吃饭" })

    for (nollStation in nollStations1) {
        println(nollStation)
    }

    //创建0-10的数组，
    var oneToTen = Array(10, { i -> i })

    for (i in oneToTen) {
        print("$i ")
    }

    //元素计数，判空
    print(oneToTen.size)
    print(oneToTen.isEmpty())

    //获取数组中的元素
    print(oneToTen[0])
    print(oneToTen.first())
    println(oneToTen.last())
    print("${oneToTen.component1()},${oneToTen.component5()}")

    //获取筛选重复元素后的数组：.distinct()或者用
    var citys = arrayOf("北京", "天津", "北京", "上海")
    val distinct = citys.distinct()
    val toSet = citys.toSet()
    for (s in distinct) {
        println(s)
    }
    for (s in toSet) {
        println(s)
    }

    //切割数组:sliceArray,全是闭区间
    //特点：大小可变，类型不可变
    val sliceArray = citys.sliceArray(0..2)
    println(sliceArray.size)

    //mutableListOf
    var countries = mutableListOf("中国", "美国", "英国")
    //在末尾添加元素
    countries.add("日本")
    //在任意位置添加元素
    countries.add(1, "韩国")
    //移除元素
    countries.remove("美国")
    //移除指定位置元素
    countries.removeAt(2)

②无序不可重复：集合类型Set：Set<类型>或者setOf(元素1，元素2)
特点：大小固定，类型不可变
方法：交差并补

    //集合
    val oneLine = setOf("天通苑", "北京站", "立水桥")
    val twoLine = setOf("朱辛庄", "沙河", "高教园")
    val threeLine = setOf("朱辛庄", "沙河", "高教园", "天通苑", "北京站", "立水桥", "昌平站")

    //集合计数及判空
    println("oneLine是否为空：" + oneLine.isEmpty() + "数量为：" + oneLine.size)

    //是否包含一个元素或一个集合
    println(threeLine.contains("北京站"))
    println(threeLine.containsAll(oneLine))

    //转化为数组
    val toTypedArray = oneLine.toTypedArray()
    for (s in toTypedArray) {
        println(s)
    }

    //集合之间的运算：交差互补
    //交集:intersect
    val intersect = oneLine.intersect(threeLine)
    for (s in intersect) {
        print("$s ")
    }

    //差集：subtract，结果是
    val subtract = oneLine.subtract(twoLine)
    for (s in subtract) {
        println(s)
    }

    //并集：union
    val unionLines = oneLine.union(twoLine)
    for (unionLine in unionLines) {
        print("${unionLine} ")
    }
     //补集：
    val minus = oneLine.minus(twoLine)
    for (m in minus) {
        println(m)
    }

     //转变为可变集合：
    val mutableSet = oneLine.toMutableSet()
    mutableSet.add("八达岭站")
    mutableSet.addAll(twoLine)
    mutableSet.remove("北京站")

    for (s in mutableSet) {
        println(s)
    }

③无序可重复：Map，但值有唯一的键
主要属性：keys（一个set，不可重复），values（可重复的）

    //Map
    //mapOf<Key,Values>{Pair(key,value)...}
    //注意：显示指定类型，防止初始化值类型错误
    val countries = mapOf<String, String>(Pair("cn", "中国"), Pair("hk", "香港"), Pair("ac", "美国"))

    //元素计数，判空
    println(countries.size)
    println(countries.isEmpty())

    //获取某个key对应的value值
    println(countries.get("cn"))
    println(countries.getOrDefault("cn", "不存在此国家代码"))

    //获取所有的keys，获取所有的values
    println(countries.keys)
    println(countries.values)

    //转化为可变，默认是不可变的
    val newCountries = countries.toMutableMap()

    //更新
    newCountries["cn"] = "中国北京"
    println(newCountries.get("cn"))
    //添加
    newCountries["bj"] = "北京"
    println(newCountries.values)
    //移除
    newCountries.remove("hk")
    println(newCountries.values)

控制流:根据逻辑条件控制程序运行流向

循环：for while

val lists = listOf(1, 2, 3)
    for (list in lists) {
        println(list)
    }
    for (a in 1..39) println(a)

var times = 2
    while (times >= 0) {
        println(times)
        times--
    }

 //整个if语句可以作为一个返回值
    if (true) {
    }
    if (true) {
    } else {
    }

when：可对某个变量的大小、值的表达式、类型等进行判断

when (3) {
        in 1..5 -> {
            println("在1到5之间")
        }

        1, 3, 5 -> {
            println("1,3,5")
        }
        (9 - 6) -> {
            println("值是3")
        }

        is Int -> {
            println("是整型")
        }

        else -> {
            println("什么都不是")
        }

函数和Lambda

1.函数
2.Lambda
3.行内函数
4.高阶函数

第一天

概述：

为什么学习Kotlin

基础（base）

操作符和类型（Operator & Type）

函数和Lambda

猜你喜欢

热点阅读