概述：
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语句可以作为一个返回值
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.高阶函数
网友评论