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{}
