关键字

var   val

var name = "张三" 

name = "李四"  //true

name = 1//false    name初始化时为String类型

val name = "赵五"

name = "你好"//false  name 用val修饰不能被改变 应该相当于final

函数

fun test(args:Array<String>):Int{

    return 3

}

判断字符串是否相等

fun equalStr(i:String , j:String){

    i==j//true

}

equalStr("张三","张三")//true kotlin的==只比较对象是否相等，不比较内存地址值

kotlin提供了一个equals的重载方法，用于忽略大小写的比较 equals(str,true)//true为忽略 false 为不忽略

val ss = fun (name : String) = println("ssdd")// 函数名为ss的函数 默认函数体为一条打印语句

fun 代表为函数 、test为函数名、args为参数名 Array<String>为参数类型 类型为字符串数组 、Int为返回值 返回值为Int类型

字符串模板 ${}

ex:

fun dayin(str:String):String{

    return "你的${str}真好"

}//运行该函数时传入的内容会直接显示在返回值里

null关键字

函数参数中加?表示参数可以传null  不加？表示不能传入null值

ex： 

fun test(str:String?):String{

    return "别"+str

}

如果不加？ 则调用函数传入test(null)会报错 加上可以传入空 test(null) -->别null

str : String!! 两个叹号表示一定不为空

！！表示当前对象不为空的情况下执行

when表达式(ex：考试满分10分，9分还不错，6分刚及格，6分一下不及格)

fun checkGrade(score:Int){

    when(score){

        10  ->println("满分")

        9    ->println("还不错")

        6    ->println("及格了")

        else    ->println("不及格")

    }

}

fun xx(num:Int):String{

    var result = when(num){

        1->"一"

        2->"二"

        else->"三"

    }

    return result

}

Loop（循环）和Range（区间）

var num = 1 .. 100  // [1,100]   头尾都包含 1~100

var num2 = 1 until 100 // [1,100)    包含头不包含尾 1~99

var result = 0

fun test(){

    for(x in num){

        result = result+x

    }//循环 关键字in

}

step

var num = 1..16

num.count()//总数

for(x in num step 2){

打印结果为 1 3 5 7 9 11 13 15

}

List 和Map

var lists = listOf("你是谁","你在哪","你好啊","我不好")//定义一个集合list

var map = TreeMap<String,String>()

map["一"] = "one"

map["二"] = "two"

map["三"] = "three"

println(map["一"]) //"one"

函数和函数式表达

1、fun add(x:Int, y:Int) : Int = x+y

2、fun add(x:Int,y:Int):Int{

    return x+y

}

3、var i = {x : Int ,y : Int -> x+y}//变量i就是一个函数  用时 println( i(2,3))

4、var j : (Int,Int)->Int = {x,y -> x+y}// println(j(2,3))

//如果函数内部只有一句return的语句 2的写法可以省略成1的写法

默认参数和具名参数以及变长参数

val Pi= 3.1415926

fun getRectArea(PI:Float = Pi,radius:Float):Float{

        return 2*PI*radius

}

fun main(args:Array<String>){

    var area = getRectArea(radius = 2.0f)//具名参数  调用方法后 因为方法已经给出pi是默认参数的默认值 所以直接用具名参数 radius = 2.0f即可调用函数

    println(area)//打印圆的周长

}

字符串转数字

var a = "13"
var b = 13
a = b.toString()
b = a.toInt()

异常处理

try{
    
}catch{
    
}finally{
    
}

循环

while(true){

}

var ssList = listOf<T>(x1,x2,x3,x4,x5)//建立一个集合 里面add五个元素

for(name  in  ssList){

}

forEach循环

fun aa(){

    (0..100).forEach{

        if(50<= it) return@forEach

              println(it)

    }

}

递归

fun digui(num:Int):Int{
        if(num==1){

        return 1;

    }else{

    return num *digui(num-1)

    }

}//阶乘

