Kotlin基础

　　kotlin与java一样都需要编译为.class文件后通过虚拟机执行代码，它可以与java共存，但是语法简洁，代码量少，只是生成的APK文件（app的安装文件，可设置APK文件签名，保护app不被恶意APK覆盖，对APK文件进行反编译可以还原源代码，通常会进行反编译处理）可能更大。

变量

　　由字母、数字下划线组成，第一个字符不能为数字，区分大小写，不能使用关键字（例for、if、else等），建议使用驼峰式命名方式（例apiService、appData等）。　　

　　声明变量分为可变与不可变变量：

1. var（variable）可变
2. val（value）不可变

var test :Int//指定数据类型时可暂时不赋值
val test="value"//有初始化赋值时，类型可省略，系统自动判断

数据类型

　　基本数据类型有8种:Byte、Short、Int、Long、Float、Double、Boolean、Char。

　　其中数据类型转换可以由低级至高级转换。（等级由低到高：Byte<Short<Char<Int<Long<Float<Double）

 

val a:Byte=1
val b:Short=10//必须声明类型，否则自动判断为Int
val c='a'
val d=100
val e=1000L
val f=1.0f
val res=a+b+c.toFloat()+d+e+f//将c转换为Float类型的ASCII码值
println("a+b+c+d+e+f=$res")//$res表示将其存储的数值转换为字符串，合成到新字符串中
//println()可将内容输出到Logcat窗口中

 　　强制转换方式。

val a:String="test"
val aInt:Int=a.toInt()//字符串转换为整数
val b:Int=1
val bString:String=b.toString()//整数转换为字符串
val c:Boolean=true
val cString:String=c.toString()//布尔值转换为字符串,真值为true，假值为false
val d:String="true"
val dBoolean:Boolean=d.toBoolean()//字符串转换为布尔值，只有“true”可以显式转换为真值
val e:Float=1.1f
val eInt:Int=e.toInt()//浮点数转换为整数 1
val f:Int=1
val fFloat:Float=f.toFloat()//整数转换为浮点数 1.0

字符串

　　字符串字面量：

1. 普通字符串
2. 原始字符串

val str="hello \nworld"//普通字符串，可以使用转义字符，不可直接换行
val str2="""hello
world"""//原始字符串，不支持转义字符，可直接换行

　　String类：存储不可变字符串，在堆内存中占据一个固定的内存空间，其实例无法改变，与val声明不可变变量不同，当实例被重新赋值时，虚拟机会回收原有内存空间，重新分配内存空间。

　　（“”：长度为0并占内存空间的空字符串，在内存中分配一个空间，可调用方法。null：特殊值。）

　　StringBuffer类和StringBuilder类：存储的字符串可调整大小，不需要创建新的内容空间进行存储。在Kotlin中可以调用他们的java类。

　　（StringBuffer对比~Builder来说，是线程安全的，当一个线程访问其实例时，保护其不被其他线程访问，避免数据不一致问题。）

分支语句

1. if...else...
2. when

if（condition）{//IF
  blabla              
}else if(condition){
  blabla  
}else{
  blabla
}

when(condition){//WHEN
  1->{blabla}
  2,3->{blabla}
  in 4..6->{blabla}
  !in10..13->{blabla}
  else->{blabla}        
}

循环语句

1. while(...){...}
2. do{...}while(...)
3. for(i in startNum until或者downTo endNum){...} ;for(i in startNum until或者downTo endNum step stepInt){...}
4. repeat(循环次数){...}
5. break
6. continue

数组

　　1.元素未初始化数组

var arr=arrayOfNulls<Int>(10)
arr[0]=1
arr[1]=2
arr[2]=3
var max:Int?=0
for(a in arr){
  a?:continue//elvis运算符，左侧为null时返回右侧，否则返回左侧结果
  if(a>max!!){
    max=a
  }
  println(a)
}
println(max)

