kotlin语法学习

一、字符串模板

字符串字面值可以包含模板表达式，即一小段代码，会求值并把结果合并到字符串中。模板表达式以美元（$）开头，有一个简单的名字构成：

val number = 100
println("The Result is $number")

或者用花括号${}括起来的任意表达式：

val text = "This is Text"
println("The length is ${text.length}")

字符串与转义字符串内部都支持模板，如果你需要在原始字符串中表示字面值$字符（它不支持反斜杠转义），你可以用下列语法：

val price = "${'$'}9.99"

二、字符串的值

kotlin有两种类型的字符串字面值：转移字符串可以有转义字符，以及原始字符串可以包含换行以及任意文本。一下是转义字符串的一个实例：

val s = "Hello, world\n"   //\n换行
val s2 = "{\"key\":\"value\"}"    //\反斜杠对""进行转义，保留字符串格式

字符串使用单个引号（“”"）分界符括起来，内部没有转义并且可以包含换行以及任何其他字符：

val text = """
This ( is) "Text"
"""

三、数组

声明对象数组的三种形式：

3.1、使用arrayOf函数和指定的数组元素创建数组

//Java写法:
String[] params1 = {"str1", "str2", "str3"};
 
//kotlin写法:
val params1 = arrayOf("str1", "str2", "str3")

3.2、使用arrayOfNulls函数创建一个指定大小的并初始化每个元素为null的数组

//Java写法:
String[] params2 = new String[12];
 
//kotlin写法:
val params2 = arrayOfNulls<String>(12)

3.3、Array构造方法指定数组大小和一个生成元素的lambda表达式

这种方法创建的数组，其中的每个元素都是非空的，就像下面这样:

//kotlin写法:
val params3 = Array<String>(3){i -> "str" + i }
 
// 也可以这么写
 val params=Array(3){"str$it"}

因为数组的原始大小已经确定，在lambda表达式中接收数组的下标，并返回一个该下标位置的值。

3.4、for循环

3.4.1、元素遍历

for(item  in  array){
	println(item)
}

3.4.2、下标遍历

for(i  in  array.indices){
	println(i.toString() + "->" +array[i])
}

3.4.3、元素遍历（带索引）

for((index,item)  in  array.withIndex()){//同时遍历下标和元素
	println("$index->$item")
}

3.5、forEach遍历数组

array.forEach{
	println(it)
}

3.6、forEach增强版遍历数组（索引加元素）

array.forEachIndexed{index, item ->
	println("$index -> $item")
}

四、集合

Kotlin的集合设计与Java不同的是，它把访问集合数据的接口和修改集合数据的接口分开了。这种区别存在于最基础的使用集合的接口之中，Kotlin.collections.Collection。使用这个接口，可以遍历集合中的元素、获取集合的大小、判断集合中是否包含某个元素，以及执行其他从该集合中读取数据的操作。但是这个接口没有任何添加或移除元素的方法。

使用Kotlin.collections.MutableCollections接口可以修改集合中的数据。它继承了普通的Kotlin.collections.Collection接口，还提供了方法来添加和移除元素、清空集合等。

//可变集合
val  arrayString  = mutableListOf<String>()
arrayString.add("1")

val  arrayString  = mutableListOf<String>("2","3")
arrayString.add("1")

//不可变集合
val  arrayInt =  listOf<Int>("1","2","3")

//可变集合
val  arrayMap  =  arrayMapOf(Pair("key","value"))
val  arrayMap  =  mutableMapOf<String,String>()
arrayMap.put("1","2")
arrayMap["1"] =  "2"

//不可变集合
val  arrayMap  =  mapOf<String,String>(Pair("key","value"))

五、集合与数组互相转化

fun main(args: Array<String>) {
 
    //声明一个数组
    val array1 = arrayListOf("str1", "str2", "str3")
 
    //将数组转化为集合
    val list1 = array1.toList()
 
    //将集合转化为数组
    val array2 = list1.toTypedArray()
}

六、方法

6.1、普通类的方法

class  Person  {
	fun  test(){
		println("成员方法")
	}
}

//需要构建出实例对象，才能访问成员方法
Person().test()

6.2、静态类的方法

//静态类里面的方法，都是静态方法，不需要构建实例对象，可以通过类名，直接访问静态方法
object  NumUtil  {
	fun double(num: Int):  Int{
		return  num*2
	}
}

NumUtil.double(1)

6.3、companion object 伴生类的方法

kotlin中没有static关键字，不过我们可以借助companion object来实现类静态方法的目的

class  Person {
	//不需要构架实例对象，可以通过类名，直接访问静态方法
		fun  test(){
			println("companion  object  实现类的方法")
		}

		fun test2(){
			println("普通成员方法")
		}
}

Person.test()
Person().test2()

七、方法参数

7.1、默认参数

方法参数可以有默认值，当省略相应的参数时使用默认值，与其java相比，这可以减少重载数量
我们可以通过类型后面的=来设置默认值