递归计算100的阶乘  用Long类型也装不下  用BigInteger

fun degui2(n:Int):Int{

    if(n==1){

    return 1

}else{

        return n+degui2(n-1)

    }

}//累加

尾递归

tailrec fun weidigui(n:Int ,result :Int):Int{

    if(n==0){

        return 1

    }else{

        return weidigui(n-1,result+n)

    }

}// tailrec关键词实现尾递归 要求返回值要是函数本身 所以这里用了两个参数来写做累加的函数

面向对象 封装

private fun add(){}

继承

open class father{

    var name = "张三"

    open fun add(){

    }

}

class son : father(){

    override fun add(){

    }

}

kotlin中继承用：来表示   子类继承父类 父类必须有关键词open 重写父类方法时 父类方法必须有关键词open 
子类复写的方法上要有关键词override 

重写接口或父类方法都要有override关键字

抽象类

abstract class Human(var name : String){

    abstract fun eat()

}

class Man(name : String) : Human(name){

    override fun eat(){

            println("")

    }    

}

接口

interface IMan{

     fun xiaodidi()

}

class Man : IMan{

    override fun xiaodidi(){

        println("")

    }

}

实现接口不用加括号   继承抽象类要加个括号

class Man:Human(),IMan{

    override fun xiaodidi(){

    }

    override fun eat(){

    }

}

var house = listOf<Human>(ren,taijian)

for(p in house){

    if(p is Man)

}

委托和代理

kotlin接口代理关键字   by

interface IWashBowl{

    fun washing()

}

class 大头儿子 ：IWashBowl{

    override fun washing(){

        洗碗 

    }

}

class 小头爸爸 ：IWashBowl by 大头儿子(){

    override fun washing(){

        通过by可以调儿子的洗碗方法

        大头儿子().washing()

    }

}

单例模式

关键字：object

object class 大头儿子{

    object关键词修饰后大头儿子类为单例 内存中有且只有一个实例

}

大头儿子()  //表示创建了一个大头儿子对象

大头儿子  //表示没有创建大头儿子对象

刚才上面这段代码

class 小头爸爸 ：IWashBowl by 大头儿子(){

    override fun washing(){

            大头儿子().washing()//此处又重新创建了一个大头儿子对象 因为大头儿子类是单例的 所以不用加括号

}

}

class 小头爸爸 ：IWashBowl by 大头儿子{

    override fun washing(){

            大头儿子.washing()//此处又重新创建了一个大头儿子对象 因为大头儿子类是单例的 所以不用加括号

}

}

枚举

enum class Week{

    星期一，星期二，星期三，星期四，星期五，星期六，星期天

}

印章类Sealed class  

子类类型有限的class

有三个类 小母驴 小公马 小公驴

sealed class Son {//她们三个类生出来的儿子只可能是骡子或驴 所以用sealed指定

    fun sayHello(){

        println("")

    }

    class 小小驴() ：Son()

    class 小骡子() ：Son()

}

关键字

lateinit  延迟加载 只能修饰var 不能修饰val, 非kotlin基本类型

companion object 修饰静态类和静态方法

const只能修饰val，不能修饰var  经过const修饰的常量，才是java中理解的常量

const val NUM = 8

internal  java里面有public protected private 和默认修饰符， kotlin里多了个internal  被internal修饰的  模块内可见（同一个module下）

as 强制转换   , Kotlin里面，Int类型不能使用as转换为String类型。第二，使用as运算符进行类型转换，如果转换错误，会抛出异常

“？”运算符，是kotlin提供的安全的类型运算符，使用“?.”进行类型转换的时候，如果转换失败，则会返回null，而不会抛出异常

val a = 5   
val b = a as? String 

多行输入符 三个双引号

val str = """

        one

        two

            """

Unit  如果函数不会返回任何有用值，那么他的返回类型就是 Unit

this关键字      用this@xx来表示  xx可以是类名也可以是函数名

