第二章（Kotlin基础）
基本要素：函数和变量
函数
函数定义规则
- 函数通过关键字
fun用来声明一个函数 - 参数的类型与函数返回类型写在它的名称后面，这和变量声明一样
- 函数可以定义在文件的最外层，不一定要把它放在类中
示例：
fun max(a: Int, b: Int): Int {
return if (a > b) a else b
}
>>> println(max(1,2)) //打印结果：2函数的声明以关键字 fun 开始，函数名称紧随其后：上面示例中函数名称是max，接下来是括号括起来的参数列表。参数列表后面跟着返回类型，它们之间用一个冒号隔开。如果不需要返回类型，则可以直接省略冒号及其后面的返回类型。
在Kotlin中，if 是有结果值的表达式。如上示例代码中函数的返回值 if (a > b) a else b ，它和Java中的三元运算符相似：(a>b) ? a : b。Kotlin中，if 是表达式，而不是语句。表达式和语句的区别在于，表达式有值，并且能作为另一个表达式的一部分使用；而语句总是包围着它的代码块中的顶层元素，并且没有自己的值。
表达式函数体
上面示例代码可以变得更简单。因为它的函数体是由单个表达式构成的，可以用这个表达式作为完整的函数体，并去掉花括号和return语句。如果函数体写在花括号中，我们说这个函数有代码块体。如果它直接返回了一个表达式，那么这个函数就有表达式体。
fun max(a: Int, b: Int): Int = if (a > b) a else b上面代码可以进一步简化，省掉返回类型：
fun max(a: Int, b: Int) = if (a > b) a else b为什么有些函数可以不声明返回类型？作为一门静态类型语言，Kotlin不是要求每个表达式都应该在编译器具有类型吗？事实上，每个变量和表达式都有类型，每个函数都有返回类型。但是对表达式函数体来说，编译器会分析作为函数体的表达式，并把它的类型作为函数的返回类型。这也是Kotlin的类型推导。（注意：只有表达式体函数的返回类型可以省略。对于有返回值的代码块函数体，必须显示地写出返回类型和return语句。）
变量
Kotlin中声明变量的关键字有两个：
- val（来自value）— 不可变引用。使用val声明的变量不能在初始化之后再次赋值。它对应的是Java的final变量。
- var（来自variable）— 可变引用。使用var声明的变量的值可以被改变。这种声明对应的是普通（非final）的Java变量。
默认情况下，应该尽可能地使用val关键字来声明所有的Kotlin变量，仅在必要的时候换成var。
注意：尽管val引用自身是不可变的，但是它指向的对象可能是可变的。例如：下面这段代码是完全有效的：
val languages = arrayListOf("Java") //声明不可变引用
languages.add("Kotlin") //改变引用指向的对象字符串模板（$）
Kotlin中的字符串模板相当于Java中的“+”号，示例：
val name = "World"
//下面两行代码是等效的
println("Hello "+name)
println("Hello $name")
>>> 打印结果：Hello World类和属性
类
Kotlin中类声明比Java中更简洁。我们以一个简单的JavaBean类来对比，以下两个例子完全等效，只是分别用Java与Kotlin来声明。
/* Java */
public class Person {
private final String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}/* Kotlin */
class Person(val name: String)属性
在Java中，字段和其访问器（getter，setter）的组合常常被叫做属性。而在Kotlin中，属性是头等的语言特性，完全代替了字段和访问器方法（getter和setter方法），在类中声明一个属性和声明一个变量一样：使用val和var关键字。声明成val的属性是只读的（只有getter方法），声明成var属性是可变的（包含getter和setter方法）。
示例：
class Person(val name: String, var age: Int) //Person类声明了一个只读的name属性与可变的age属性
fun main(args: Array<String>) {
val person = Person("xiaochao",24)
// person.name = "xiaochao" //编译不通过，val修饰，是只读的（只有getter，没有setter），不可修改
person.age = 25//编译通过，var修饰，是可变的，这里赋值是调用setter方法
println("name=${person.name},age=${person.age}")//这里取值是调用getter方法
｝
>>> 打印结果：name=xiaochao,age=25上面代码演示了在构造函数中声明属性及调用，如果想直接在Person类文件中声明属性也是一样的。
class Person {
val name: String = "xiaochao"
var age: Int = 0
}
fun main(args: Array<String>) {
val person = Person()
// person.name = "hello world" //编译不通过，name是val修饰的，是只读的，不可修改
person.age = 18
println("name=${person.name},age=${person.age}")
｝
>>> 打印结果：name=xiaochao,age=18自定义访问器（getter、setter）
假设你声明这样一个矩形，它能判断自己是否是正方形。不需要一个单独的字段来存储这个信息（是否是正方形），因为可以随时通过检查矩形的长宽是否相等来判断：
class Rectangle(val height:Int,val width:Int){
// val isSquare:Boolean
// //自定义getter方法，同理也可以自定义setter方法，不过要自定义setter方法则属性必须声明为var类型
// get() {
// return height==width
// }
//可以使用表达式函数体来简化
val isSquare:Boolean
get() = height==width
}
fun main(args: Array<String>) {
val rectangle = Rectangle(20,20)
println(rectangle.isSquare)
}
>>> 打印结果：true枚举和“when”
声明枚举类
和Java一样，枚举并不是值的列表：可以给枚举声明属性和方法。
enum class Color(val r: Int, val g: Int, val b: Int) {
//下面每一个颜色都表示一个Color枚举类常量
RED(255, 0, 0), YELLOW(255, 255, 0),
ORANGE(255,165,0),INDIGO(75,0,130),
GREEN(0, 255, 0), BLUE(0, 0, 255);//这里必须要有分号
fun rgb() = (r * 256 + g) * 256 + b//给枚举类定义一个方法
}
fun main(args: Array<String>) {
println(Color.BLUE.rgb())
}
>>> 打印结果：255when的基本使用
fun getMnemonic(color:Color){
when(color){
Color.RED -> println("red")
Color.BLUE -> {
println("blue")
}
Color.GREEN,Color.YELLOW -> println("green or yellow")
}
}when当作表达式函数体
使用when当作表达式函数体时，when中的分支都必须在最后加else判断（在这里判断条件Color是枚举类型，所以这里将枚举类型的所有常量声明完整也可以省略else，其他情况下则必须加else）：
fun getMnemonic2(color:Color) =
when(color){
Color.RED -> "RED"
Color.BLUE -> {
"BLUE"
}
Color.GREEN,Color.YELLOW -> "GREEN or YELLOW"
//如果不加else则编译无法通过，因为Color下还有ORANGE与INDIGO没判断
else -> "other"
}不带参数的when
如果没有给when表达式提供参数，那么分支条件就是任意的布尔表达式。
fun mixOptimized(color1:Color,color2:Color) =
when{
(color1==Color.RED && color2==Color.YELLOW) ||
(color1==Color.YELLOW && color2==Color.RED) -> Color.ORANGE
(color1==Color.YELLOW && color2==Color.BLUE) ||
(color1==Color.BLUE && color2==Color.YELLOW) -> Color.GREEN
else -> throw Exception("Dirty color")
}智能转换：合并类型检查和转换
如果你检查过一个变量是某种类型，后面就不再需要转换它，可以就把它当作你检查过的类型使用。事实上编译器为你执行了类型转换，我们把这种行为称为智能转换，智能转换只在变量经过 is 检查之后且不再发生变化的情况下有效。例子：
private val view:View? = null
fun test(){
if(view is TextView){
view.setText("这里view已经可以当成TextView使用")
}
}智能转换通过 is关键字来表示，这里的 is相当于Java中的 instanceof
强制转换则通过 as关键字来表示，例子：
private val view:View? = null
fun test(){
val textview = view as TextView
textview.setText("强制转换")
}for循环
for循环基本使用
for (i in 0..10) { //从0开始遍历到10
println(i)//0,1,2,3,4,5,6,7,8,9,10
}上面我们看到了最简单的for循环的使用方式，Kotlin中的for循环是用区间来表示，使用.. 运算符来表示区间，上面的for循环就表示0到10这个区间。除了区间这个概念，Kotlin中的for循环还涉及到步长这个概念。步长简单理解就是每次循环区间的大小，默认是1，如上面的代码，没有显示指定步长，默认就是从0到10这个区间以1的步长递增循环，接下来我们指定步长为2,那么输出的结果就会是0,2,4,6,8,10。以2的步长去递增。看下面代码：
for (i in 0..10 step 2) {
println(i)//0,2,4,6,8,10
}如果我们想从10递减到0那么该怎么写呢？看下面代码：
for (i in 10 downTo 0) { //这里我们同样可以设置步长
println(i)
}上面我们通过0..10知道了for循环的区间，这样会打印出0到10，接下来我们再看一种Kotlin中for循环写法：
for (i in 0 until 10){
println(i)//0,1,2,3,4,5,6,7,8,9
}注意上面until这种写法与0..10的区别在与until这种写法只会打印0到9，而0..10则会打印0到10。
迭代数字：区间和数列
区间本质上就是两个值之间的间隔，这两个值通常是数字：一个起始值，一个结束值。使用 .. 运算符来表示区间：
val oneToTen = 1..10注意Kotlin的区间是包含的或者闭合的，意味着第二个值始终是区间的一部分。
你能用整数区间做的最基本的事情就是循环迭代其中所有的值。如果你能迭代区间中所有的值，这样的区间被称作数列。
for循环迭代map
val maps = TreeMap<Char, String>()
for (c in 'A'..'F') {
val value = Integer.toBinaryString(c.toInt() )//A-F的二进制值
maps[c] = value //c为键，value为值
}
for ((key, value) in maps) {
println("$key = $value")
}
//打印结果
A = 1000001
B = 1000010
C = 1000011
D = 1000100
E = 1000101
F = 1000110使用in关键字来检查集合和区间的成员
例如，我想检查5这个数字是否在0,10之间，代码如下：
fun main(args: Array<String>) {
println(testIn(5))//true
}
fun testIn(i:Int):Boolean{
//这里in可以取反，!in
return i in 0..10
}再举个例子，比如我想检查某个List列表中是否包含某个值，也可以通过in来检查，代码如下：
fun main(args: Array<String>) {
println(testIn("xiaochao"))//true
}
fun testIn(name: String): Boolean {
val listdata = ArrayList<String>()
listdata.add("xiaochao")
listdata.add("xiaowang")
listdata.add("laowang")
return name in listdata
}Kotlin中的异常
Kotlin中异常与Java中并没有太大区别。但是当Kotlin在使用 try catch 时，却可以将其作为表达式。
fun testException(str:String):Int{
val number = try{
Integer.parseInt(str)
}catch (e:NumberFormatException){
0
}
return number
}
fun main(args: Array<String>) {
println(testException("55")) //打印结果：55
println(testException("hello world")) //打印结果：0
}总结
-
fun关键字用来声明函数。val关键字和var关键字分别用来声明只读变量和可变变量。 - 字符串模板帮组你避免繁琐的字符串链接。在变量名称前加上
$前缀或者用${ }包围一个表达式，来把值注入到字符串中。 - 熟悉的
if是带返回值的表达式。 -
when表达式类似于Java中的switch但功能更强大。 - 在检查过变量具有某种类型之后不必显示地转换它的类型：编译器使用智能转换自动帮你完成。
- for、while、do-while循环与Java类似，但是for循环现在更加方便，特别是当你需要迭代map的时候，又或是迭代集合需要下标的时候。
- 简洁的语法1..5会创建一个区间。区间和数列允许Kotlin在for循环中使用统一的语法和同一套抽象机制，并且还可以使用
in云算法和!in运算符来检查值是否属于某个区间。 - Kotlin中的异常处理和Java非常相似，除了Kotlin不要求你声明函数可以抛出的异常（即不需要在函数后显示的 throws Exception）。