　　(?:表示当前对象可以为null，不会抛出空指针异常。!!:表示当前对象不为null时执行，为null时抛出空指针异常。)

　　2.元素初始化数组

var a:Array<String>=arrayOf("yi","er","san")//其他类型数组创建
var b:IntArray=intArrayOf(1,2,3)//基本数据类型创建
for(i in a.indices){//indices方法获取数组的所有下标
  println("a["+i+"]="+a[i])
  println("b["+i+"]="+b[i])
}

　　3.空数组:使用emptyArray<数据类型>()创建，使用时通过arrayOf()或者typeArrayOf()初始化，或者赋值一个非空数组。

var a=emptyArray<Int>()
a=arrayOf(1,2,3)

　　4.二维数组(表格)

val a=Array(3){IntArray(2)}//实例化方式创建二维数组
a[0][0]=0
a[0][1]=1
a[1][0]=0
a[1][1]=1
a[2][0]=0
a[2][1]=1
for(i in a.indices){
  for(j in 0 until a[i].size){
     println("("+i+","+j+")="+a[i][j])
  }
}
val b=arrayOf(intArrayOf(1,2,3),intArrayOf(4),intArrayOf(5,6))//使用一维数组直接创建二维数组
for(i in b.indices){
  for(j in 0 until b[i].size){
     println("("+i+","+j+")="+a[i][j])
  }
}

函数

　　函数与高阶函数

fun a(x:Double,y:Double):Double{
  return x*y
}   
fun a(x:Double,y:Double):Double=x*y

fun b(x:Double,y:Double,z:(Double,Double)->Double){//高阶函数作为参数的数据类型，函数类型为()->Unit
  println(x*y*z)     
}
fun c(x:String="xxx",y:Double,z:Double){//高阶函数作为数据类型
  var area:(Double,Double)->Double=d(x)
}
fun d(x:String):(Double,Double)->Double{//高阶函数作为返回值
  if(x=="xxx"){
    return ::a
  }
}

　　匿名函数

var a=fun(x:Double,y:Double):Double{
  return x*y
}
println("图片面积为${a(1.1,2.2)}")

　　Lambda表达式：本质为匿名函数，多作为高阶函数使用，也可以直接使用。

var a={x:Double,y:Double->x*y}//标准形式

getData(x,y,{a:Double,b:Double->a*b})
getData(x,y){a:Double,b:Double->a*b}//尾随形式，当函数最后一个参数是lambda表达式时，可以放在括号外面。

inline fun getInfo(x:Double,y:Doubel,lambda:(Double,Double)->Double){
  println("test")
}

(inline关键字:修饰函数，使它成为内联方法，调用时会把方法中的代码移动到调用的地方，而不是通过方法压栈进栈，带有lambda表达式参数的函数建议使用内联方法。

noinline关键字：修饰内联方法的参数，使它可以传递给内联方法中调用的非内联方法。)

　　Lambda表达式参数的省略形式：如果表达式只有一个参数，并能够根据代码判断参数的数据类型，那么参数可以省略，并用it关键字代替。

inline fun repeat(a:Int,lambda:(Int)->Unit){
  for(i in a downTo 0){
    lambda(i)
  }  
}    

repeat(1,{l:Int->println("a$l")})//参数的标准形式
repeat(1){l->println("b$l")}//参数的尾随形式
repeat(1){println("c$it")}//参数的尾随省略形式

　　let、also、apply、with、run函数：使用lambda参数省略形式调用。

函数名	it关键字	this关键字	默认返回值	带返回值
let	调用对象本身	调用所属实例	Kotlin.Unit	返回返回值
also	调用对象本身	调用所属实例	调用对象本身	返回调用对象本身
apply	不支持	调用对象本身	调用对象本身	返回调用对象本身
with	不支持	调用对象本身	Kotlin.Unit	返回返回值
run	不支持	调用对象本身	Kotlin.Unit	返回返回值