共计 6454 个字符，预计需要花费 17 分钟才能阅读完成。
函数和变量
函数
/**
* 求最大值
* if 是表达式而不是语句，表达式有值，语句没有。* java 中所有的控制结构都是语句
* kotlin 中除了循环以外大多数控制结构都是表达式
*/
private fun max(a: Int, b: Int): Int {return if (a > b) a else b
}
/**
* 如果函数体写在花括号中，咱们说这个函数有代码块体。* 如果间接返回了一个表达式体，他就有表达式体。*/
fun max2(a: Int, b: Int): Int = if (a > b) a else b变量
可变变量和不可变变量
val – 不可变援用。相当于 Java 的 final 变量。
var – 可变援用。一般的 Java 变量。
在定义了 val 变量的代码块执行期间，val 变量只能进行惟一一次初始化。然而，如果编译器能确保只有惟一一条初始化语句被执行，能够依据条件应用不同的值来初始化它：
val message:String
if (CanPerformOperation()){
message = "Success"
// ...
} else{message = "Failed"}留神：只管 val 援用本身是不可变的，然而它指向的对象可能是可变的。例如：
val languages = arrayListOf("Java") // 申明不可变援用
languages.add("Kotlin") // 扭转援用指向的对象谬误：类型不匹配
var answer = 42
answer = "no answer"字符串模板
var a1 = 1
val s1 = "a is $a1"
a1 = 3
// 模板中的任意表达式
val s2 = "${s1.replace("is","was")},but no is $a1"
// a was 1, but now is 3
Log.e("s2", s2)和许多脚本语言一样，只须要在变量名称前加上 $，就能够在字符串字面值中援用局部变量。
援用 ”$” 须要本义“\$”
类和属性
类
在 Kotlin 中，public 是默认的可见性，所以你能省略它。
public class Person {
private final String name;
public Person(String name) {this.name = name;}
}—>
class Person(private val name: String)属性
class PersonProperty {
// 只读属性：生成一个字段和一个简略的 getter
val name: String = "kotlin_hahaha"
// 可写属性：一个字段、一个 getter 和一个 setter
var isMarried: Boolean = false
fun set() {isMarried = true}
}自定义拜访器
/**
* Created by jingbin on 2018/11/18.
* 自定义拜访器
* 也能够应用函数返回，实现和性能没有差异，惟一的差异是可读性
* 通常来说：* 如果形容的是类的特色(属性)，应该把它申明成属性。*/
class Rectangle(val height: Int, val width: Int) {
// 函数表达式 能够赋值
val isSquare: Boolean
// 申明属性的 getter
get() {return height == width}
}Kotlin 源码布局：目录和包
1. 把类和函数的申明放在包中，能够同级
class Rectangle(val height: Int, val width: Int) {
// 函数表达式 能够赋值
val isSquare: Boolean
// 申明属性的 getter
get() {return height == width}
}
fun createRandomRectangle(): Rectangle {val random = Random()
return Rectangle(random.nextInt(), random.nextInt())
}Kotlin 不辨别导入的是类还是函数，而且，它容许应用 import 关键字导入任何品种的申明。能够间接导入顶层函数的名称。
2. 导入其余包中的函数
// 导入函数的名称
import com.kotlin.jingbin.kotlinapp.classproperty.createRandomRectangle
// 导入其余包中的函数
LogUtil.e(createRandomRectangle().isSquare)包层级和 java 相似。
示意和解决抉择: 枚举和 ”when”
when 构造，java 中 switch 构造的替代品，然而更弱小。智能转换。
枚举
1. 申明简略的枚举类
enum class SimpleColor {RED, ORANGE}2. 申明一个带属性的枚举类
enum class Color(
// 申明枚举常量的属性
val r: Int, val g: Int, val b: Int) {
// 在每一个常量创立的时候指定属性值
RED(255, 0, 0),
ORANGE(255, 165, 0),
WELLOW(255, 255, 0),
GREEN(0, 255, 0),
BULE(0, 0, 255),
INDIGO(75, 0, 130),
VIILET(238, 130, 238);// 分号
fun rgb() = (r * 256 + g) * 256 + b
}3. 应用“when”解决枚举类
/**
* 应用 when 解决枚举类:
* 间接返回一个“when" 表达式
*/
fun getMnemonic(color: Color) = {when (color) {
RED -> "Richard"
ORANGE -> "Of"
WELLOW -> "Haha"
// 合并多个选项
BULE, GREEN -> "望穿"
VIILET, INDIGO -> "秋水"
}
}when
1、在 when 构造中应用任意对象
fun mix(c1: Color, c2: Color) = {
// when 表达式的实参能够是任何对象，它被查看是否与分支条件对等
when (setOf(c1, c2)) {setOf(Color.RED, Color.YELLOW) -> Color.ORANGE
setOf(Color.BLUE, Color.YELLOW) -> Color.GREEN
setOf(Color.BLUE, Color.VIOLET) -> Color.INDIGO
// 如果没有任何其余分支匹配这里就会执行
else -> throw Exception("Dirty color")
}
}2. 不带参数的 when
fun minOptimized(c1: Color, c2: Color) = {
// 没有实参传给 when
when {(c1 == Color.RED && c2 == Color.YELLOW) || (c2 == Color.RED && c1 == Color.YELLOW) -> Color.ORANGE
(c1 == Color.BLUE && c2 == Color.YELLOW) || (c2 == Color.BLUE && c1 == Color.YELLOW) -> Color.GREEN
(c1 == Color.BLUE && c2 == Color.VIOLET) || (c2 == Color.BLUE && c1 == Color.VIOLET) -> Color.INDIGO
else -> throw Exception("Dirty color")
}
}3、智能转换：合并类型检查和转换
// 3.1 表达式层次结构
interface Expr
// 简略的值对象类，只有一个属性 value，实现了 Expr 接口
class Num(val value: Int) : Expr
// sum 运算的实参能够是任何 Expr: Num 或者另一个 Sum
class Sum(val left: Expr, val right: Expr) : Expr
/**
* 3.2 应用 if 层叠对表达式求值
* 在 Kotlin 中，如果你查看过一个变量是某种类型，前面就不再须要转换它，能够就把它当作你查看过的类型应用。* 事实上编译器为你执行了类型转换，咱们把这种行为称为智能转换。* */
fun eval(e: Expr): Int {
// is - instanceOf
if (e is Num) {
// 显示的转换成类型 Num 是多余的
val num = e as Num
return num.value
}
if (e is Sum) {
// 变量 e 被智能转换了类型
return eval(e.left) + eval(e.right)
}
throw IllegalAccessException("Unknown expression")4、重构：用“when”代替“if”
/**
* Kotlin 中没有三元运算符，因为 if 有返回值
* 意味着: 能够用表达式语法重写 eval 函数，去掉 return 语句和花括号，应用 if 表达式作为函数体
*/
// 4.1 应用用返回值的 if 表达式
fun eval2(e: Expr): Int =
if (e is Num) {e.value} else if (e is Sum) {eval2(e.right) + eval2(e.left)
} else {throw IllegalAccessException("Unknown expression")
}
// 4.2 应用 when 代替 if 层叠
fun eval3(e: Expr): Int =
when (e) {
is Num -> e.value
is Sum -> eval3(e.right) + eval3(e.left)
else -> throw IllegalAccessException("Unknown expression")
}5、代码块作为“if”和“when”的分支
/**
* 一个函数要么具备不是代码块的表达式函数体，* 要么具备蕴含显示 return 语句的代码块函数体
*/
// 在分支中含有混合操作的 when
fun evalWithLogging(e: Expr): Int =
when (e) {
is Num -> {LogUtil.e("num: ${e.value}")
e.value
}
is Sum -> {val left = this.evalWithLogging(e.left)
val right = this.evalWithLogging(e.right)
LogUtil.e("Sum: $left + $right")
// 代码块中最初的表达式就是后果
left + right
}
else -> throw IllegalAccessException("Unknown expression")
}迭代事物:“when”循环和“for”循环
1、“while”循环
Kotlin 有 while 循环和 do-while 循环，他们的语法和 Java 中相应的循环没有什么区别
2、迭代数字：区间和数列
/**
* 区间：区间实质上就是两个值之间的距离，这两个值通常是数字：一个起始值，一个完结值。* 应用 .. 运算符来示意区间
* 数列：你能用整数区间做的最根本的事件就是循环迭代其中所有的值。* 如果你能迭代区间中所有的值，这样的区间被称作数列。* */
val oneToTen = 1..10
// 应用 when 实现 Fizz-Buzz 游戏
fun fizzBuzz(i: Int) = when {
i % 15 == 0 -> "FizzBuzz"
i % 3 == 0 -> "Fizz"
i % 5 == 0 -> "Buzz"
else -> "$i"
}
for (i in 1..100) {// LogUtil.e(fizzBuzz(i))
}
// 倒序 只计偶数 [应用 until 函数能够标识：不蕴含指定完结值的半闭合区间]
for (i in 100 downTo 0 step 2) {LogUtil.e(fizzBuzz(i))
}3、迭代 map
// 应用 TreeMap 让键排序
val binaryReps = TreeMap<Char, String>()
// 创立字符区间 包含 F
for (c in 'A'..'F') {
// 把 ASCII 码转换成二进制
val binaryString = Integer.toBinaryString(c.toInt())
binaryReps = binaryString
}
// 迭代 map，把键和值赋值给两个变量
for ((letter, binary) in binaryReps) {LogUtil.e("$letter = $binary")
}
// 迭代汇合时 应用下标
val list = arrayListOf("10", "11", "1001")
for ((index, element) in list.withIndex()) {LogUtil.e("$index = $element")
}4、应用“in”查看汇合和区间的成员
// 1. 应用 in 查看区间的成员
fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNoDigitic(c: Char) = c !in '0'..'9'
// 2. 用 in 查看作为 when 分支
fun recognize(c: Char) = when (c) {
in '0'..'9' -> "In's a digit!"in'a'..'z', in'A'..'Z'->"In's a letter!"
else -> "I don't know.."
}Kotlin 中的异样
// val 不能再赋值，相当于 final
val percentage = 0
if (percentage !in 0..100) {throw IllegalAccessException("A percentage value must be between 0 and 100: $percentage")
}
/**
* 和所有其余类一样，不用应用 new 关键字来创立异样实例。* 和 java 不同的是，Kotlin 中 throw 构造是一个表达式，能作为另一个表达式的一部分应用：*/
val number = 8
val percentage2 =
if (number in 0..100) {number} else {
// throw 是一个表达式
throw IllegalAccessException("A percentage value must be between 0 and 100: $percentage")
}
val bufferedReader = BufferedReader(StringReader("239"))1、try catch 和 finally
// 不用显式地晓得这个函数可能抛出的异样
fun readNumber(reader: BufferedReader): Int? {
try {val line = reader.readLine()
return Integer.parseInt(line)
// 异样类型在左边
} catch (e: NumberFormatException) {return null} finally {reader.close()
}
}2、try 作为表达式
fun readNumber2(reader: BufferedReader) {
val number = try {
// 没有任何异样产生时 应用这个值
Integer.parseInt(reader.readLine())
} catch (e: NumberFormatException) {
// return
// 产生异样时的状况下应用 null
null
}
}总结
fun 关键字用来申明函数。Val 关键字和 var 关键字别离用来申明只读变量和可变变量。
字符串模板帮组你防止繁琐的字符串拼接。在变量名称前加上 $ 前缀或者用 ${} 突围一个表达式，来把值注入到字符串中。
值对象类在 Kotlin 中以简洁的形式示意。
相熟的 if 当初是带返回值的表达式。
when 表达式相似于 Java 中的 switch 但性能更弱小。
在查看过变量具备某种类型之后不用显示地转换它的类型: 编译器应用智能转换字段帮你实现。
for、while、和 do-while 循环与 java 相似，然而 for 循环当初更加不便，特地是当你须要迭代 map 的时候，又或是迭代汇合须要下标的时候。
简洁的语法 1…5 会创立一个区间。区间和数列容许 Kotlin 在 for 循环中应用对立的语法和同一套形象机制，并且还能够应用 in 运算符和!in 运算符来查看值是否属于某个区间。
Kotlin 中的异样解决和 java 十分类似，除了 Kotlin 不要求你申明函数能够抛出异样。
正文完