fun  read(offset:  Int = 0, start: Int){}

7.2、具名参数

如果一个默认参数在一个无默认值的参数之前，那么无默认值的参数，只能通过使用具名参数调用该方法来使用：

fun  read(offset:  Int = 0, start: Int){}

read(start = 1)//仅仅指给start传递值，使用默认值offset = 0

如果最后一个参数是方法，那么它既可以作为具名参数在括号内传入，也可以在括号外传入。

fun  read(offset:  Int = 0, start: Int, action: ()  -> String){}

read(start = 1, action = {"括号内传递action参数"})

read(start = 1) {"括号外传递action参数"}

7.3、可变数量的参数（Varargs）

方法的参数（通常是最后一个）可以用vararg修饰符标记：

fun  append  (vararg str:  Char， offset: Int):  String{
	val result = StringBuffer()
	for (char  in  str){
		result.append(char)
	}
	return result.toString()
}

允许将可变数量的参数传递给方法：

append('y','o','u','r','s',1)

当我们调用vararg方法时，我们可以一个接一个传参，例如append(‘y’,‘o’,‘u’,‘r’,‘s’)，或者，如果我们已经有一个数组并洗完将其内容传给该方法，我们使用伸展（spread）操作符（在数组前面加*）：

val  world  = charArrayOf('y','o','u','r','s')
val  result = append('y','o','u','r','s',*world, offset = 2)

可变参数的要求：

• 只有一个参数可以标注为vararg
• 如果vararg参数不是最后一个参数，可以使用具名参数语法，给后面的参数传递值。

八、Lambda表达式

class  View{
	public  void setOnClickListener(OnClickListener l){
	}
}

view.setOnClickListener(new View.OnClicListenser(){
	@Override
	public void onClick(View view){
		println("Lambda简洁之道")
	}
})

view.setOnClickListener{view -> println("Lambda简洁之道")}
1、省略了接口的结构体
2、保留参数view
3、-> 编写表达式

lambda表达式作为方法中的参数时候，定义transform方法，可以对数组中的元素进行变换。

//array： 要求传入一个数组，元素类型为Int 整数类型
//action： 要求传入的是一个方法，接受两个参数下标index，元素element，要求返回变换后的元素，会替换掉老的元素
fun transform(array:  Array<Inr>, action:  (index:  Int,   element:   Int) ->  Int){
	for(index  in  array.indices){
		val  newValue  =  action(index,array[index])
		array[index]  =  newValue
	}
}

val  numbers = arrayOf(1,2,3,4)
//具名参数调用，即使用参数名action给它赋值
transform(numbers, action = {index, element -> 
	.........
	index * element//闭包中最后一行表达式，计算后的结果，就是action函数的返回值
})

transform(numbers){index, element -> 
	.........
}

如何使用it
it并不是kotlin中的一个关键字（保留字）
it是在当一个高阶方法中Lambda表达式的参数只有一个对的时候可以使用it来使用此参数
it可表示为单个参数的隐式名称，是kotlin语言约定的

class  Person (var age:  Int){}

val persons  =  arrayOf(Person(1),Person(2),Person(3))

//这里的it就表示每一个person对象
persons.forEach{
	println(it.age)
}

//这里的it就表示每一个Int整数
val  numbers  =  arrayOf(1,2,3,4)

numbers.forEach{
	println(it)
}

九、条件控制

9.1、if表达式

带返回值if表达式
在kotlin中，if是一个表达式所以他会返回一个值，表达式的值为表达式作用域内最后一行的值。这一点和java是不同的，在java中if仅仅是语句。

//一般类似与java中的传统if的用法
fun  maxOf(a:  Int, b: Int): Int{
	if(a > b){
		return a
	}else{
		return b
	}
}

if表达式分支可以是代码块，也可以把作用域内最后一样表达式的值作为该分支的值：

fun  maxOf(a:Int, b:Int) = if(a > b){
	println(a)
	a//返回值为a 
}else{
	println(b)
	b//返回值为b
]

if表达式替代三目运算符
因为在kotlin中if表达式是带有返回值的，所以在kotlin中是不需要三目运算符（xxx?xxx:xxx）,因为if表达式这些都能做到。

fun  maxOf(a: Int, b: Int) = if(a > b)  a  else  b

9.2、when表达式

fun  eval(number: Number): String = when (){
	is Int -> "this is Int"
	is Double -> "this is Double"
	else  -> "无效的类型"
}

十、泛型

10.1、泛型接口

interface  Drinks<T>{
	fun taste(): T
	fun price(t:  T)
}

10.2、泛型类

abstract  class  Color<T> (var t:T){
	abstract fun ptintColor()
}

class   Blue{
	val color = "blue"
}

class  BlueColor(t: Blue): Color<Blue>(t){
	override fun printColor(){
		println("color:${t.color}")
	}
}

10.2、泛型方法

fun  <T>  fromJson(json: String, tClass: Class<T>): T?{
	val t: T? = tClass.newInstance()
	return t
}