一、基础语法
1、var、val变量定义；val不可修改类似final；
var <变量名> ：<类型> = <初始化值>
val <变量名> ：<类型> = <初始化值>
如下定义：
var name : String = “abc”
其中可以直接省略 类型，如：var name = "abc" // 类型推导
2、Fun函数定义；
与java不同的点，fun函数可以在类外定义函数；
Unit相当于java的 void返回，可以不写，默认返回Unit（Void）
fun main():Unit{
}
具有返回值的例子：
fun:add(num1 : Int, num2 : Int): Int{
return num1 + num2
}
fun:add2(num1:Int,num2:Int) = num1 + num2 //使用类型推导，推导出返回值为Int
可变参数、可变长的参数
fun:method(vararg value : Int){
for（ i ：Int in value）{
println（i）
}
}
lambda 表达式函数
var method : (Int,Int) -> Int = {num1,num2 - > num1+ num2}
var res:int= method(1,1)
3、String 使用
val name = “abc”
val age = 22
println（“name$name, age$age”）//使用美元符号$拼接字符串
//换行,三个引号换行; .trimIndent() 函数去掉前置空格；
val info = """
AAAAAA
BBBBBB
""".trimIndent()
4、Null机制检查
var name:String?=null
name?.length //如果为null不执行，不会发生空指针异常
name!!.length //如果为null，发送空指针异常
//Int? 返回类型，可以返回null
fun:test(name:String):Int?{
}
//三目运算符
var info:String?=null
info?.length ?: "info为null"
5、in 区间
for（i：int in 1..9）{
}
for（i：int downTo 9..1）{
}
in 其中只可以从小到大；downTo 是从大到小；
用in区间做判断，如：var value = 2；if（value in 1..100）
指定间隔 step， 如：for（i：int in 1..20 step 2），间隔2循环数组1-20的数
用于排除until，如：for（i ： int in 1 until 10），排除10，输出1到9的数
二、比较和数组
1、比较
比较两个值
val name1 = “Alice”
val name2 = “Alice”
name1.equals(name2) //true 不推荐这样写，而是推荐使用==
name1 == name2 //true
比较对象地址，使用三个等号===
val name1 = “Alice”
val name2 = “Alice”
name1 === name2 // 输出：false
2、数组
第一种模式
val nums : Array<Int> = arrayOf(1,2,3,4,5)
println(nums[0])
第二种模式,20个size，value = 0开始value取值0、20，然后每个value + 1001，
val nums:Array<Unit> = Array(20,{value:Int -> （value + 1001）} )
三、条件控制
if 是属于表达式，具有返回值。
val max : Int = if(num1 > num2) num1 else num2 // 表达式比较大小
val max ：Int = if(num1 > num2){
//TODO ....代码
num1
}else{
//TODO ....代码
num2
}
switch 的写法，同时 when也具有返回值
基础写法
val num = 11
when(num){
1->println("一")
11->println("十一")
else ->println("else")
}
//具有返回值写法
val num = 11
val str : String = when(num){
1->{
println("一")
"一"
}
11-> {
println("十一")
"十一"
}
else -> {
println("else")
"else"
}
}
四、循环和标签
标签 xxx@ 自定义的标签
class 类 系统会自带一个标签，如 class Person{} this@Person
循环
var items :List<String> = listOf<String>("a","b","c")
for(item in items){
println(item)
}
items.forEach{
println(it)
}
遍历，打印下标
for(index in items.indices){
println("下标：$index , 对应的值：${items[index]}")
}
五、类与对象
类 默认是public ，可以不需要添加public
空类，可以不需要{}
定义空类：
class Empty
构造函数（class类需要添加open修饰才可以被继承）
主构造函数、次构造函数
open class Person(id : Int){ // 主构造
constructor(id : Int , name : String) : this(id){ // 次构造必须引入主构造 :this(id)
}
//构造函数重载
constructor（id :Int , sex : Char）: this(id){
}
//无参构造函数
constructor（）: this(12){
}
}
定义对象,不能使用new
var p = Person() //调用无参构造
继承和实现 使用：继承。class类需要添加open修饰才可以被继承
class Student (id : Int)： Person( id){
}
定义类的成员变量
class Student (id : Int)： Person( id){
lateinit var name : String // lateinit 懒加加载初始化，kotlin中全部无默认值
var age :Int = 0
}
抽象类 与 接口
接口，默认都是open 修饰
interface Callback{
}
抽象类
abstract Person ：Callback{ //多个接口，只需要用 逗号, 隔开
abstract fun getId() : Int
abstract fun initView() : Unit //返回空，可以不写 ： Unit
}
实现抽象类和接口
class Student ：Person(){ //继承必须需要加() 表示是构造函数
override fun getId() : Int = 33
override fun initView() { }
}
data 定义数据类（实体Bean）；其中：data 字段的使用，可以快捷生成javaBean类
data class User(val id : Int, var name ：String , val sex : Char)
//使用数据类（实体bean）‘
val user = User(11,"Alice","F")
克隆、复制
val(xId，xName，xSex) = user.copy()
println("xId:$xid ，xName:$xname，xSex:$xSex")
//拒绝复制, 使用下划线 _
val(_，xName，xSex) = user.copy()
println("xId:$xid ，xName:$xname，xSex:$xSex")
单例 ，使用object字段修饰
object Person{
fun test(){
}
}
//使用
Person.test()
单例模式，demo
class Test{
object Holder{
var instance = Test()
}
//使用派生companion object，实现static
companion object{
//在派生中写的代码逻辑，全部属于静态的
fun getInstance() : Test { // 简写： fun getInstance() : Test = Holder.instance
return Holder.instance
}
}
}
//使用
fun main(){
var test : Test = Test.getInstance()
}
内部类必须使用inner 修饰，若没有inner，则是属于嵌套类，嵌套类不能访问外部类的成员
class Test{
class Holder{ // 嵌套类
}
inner class Holder{ // 内部类
}
}
