Kotlin基础语法

1.函数

（1）Main函数
默认是Unit返回类型，可以定义其他返回类型：Int

（2）直接声明一个函数，给出返回值：
fun max()=1;

(3)参数函数
fun max（x:Int，y:Int）=if（x>y）{
x
}
else{
y
}
如果已经确定返回某个值，可以忽略指定返回类型

2.变量

(1)位置：
全局变量和局部变量

（2）方式：

var j="2"
val i="1" //和java的final
val z:String="3"

拼接
println("i:${i}j:${j}")

3.类

（1）声明：
class Person（val name:String）{
}
//不可以传递null
var person=Person（"jarry"）

class Person（val name:String?）{
}
//可以传递null
Person（null）

（2）成员变量
可以使用到变量：
person.name
但是如果是val是不能这样修改值：person.name="song"
var就可以，因为val是不可修改的

class Person（var name:String）{

val married:Boolean
get()=true //由于是val，只能有get，没有set

var old:Int=1 //如果set方法，必须有默认值
get()=12
set(value){
old=value
}
}

var person=Person（"jack"）
person.married // 调用的是get
person.old=23
person.old

4.枚举

//enum 是软关键字，必须跟在class前面，不然就是一个普通变量名
enum class Color（val r:Int,val g:Int,val b:Int）{
RED（255,0,0）,
YELLOW（1,2,3）,
BLUE（2,3,4）;

//必须用;将下面的方法分开
fun rgb（）=r+g+b
}

使用
Color.RED

5.控制流

Kotlin中没有switch关键字

可以用when

when（Color.RED）{
Color.BULE->println("bule")
Color.YELLOW,
Color.RED->println("f") //可以用逗号表示，多个

}

when{ //如果没有参数，则可以写任何条件表达式，只要满足就执行
1+2==3->println("shi")
test()->println("shi")
}

fun test()=true

fun max(x:Int,y:Int)=when{
x>y->x
x<y->y
}

6.循坏

//表示11次循环，1——10之间
for（i in 0..10）{
}

val range:IntRange=0..10
loop@ for(i in range){
if(i==2){
break @loop
continue@loop //跳出
}
}

7.集合

val list=listOf(1,2,3,4)

list[0]
list.last()

遍历：
for（i in list）{

}

list.forEach(){
   item->
   println(item)
}

list.forEachIndexed{
index,item->
}

list.joinToString

8.参数传递:

fun test(i:Int=1,k:String=""){
}

test()
test(2)
test(3,"sf")
test(k="gg")

可变长度的参数

fun test(vararg item:Int){
item.forEach(){
    item->println(item)
}


}
test(1,2,3,4)   //可以传递任意长度的参数，传进去之后是一个数组

9.扩展方法：

inline fun String.show(){
}

"".show

10.扩展属性

inline val String.lastChar:Char
get{}=get{length-1}

11.map

创建：val map=mapOf(1 to "a",2 to "b",3 to "c")
获取：map[1]、map["c"]

设置：
1 to "d"
1.to["e"]
1 with "f"

//析构
val pair ="a" to "g"
val (key,value)=pair
val compile="com.android.support.constraint:constraint-layput:1.1.2"
val (group,name,version)=compile.split(":")

中缀
infix fun<A,B> A.widh(that:0):Pair<A,B> =Pair<this,that>

//字符串、正则表达式 null安全 本地函数

12.字符串

和Java不同的是，Kotlin的字符串提供了扩展方法

val str="com.jarrysong.lession"
str.split(".") //这是Kotlin向String注入的一个方法，并不能和Java一样得到结果，这里会得到正则表达式的结果

val path="xxx/xxx/build.gradle"
val dir=path.substringBeforeLast("/")
val fullname=path.substringAfterLast("/")
fullname.substringBeforeLast(".")
fullname.substringAfterLast(".")

13.正则表达式

val r1="(.+)/(.+)\.(.+)".toRegex()
val matchResult=r1.matchEntire(path)
if(null!=matchResult){
matchResult.destructured.toList()
}

字符串要表示原有格式，可以用三引号符：
val r2="""(.+)/(.+).(.+)"""

val str2="""fafdsdf
dfsdfdsf
sadfsdf"""
//支持换行，保持原来样式

