kotlin从入门到放弃，让你领会kotlin的人性化与比java更强大之处

kotlin从入门到放弃

1. kotlin的主函数
2. 常用的关键字说明
3. kotlin的基本数据类型与基础语法
4. kotlin的条件控制与循环控制
5. kotlin的类、对象、接口与继承
6. kotlin的扩展与高阶函数的定义和使用
7. kotlin的委托
8. kotlin的协程

kotlin的主函数

类似于java的main方法一下，配置好IDE，输入main就会有提示补全

fun main(){
	println("hello word")
}

常用的关键字说明

val 不可变的修饰，类似于java的final
var 可变的修饰，可以代表任何类型

kotlin的基本数据类型与基础语法

基本数据类型

java的八大基本数据类型 VS kotlin基本数据类型（ Byte、Short、Int、Long、Float、Double等）不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。

java	kotlin
byte	Byte
char	$12
boolean	Boolean
int	Int
short	Short
float	Float
double	Double
long	Long

我个人理解kotlin中的基本数据类型都是java的包装数据类（也就是对象类型）通过编译转换成java字节码的时候会变成java的基本数据类型（类似于拆箱一样）

基础语法

//创建类
class Runoob {}
//创建方法
fun test() {}
//定义常亮
val b = 1  //类型自动推断
var x = 5  // 系统自动推断变量类型为Int
//如果不初始化，则必须声明类型
val c: Int 

kotlin的方法默认是public，方法定义在类外面类似于static方法一样，可以直接调用

（kotlin类似于描述性语言一下，无论是普通方法还是lamda函数都是一样的，先写输入，再写输出）
(Unit类似于java中的void关键字一样，不同的是Unit是一个类，通常方法返回Unit的时候可以省略)

fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}
fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b
fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}

lamda函数说明

(Int, Int) -> Int 描述lamda函数的输入是两个整型，->之后是描述lamda函数的输出是整型

{x,y -> x+y} x,y是输入进来的两个参数的局部变量名称，->之后是需要执行的函数体与返回值

//lamda函数
val sumLambda: (Int, Int) -> Int = {x,y -> x+y}

null检查机制

//类型后面加?表示可为空
var age: String? = “23”
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

kotlin的条件控制与循环控制

条件控制

普通用法与java类似，此处不再说明，只看表达式方式的if

val max = if (a > b) a else b

使用区间

// 使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y
if (x in 1..8) {
   println("x 在区间内")
}

When 表达式类似于java中的switch，但比switch的功能更强

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    3, 4 -> print("x == 3 or x == 4")
    in 5..10 -> print("5-10之间")
    !in 10..20 -> print("不在10-20之间")
    else -> { // 注意这个块
        print("x 是其他")
    }
}

循环控制

正常循环：

for (i in 1…4) print(i) // 打印结果为: “1234”

如果你需要按反序遍历整数可以使用标准库中的 downTo() 函数:

for (i in 4 downTo 1) print(i) // 打印结果为: "4321"也支持指定步长：
for (i in 1…4 step 2) print(i) // 打印结果为: “13”
for (i in 4 downTo 1 step 2) print(i) // 打印结果为: “42”

如果循环中不要最后一个范围区间的值可以使用 until 函数:

for (i in 1 until 10) { // i in [1, 10), 不包含 10
println(i)
}

遍历集合，此处需要indices，不然i就为集合中的item

for (i in array.indices) {
print(array[i])
}

增强for循环遍历

fun foo() {
ints.forEach {
if (it == 0) return//it代表ints中的每一个item
print(it)
}
}

while循环与do while循环与java一样
关键字break 和 continue和return与java一样

kotlin的类、对象、接口与继承

类、对象、接口

类的定义，类中属性的定义

class Runoob {  // 类名为 Runoob
   // 大括号内是类体构成
}
class Empty //空类

//属性定义
class Runoob {
   var name: String = ……
   var url: String = ……
   var city: String = ……
}

class Person constructor(firstName: String) {}

class Person(firstName: String) {
}

特殊说明：init代码块执行时机在主构造函数之后，在其他构造函数之前
举例

class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String = "http://www.runoob.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

关键字说明：
open：为可继承，可重写的作用，注意：无需对抽象类或抽象成员标注open注解。
inner：内部类使用 inner 关键字来表示

类的修饰符包括 classModifier 和_accessModifier_:

classModifier: 类属性修饰符，标示类本身特性。

abstract // 抽象类
final // 类不可继承，默认属性
enum // 枚举类
open // 类可继承，类默认是final的
annotation // 注解类

accessModifier: 访问权限修饰符

private // 仅在同一个文件中可见
protected // 同一个文件中或子类可见
public // 所有调用的地方都可见
internal // 同一个模块中可见

继承

java中任何类都继承自object类，kotlin中任何类都继承Any类
Any 默认提供了三个函数：

equals()
hashCode()
toString()

举例：继承重写

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {

    override fun study(){    // 重写方法
        println("我在读大学")
    }
}

kotlin的扩展与高阶函数的定义和使用

扩展

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator 模式。
扩展函数

fun receiverType.functionName(params){
   body
}
//receiverType：表示函数的接收者，也就是函数扩展的对象
//functionName：扩展函数的名称
//params：扩展函数的参数，可以为NULL

扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

高阶函数的定义和使用

kotlin的委托

kotlin的协程