前言：

kotlin这门语言给我的感觉就是java和python的结合起来改造的语言，作为后来的语言，与前面的语言相像是有道理的。这门语言中有很多简写的东西，就是有很多简便的声明方法，我也觉得十分的不错。

基本的声明：

1. kotlin中句尾 ; 是可有可无的

2.kotlin中空值是用null表示

函数声明方式：

fun 函数名（形参：形参类型）：返回值类型{

函数体

}

kotlin中用Unit表示无返回

函数表达式：

函数在kotlin中存在简写的形式，也就是这里提到的函数表达式

//fun 函数名（形参）：返回值类型 = 函数内容
fun add(x:Int ,y:Int):Int = x + y

很明显，这种形式的表达试能构造的函数偏向于简单，并不能支撑很复杂的函数

除此之外，kotlin中还能用一个变量来存储函内容，对这个变量的调用就是对函数的调用，十分方便。

//var 变量 = {形参 -> 函数体}
var i = {x:Int , y:Int -> x + y}
var result = i(x,y)

变量类型与变量声明方式：

var表示变量类型的声明，val表示常量类型的声明

var name = "只晓得闲逛"
val key = 1

var声明变量的时候，会根据语句后的赋值自动识别变量的数据类型，为其开辟空间。当然在第一次识别后，变量类型便已经确定，便不能存储其它类型的变量。若在声明变量时不对其进行赋值，则应该指明其变量类型。

var name : String

kotlin支持Int，Short，Long，Byte，Float，Double，Boolean等基本数据类型。

特殊的数据类型：

kotlin还支持list和map两种数据类型，其中List可以理解为列表，Map可以理解为字典。

列表可以理解为特殊的数组形式，不过按照顺序将相同或者不同的变量放在一列之中。这个和python中的list数据类型差不多一样。

var list = listOf(0,"1")
//withIndex可以输出下标
for( (i,e) in list.withIndex ){
    println("$i $e")
}

字典其实就是键值对，其抽象形式为 键 = 值 相对应。哈希表差不多也是这个意思。

var map = TreeMap<String , String>()
map["李白"] = "君不见大河之水天上来"

 字符串模板：

kotlin中字符串某些内容可以用变量表示，可以更具需要按照变量内容替换字符串对应位置的字符，这个被称为字符串模板。

//将place中存储的字符替换则可以改变输出字符中的地点
var place = "家门"
println("我走进${place}")

循环语句：

if-else语句：

if(){

}else if(){

}else{

}

when语句:

kotlin中的when语句和switch语句很像，它可以根据条件执行不同的语句

when(score){
    0 -> println("错误")
    1 -> println("正确")
}

loop语句：

loop语句相当于将枚举浓缩起来了，化作了一个变量。我感觉这个就是kotlin一个方便的地方。

var nums = 1 .. 100//此处就是loop的用法
for(num in nums){
    print(num)
}

而步长step，一般 nums 按照 step = 1 进行循环，逐步输出。而我们可以设定步长，按照步长进行一定的枚举。

异常处理语句：

我个人觉得kotlin中异常处理语句和java中的没啥区别，其实也是try+catch

try{
}
catch(异常类型){
}

递归+尾递归优化：

本来递归是一种算法，在程序的基本语法应该是不会说的。但是，kotlin中存在一种被称为尾递归优化的优化方式。在使用关键词tailrec后，在递归返回值的地方调用的只是该函数，而不应该包含其它东西。

tailrec fun olladd(num:Int , result:Int):Int{
    if(num == 1){
        return 1
    }
    return olladd(num-1 , result+num)
}

面向对象：

kotlin也是一门面向对象算法，或者说它作为吸收了前几代代码精髓的语言，理所应当应该具有面向对象性。它具备基本的继承，派生和多态三种性质。

继承：

kotlin中继承和java在语法表达上有一点点小区别。

open class father{
    var charactor:String = "性格内向"
}

class son : father(){
    
}

上面就是kotlin中继承的简单例子。父类不具备open关键字时，子类不能实现对父类的继承。

而kotlin中的抽象类，和接口与java中没啥区别。由于他们本身就具有需要实现的函数，不继承是无法具化为对象的，所以就不用写open关键词了。

abstract class human(var name:String){
    abstract fun eat()
}

class Man(var name:String):human(name){
    override fun eat(){
    }
}

这就是一个抽象类，当然，也是个纯虚类。类中所有函数都是抽象类.在子类对父类的函数进行重写时，要加上关键字override

kotlin中接口也没有啥区别，同样就是将class换做了interface

interface human{
    fun eat(){} 
}

class man:human{
    override fun eat(){
            
    }
}

多态：

kotlin中的多态其实和java还有其它语言没有啥区别，就是对抽象类进行继承和对抽象函数进行具体化的过程.

代理和委托：

在kotlin中具备这样的功能，在某个类需要完成某个任务时，可以指定别的类代理完成该项任务。其关键词就是by。类要实现接口，可以使用继承了该接口的其它类的方法代替自己实现接口，当然在该类实现了接口抽象函数的情况下，优先使用该类的自己实现的方法。

interface ball{
    abstract fun bound()
}

class blackball : ball{
    override fun bound(){
    }
}

//此时whiteball就可以使用balckball实现的bound方法，完成bound这个动作
class whiteball : ball by blackball(){

}

单例模式：

其实kotlin中的单例模式就是我们所谓的静态，加上object关键词，可以实现我们以前认为的静态。对类的方法调用不用实例化。单例模式下，代理中不用实例一个被代理对象，直接写上被代理的类的名字即可

object human{
    fun eat(){}
}

human.eat()

枚举类：

kotlin中将类前关键词class前加上enum，可以实现一个枚举类。枚举类具有可以在使用时灵活调用每个待枚举项的功能，并且可以快速获得每个枚举内容的顺序。

enum class week{
    1，2，3，4，5，6，7
}

印章类：

该类可以指定其继承类有哪些，非指定类无法继承该类。在class关键词前加上sealed就可以

sealed class Son{
    class 小蝌蚪():Son()
    class 小驴():Son()
}