1.变量的声明和使用
var 声明变量
val 声明常量
kotlin的数据类型：Byte Short Int Long Float Double String
java的数据类型：byte short int long float double boolean char
kotlin会通过类型推断数据类型
可以用冒号(:)来显示指定数据类型
例：var name="张三" //存放字符串类型的数据
var j:Short =1;
var s:String="123456"
val n="abc"//只读数据类型
2.函数
函数格式：fun 函数名(参数名:参数类型):返回值类型{
函数体
}
字符串模板：字符串模板是在字符串中添加若干个占位符，内容会在后期指定
格式: $值，${表达式}
例：var temp="kotlin${content}"
3.条件控制
3.1 if语句
if(表达式){
}else{
}
3.2 when语句
Java中的switch中，是通过 case 值: 类型来对相应情况进行处理，而Kotlin是使用 -> 一个类似箭头方式；
默认情况，Java中是使用default指定除了所有定义的case情况以外的情况，而Kotlin是使用else；
例：fun studentLevel(score:Int):String{
var level=when(score){
5 ->"A"
4 ->"B"
3 ->"C"
else ->"D"
}
return level
}
4.字符串比较
4.1 ==
比较两个字符串，如果两个字符串的内容一致，在Java中使用 str1 == str2 时，是比较两个字符串的地址值，但是在kotlin中，则不是如此，比较的只是字符串的内容。
4.2 equals(str:String)
方法中的参数是与之对比的字符串，默认不忽略大小写，即大小写敏感
4.3 equals(str:String,ignoreCase:Boolean)
方法中有两个参数，第一个参数是与之对比的字符串，第二个参数是布尔类型的值，是否忽略大小写，ture为忽略字母大小写
5. 空值处理
fun hello(str:String):String{//接收一个参数，参数的非空的string类型，加上问好(?)代表的是参数可以是空
return "你好，" + str
}
6.Loop和Range
6.1 开区间和闭区间
开区间用(a,b)来表示，不包含两个端点
闭区间用[a,b]来表示，包含两个端点
使用 1 .. 100 定义了 [1，100] 的区间，包含1和100
使用 1 until 100 定义了 [1,100) 的区间，其中包括了1-99的数，不包含100
step指定每一次遍历是以多少个为单位
例：
var num1=1..20//[1.20]
var num2=1 until 20//[1.20)
for(num in num1){
Log.e("Main",num.toString());
}
for(num in num1 step 5){
Log.e("Main",num.toString());
}
7. List和Map
kotlin中的集合和其他语言不通，kotlin集合分为可变和不可变集合
kotlin集合包含三种类型，List、Set、Map
它们都是接口，并不是实际的类。
它们都继承至Collection接口,而Collection又继承与Iterable接口。它们几乎上只实现了isEmpty()、size属性、get()、contains()等方法。这一点和Java类似。
这三种集合类型分别有存在MutableList、MutableSet、MutableMap接口，这些接口中提供了改变、操作集合的方法。例如add()、clear()、remove()等函数。
7.1 List类型
例1：使用listOf()初始化不可变的List类型集合
val arr = arrayOf("1","2",3,4,5)
val list1 = listOf(1,2,"3",4,"5") // 随意创建
val list2 = listOf("1","2","3","4","5") // 确定元素的值类型
val list3 = listOf(arr) // 可传入一个数组以下代码是错误的。
因为List只能是不可变集合。而add、remove、clear等函数时MutableList中的函数
list1.add()
list1.remove
...// 遍历
for(value in list1){
print("$value \t")
}
结果：1 2 3 4 5
例2：使用mutableListOf()初始化不可变的List类型集合
val arr = arrayOf("1",2,3,4)
val mutableList1 = mutableListOf(1,2,"3",4,"5") // 随意创建
val mutableList2 = mutableListOf("1","2","3","4","5") // 确定元素的值类型
val mutableList3 = mutableListOf(arr) // 可传入一个数组
val mutableList : ArrayList // 这里的ArrayList<>和Java里面的ArrayList一致
mutableList1.add("6") // 添加元素
mutableList1.add("7")
mutableList1.remove(1) // 删除某一元素
// 遍历
for(value in mutableList1){
print("$value \t")
}
mutableList1.clear() // 清空集合
结果：2 3 4 5 6 7
7.2 Set类型
Set类型集合会把重复的元素去除掉。这一点和Java是不谋而合的。这个特性也是Set类型集合与List集合类型的区别所在。
7.3 Map类型
Map类型集合和List以及Set都有着差别。
不可变的Map类型集合的初始化使用：mapOf()函数
可变的Map类型集合的初始化使用：mutableMapOf()函数
注意：当我们的键存在重复时，集合会过滤掉之前重复的元素。
例1：
// 以键值对的形式出现，键与值之间使用to
val map1 = mapOf("key1" to 2 , "key2" to 3)
val map2 = mapOf(1 to "value1" , 2 to "value2")
val mutableMap = mutableMapOf("key1" to 2 , "key1" to 3)
val hashMap = hashMapOf("key1" to 2 , "key1" to 3) // 同Java中的HashMap
map2.forEach{
key,value -> println("$key \t $value")
}
结果：key1 value1
key2 value2
8. 异常处理
try{
}catch (e:Exception){
}
9. 面向对象
例：定义一个学生类
class Person{
var name:String
var age:Int=0 //Int类型必须初始化
constructor(name:String,age:Int){//构造方法
this.name=name
this.age=age
}
}
9.1 三大特征
9.1.1 封装
就是把客观事物封装成抽象类，并且类可以把自己的数据和方法让可信的类或对象操作
优点：1)良好的封装能够减少耦合
2)类内部结构可以自由修改
3)可以对变量成员进行更精细的控制
4)隐藏信息，实现细节
9.2 继承
9.2.1 让某个类的对象获得另一个类型对象的属性的方法
在kotlin中，所有的类在默认情况下都无法被继承，就是说所有类在默认情况下都是final，如果想被继承，需要使用关键字open，只有被open修饰的类才可以被继承
例：open class Person(name:String,age:Int){
}
9.2.2 类的方法重新
在kotlin中，类中的方法也是final类型，是不能被重写的，也需在方法前面加上open关键字后才可以；子类要重写父类中open修饰的方法，需在子类的方法前面加override关键字
例：open class Color{
open fun name(){
println("red")
}
fun type(){
println("7 ColorS")
}
}
class Blue:Color() {
override funname(){
println("blue")
}
}
9.3 多态
指一个类实例的相同方法在不同情形有不通表现形式
优点：
1)可消除类型间的耦合关系
2)可替换性
3)可扩充性
4)接口性
5)灵活性
6)简化性
多态存在的三个必要条件：
1)继承
2)重新
3)父类引用指向子类对象
10. 抽象类和接口
10.1 抽象类
abstract class 抽象类名[(主构造函数)][: 继承父类和实现接口] {……}
注：即使不用 open 关键字修饰，抽象类也是可以被继承的，想想也很容易明白，因为抽象类本来就是用来继承的，所以就可以省略open关键字。
例：abstract class Man{...... }
10.2 接口
interface 接口类名[: 继承的接口] {……}
例：interface Person
class Student: Person,Man(){