operator fun ss() //告诉编译器要定义一个运算符的方法了

infix fun xs()// infix 为中缀表达式

可变参数   变长参数  vararg 

fun asList<T> (vararg num :T) :List<T>{

}

变长参数相当于java的可变参数 （...）

调用时 asList(1,2) asList(1,2,3) asList(1,2,3,4)

val a = array(1,2,3)

val list = asList(1,2,*a,4) 传递一个 array 的内容给函数，我们就可以使用 * 前缀操作符  这个*只支持对于变长参数的场景 而且只能展开数组

inner  内部类

class xxx{

    private inner class xxx{

    }

}

字符串与对象地址比较

"11"=="11"//true  相当于equals

new String("123")==="123"//false 相当于==  比较的是内存地址

内联扩展函数之let

let扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，
let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作。

类的构造方法

class 妹子 constructor (var 长相：String，var 性格：String){

    init{ //init{}是构造方法的方法体，在每一次创建一个对象的时候都会调用

    }

}  //只有一个构造方法时constructor可以省略

var 妹儿 ：妹子 = 妹子(美，好)//根据构造方法传入参数长相美，性格好 new一个妹子 出来 

kotlin里的object  是Any

空类型和智能类型的转换

String?

String!!

包

import com.palmap.activity.sss

import com.palmap.activity.sss as bbb

同一个类下有相同类名的包导入 可以在导包的时候用as 给他起个别名

数组

val arrayOfInt : IntArray = intArrayOf(1,2,3)

val arrayOfChar : charArray = charArrayOf('a','b','c')

val arrayOfString : Array<String> = arrayOf("sss","www","vvv")

常量val和变量var

运行时常量  val name = “你好啊”

编译期常量 const val name = "嗯好"

类型推导

只要编译器可以猜到你定义 的变量或常量的类型 就可以不用写类型 

ex   val ss = "sss"

val ss = 5

var x = getString()+5//String类型

Lambda表达式

Lambda表达式实际是一个匿名函数

写法：

{[参数列表] - > [函数体，最后一行是返回值]}

val sum = {arg1 :Int,arg2 :Int -> arg1+arg2}

Lambda表达式类型举例

()->Unit   //无参，返回值为Unit

(Int) ->Int//传入一个整型，返回一个整型

(String ,(String)->String) -> Boolean //传入字符串,Lambda表达式，返回布尔

调用：

用()调用    == 用invoke调用

println(sum(1,2))

println(sum.invoke(1,2)) //invoke是kotlin里自带的方法

Lambda表达式的简化

args.forEach(::println)简化过程

args.forEach({println(it)})

对于函数来说，如果他的最后一个参数是Lambda表达式,就可以把大括号里的内容移到外面去

args.forEach(){println(it)}

如果小括号里什么也没有，小括号可以省略

args.forEach{println(it)}

如果传入的函数和需要接收的Lambda表达式是完全一样的，还可以进一步简化

args.forEach(::println)

如果Lambda表达式只有一个参数，默认为it  

fun main(args : Array){

    args.forEach{

        if(it=="q")return

        println(it)

    }

println("完事了")

}  //执行以后 打印语句“完事了”执行不到 因为forEach属于Lambda表达式 这里的return是直接return main函数如果想要return循环 可以给循环起个名字

fun main(args : Array){

    args.forEach ForEach@{

if(it=="q")return@ForEach

println(it)

}

println("完事了")

} 

表达式

条件表达式  中缀表达式 

val mode = if(){ xxx }else{ sss } 如果要这样写需要写完整 就是有if也要有else 

多层循环嵌套 可以起名告诉编译器要跳出哪个循环

Outter@for(,,,){

    Inner@while(,,,){

    if(..)break@Outter

}

}

解决两个接口里有相同名字相同返回值相同参数的方法，方法名冲突的问题 用super<>泛型里面加上要调用那个方法的接口名字