val str3="""'$'path""" //用美元引用path变量

val str4="$path" //如果不用三引号符，就用把美元符转义

14.null参数传递

fun test(str:String){ //不可以传递空
}

fun test(str:String?){ //可以传递空
str.substring(0) //不可以，有危险
str?.substring(0) //可以
str!!.substring(0) //不会报错，但是要自己控制是否为空

test(null)

15.本地函数

class User(val id:Int,val name:String?,val psw:String?)

//存库
fun User.save(){
  //常用方法
  if(name==null||name.isEmpty()){


  }
  if(psw==null||psw.isEmpty()){


  }

  //改造
  fun check(str:String?){
     if(psw==null||psw.isEmpty()){


      }
  }

  check(name)
  
}

//接口、抽象类、继承
嵌套类、内部类、object与伴生对象
访问控制

16.接口

Interface OnClickListener{
  val name:String
  fun click(）
  fun test(){
   println("sdf")
   }
}


Interface OnClickListener2{
  fun click(）
  fun test(){
   println("sdf")
   }
}


class Button(override val name:String) :OnCliclListener，OnCliclListener2{
   
  override fun click(){}   //如果两个接口中都有相同的方法，一般重写


       override fun test(){
           super<OnclickListener>.test()   //如果两个接口中都有相同的方法，用用父方法，就一定要指明是谁的方法
       }   




}

17.抽象类

abstract class Person{

  abstract fun test（）
}


class Man :Person(){

}

18.继承

open class Button(override val name:String) :OnCliclListener，OnCliclListener2{
   
  override fun click(){}   //如果两个接口中都有相同的方法，一般重写


       override fun test(){
           super<OnclickListener>.test()   //如果两个接口中都有相同的方法，用用父方法，就一定要指明是谁的方法
       }   

    open fun show(){}




}


class NDButton(override val name:String) :Button(name){
      override fun test(){}
      override fun click(){}
      override fun show(){}
}

19..嵌套类

class AlertDialog{
val str ="aaaa"



//嵌套类
class Builder{ 
    //不能引用str
}

//内部类
inner class Inner{
  fun test(){
    str.substring(0)
  }
}



//类似Java的static
object Dialog{

  fun show（）{
   }

}

20.伴生类（伴随AlertDialog类而生的）

companion object{    //可以指定名字A,如果不指定就是Companion
    fun show(){
     }
}


fun main（args:Array<String>）
     Dialog.show()
     AlertDialog.Companion.show() 
     //匿名内部类
     val person =object：Person（）{
          override fun test(){
            }

     }
     
     val listener =View.OnClickListener{
       
     }
}

21.访问权限

public ：默认的，所有地方可见
private：类内部 同文件当中可见
protected：子类内部可见
internal：模块内可见

数据类、构造器与委托

22.数据类，当调用toString的时候就会将属性全部输出

date class Person(val name:String)

fun main(args:Array<String>){
User("ad")

}

23..构造类，默认的是主构造函数和对应的参数

class User（val name:String）{
   var name:String=""
   var pwd:String=""


   //副构造器
   constructor(name:String,pas:String):this(name){
       this.name=name
       this.pwd=pwd
 
   }
   
   //初始化器
   init{
   this.name=name
   }

}

24.委托，替代继承的方式

class MyList(list:ArrayList<String>):Collect<String> by list{
}

//属性委托,如果没有使用这个list，就不会调用这个方法，如果使用了第一次就会调用，第二次使用也不会再创建
val list：ArrayList<String> by lazy{
      ArrayList<String>{}
}



var str:String by Delegates.notNull<String>{
}

var str:String by Delegates.observable(""){
   proerty,oldValue,newValue->
   false   //不能将newValue赋值给str
}

25.Any?

就相当于Java中的Object

class Delegates<T>：ReadWriteProperty<Any?,T>{

     var t:t?=null
 
     override fun getValue(thisRef:Any?,property:KProperty<*>):T{
           return t?:throw Exception("")    //如果t有值就返回t,如果为空就返回异常
     }


     override fun setValue(thisRef:Any?,property:KProperty<*>,value:T{
             t=vaule
     }


 }



var p:String by Delegates{}