《Kotin 编程思想·实战》

《Kotlin极简教程》正式上架：

点击这里 > 去京东商城购买阅读

点击这里 > 去天猫商城购买阅读

1 JVM语言家族概览

1.1 编程语言简史

1.2 程序执行的三种方式

1.2.1 编译执行

1.2.2 解释执行

1.2.3 虚拟机执行

1.3 JVM概述

1.3.1 Java源代码编译执行过程

1.3.2 Java Class文件简介

1.3.3 JVM字节码执行过程

1.4 JVM语言家族

1.4.1 Scala

1.4.2 Groovy

1.4.3 Clojure

1.4.4 Kotlin

1.4.5 Xtend

Xtend是Eclipse推出的一个新的JVM语言，并无意替代Java，而是以己之长补Java之短，精简代码，无类型，改进可读和维护。Eclipse Xtend可以编译成可读的Java代码，类似CoffeeScript之于Javascript。

静态类型

特点

扩展方法：加强封闭类型的新功能。

Lambda表达式：匿名函数文字简洁的语法。

将lambda表达式编译成匿名内部类。

运算符重载：让库更表达。

强大的交换机的表达：类型与隐式类型转换开关。

多个调度：即多态方法调用。

模板表达式：智能空间处理。

报表：一切都是表达式。

属性：访问和定义getter和setter方法的速记法。

局部类型推理：很少需要写下类型签名了。

全面支持Java的泛型：包括所有的一致性和转换规则。

类型系统：Xtend的静态类型是不错的，因为它允许更好的静态分析和基于类型信息的更好的工具。然而，缺点是额外的复杂性

2 Kotlin简介

2.1 kotlin简史

2.2 快速学习工具

2.2.1 云端IDE

2.2.2 本地命令行环境搭建

2.2.3 Kotlin REPL

2.2.4 使用IntelliJ IDEA

2.2.5 使用Gradle构建工程

3 快速开始：HelloWorld

3.1 命令行的HelloWorld

3.2 应用程序版HelloWorld

3.3 Web RESTFul HelloWorld

3.4 Android版的HelloWorld

3.5 JavaScript(Canvas) 版HelloWorld

4 kotlinc编译过程分析

4.1 kotlinc执行原理分析

4.2 kotlin代码执行过程

4.3 Kt.class与Java.class区别

5 语言基础

5.1 基础语法

5.1.1 包（package）

package打包与import导包

源文件可以不需要匹配目录和包，源文件可以放在任何文件目录

如果没有任何包声明的话，则当中的代码都属于默认包，导入时包名即为函数名！
比如：import shortToast

另外你还可以在导入类的时候为类设置一个别名，比如：
import java.util.Date as d

直接在文件中写一堆fun方法！

kotlin中因为可以使用扩展方法，所以可以连class和interface都不写，

5.1.2 变量

变量作用域

声明变量

val

var

val定义常量和var定义变量，默认都是private的，比如
定义：val a =123, var b = 321，打开生成的.class文件可以看到：

private私有，且默认写了公有的getter和setter方法。

5.1.3 表达式

range

return

throw

三元表达式

Lambda表达式

this表达式

super表达式

5.1.4 代码块

5.1.5 分支控制流

if表达式

判断结构(条件表达式)

Java int max = a>b?a:b

Kotlin: val max = if (a>b) a else b

在if语句块的最后可以自动返回最后一行表达式的值，而不需要写return

fun ifExample(x: Int, y: Int) {
val result = if (x >= y) {
println("Condition ok.")
true
} else {
println("Condition else.")
false
}
println("Result $result")
}

when表达式

fun whenExample(userType: Int) {
when (userType) {
0 -> println("Registered user")
1 -> print("Administrator")
else -> {
println("Unknown")
}
}
}

fun whenExample2(userType: Int) {
when (userType) {
0, 1 -> println("Welcome user.")
else -> println("Permission denied.")
}
}

fun whenExample3(userType: Int) {
when (userType) {
filterUserType(userType) -> {
println("Subtype ok")
whenExample2(userType)
}
else -> print("Subtype not ok")
}
}

fun filterUserType(userType: Int): Int {
if (userType >= 0 && userType < 2) {
return userType;
}
return -1
}

fun whenExample4(x: Int) {
val from = 0
val to = 100
when (x) {
in from..to -> println("PRECISE")
in (from / 2)..(to / 2) -> print("VERY PRECISE")
50 -> print("STRAIGHT IN TARGET")
else -> print("MISSED")
}
}

fun whenExample5(fullName: String) {
val isJohn = when (fullName) {
is String -> fullName.startsWith("John ")
else -> false
}
}

fun whenExample6(fullName: String) {
when {
fullName.length == 0 -> println("Please enter your name.")
fullName.substring(0, 2).equals("X ") -> println("Hello Mr. X")
fullName.startsWith("John ") && !fullName.endsWith(" Smith") -> println("Hello John!")
fullName.endsWith(" Smith") -> println("Hello agent Smith.")
else -> println("Only secret agents allowed!")
}
}

5.1.6 循环

while循环

for循环

Kotlin中的while与do-while，break，continue与Java中的类似，不过Kotlin中多了个好玩的东西：
Ranages，包含与范围有关的函数操作符

Ranages

在范围内与不在范围内

fun main(array: Array) {
for ((index, value) in array.withIndex()) {
println("[ value ]")
}

val a1 = 1
val a2 = 2
val b1 = if(a1 in 0..9) true else false
val b2 = if(a2 !in 10..20 ) true else false
println(b1)
println(b2)

val str1 = "Hello"
val str2 = "Hello,Wolrd"
if(str1 in str2) println(str1 + " in " + str2) else println(str1 + " is not in " + str2)
if(str1 in "Hello".."Kotlin") println(str1 + " in " + "Hello".."Kotlin") else println(str1 + " is not in " + "Hello".."Kotlin")

}

顺序遍历

val arr = Array(10,{n->n})
arr.forEach(::print)
println()
arr.forEach{
    it->print(it.toString() + " ")
}
println()
for(e in arr) print(e)
println()
for(i in 0..arr.lastIndex) print(arr[i].toString() + " ")
println()

你也可以调lastIndex来获得最后的下标，写成if(i in 0..array.lastIndex)
如果你不想顺着遍历，想反过来遍历，可以利用downTo (递减)关键字，从最大值到最小值递减！
for(i in 9 downTo 5) print(arr[i])
println()
可能你还想隔着遍历，比如只遍历：10,7,4,1，可以用 step (步长)关键字！后面跟着的是步长，
比如你可以写成小数0.1这样也行，示例：
for(i in 9 downTo 3 step 3) print(arr[i])

倒序遍历

5.1.7 代码注释

5.1.8 异常

Kotlin中所有的Exception都继承了Throwable，含有一个message且未经检查。
这表示不会强迫我们在任何地方使用try/catch，而Java中如果某个方法抛出
了Exception，就需要用try-catch包围代码块。

Kotlin抛出异常和try-catch-finally和Java中的类似！但是Kotlin中throw和try都是表达式，
意味着他们可以赋值给某个变量，这一点在处理边界问题的时候很有用！代码示例：

class ExceptionExamples {

fun exceptionExmple() {
    try {
        // do something ...
    } catch (e: KotlinNullPointerException) {
        // handle exception
    } finally {
        // do something ...
    }
}

// Try / Catch is expression!
fun exceptionExample2(): Int {
    return try {
        // do something
        0
    } catch (e: KotlinNullPointerException) {
        // handle exception
        -1
    }
}

}

5.2 标识符

5.2.1 修饰符

访问权限

public：默认，总是可见

internal：同模块可见

private：声明范围与同模块的子作用域可见

protected：类似于private，但对子类也可见

5.2.2 关键保留字

var：定义变量

val：定义常量

fun：定义方法

Unit：默认方法返回值，类似于Java中的void，可以理解成返回没什么用的值

vararg：可变参数

如果是可变参数的话，可以使用 vararg 关键字修饰

fun sum(vararg args: Int) {
var sum = 0
for (x in args) {
sum += x
}
println("Sum: $sum")
}

fun trySum(){
sum(1, 3, 6, 10, 1, 2, 3, 4)
}

$：字符串模板(取值)

位运算符：or(按位或)，and(按位与)，shl(有符号左移)，shr(有符号右移)，

ushr(无符号右移)，xor(按位异或)，inv(按位取反)

in：在某个范围中

downTo：递减，循环时可用，每次减1

step：步长，循环时可用，设置每次循环的增加或减少的量

when：Kotlin中增强版的switch，可以匹配值，范围，类型与参数

is：判断类型用，类似于Java中的instanceof()

5.2.3 运算符

5.2.4 赋值符

5.3 函数

5.3.1 main函数

5.3.2 定义函数

使用 fun 关键字来声明

如果没有访问控制符修饰的fun默认是public final的！

返回值：Unit

扩展函数

直接定义在文件中，而不需要依赖于任何的类的函数

成员函数

写在class或object中的函数

5.3.3 包级函数

5.3.4 Lambda表达式

// lambda写法1
val runnable3 = Runnable { ->
println("I'm a Lambda")
}

// lambda写法2
val runnable4 = { println("I'm a Lambda") }
Thread(runnable4).start()

函数式接口（functional interface）

只包含一个抽象方法的接口

Java标准库中的java.lang.Runnable和java.util.Comparator

public void runThread() {
new Thread(new Runnable() {
public void run() {
System.out.println("Run!");
}
}).start();
}

public void runThreadUseLambda() {
new Thread(() -> {
System.out.println("Run!");
}).start();
}

Collections.sort(list, (x, y) -> y - x);

List input = Arrays.asList(new String[] {"apple", "orange", "pear"});
input.forEach((v) -> System.out.println(v));
input.forEach(System.out::println);

5.3.5 闭包

5.3.6 匿名函数

// new 一个线程
// 匿名类写法
val runnable1 = object : Runnable{
override fun run() {
println("I'm an anonymous class")
}
}

// 函数写法, 略像js
val runnable2 = fun (){
println("I'm a function")
}

5.4 特色功能

5.4.1 函数拓展和属性拓展(Extensions)

fun main(args: Array) {
val list = listOf("1", "2", "3", "4")

// 函数拓展
list.myForEach { println(it) }

// 属性拓展
println("last: ${list.lastItem}")

}

/**

拓展 List 类, 加一个自定义的遍历方法
*/
fun List.myForEach(doTask: (T) -> Unit){
for(item in this)
doTask(item)
}

/**

拓展 List 类, 加一个自定义的长度属性
*/
val List.lastItem: T
get() = get(size - 1)

// 输出：
1
2
3
4
last: 4

class Employee {
fun name(): String {
return "Employee name"
}
}

class ExtendedFunctionalityExample(val e: Employee) {
// We extended Employee class with function that does not exist in original class!
fun Employee.age(): Int {
return 25
}

fun tryExtendedEmployeeExample() {
    println("Name: ${e.name()}, Age: ${e.age()}")
}

}

5.4.2 属性代理

以懒加载为例，lazySum可能需要复杂的运算，我们把它代理给lazy。可以看到，只有第一次加载进行了计算，之后都是直接取值，提高了效率。

val lazySum: Int by lazy {
println("begin compute lazySum ...")
var sum = 0
for (i in 0..100)
sum += i
println("lazySum computed!\n")
sum // 返回计算结果
}

fun main(args: Array) {
println(lazySum)
println(lazySum)
}

// 输出：
begin compute lazySum ...
lazySum computed!

5050
5050

5.4.3 委托（Delegate）

5.4.4 空指针安全

空对象检查Null Check

var mNullable: String? = null
var mNonNull: String = "mNonNull"

fun testNull(){
println("testNull: ")
println(mNullable?.length)
println(mNonNull.length)
println()
}

// 输出：
testNull:
null
8

// java 风格，判空
if(mNullable != null)
mNullable.length

// kotlin 语法糖，判空(推荐)
mNullable?.length

null check实现原理简析

空类型强转为非空类型

var user: User? = getUser()
user!!.name = "Jack"

5.4.5 Lazy Evaluation

class UsesLazy {
val myLazyValue: String by lazy {
println("I am initializing this lazy value!")
"My lazy value!"
}
}

fun useLazy(){
val usesLazy: UsesLazy = UsesLazy()
val a: String = usesLazy.myLazyValue
val b: String = usesLazy.myLazyValue
val c: String = usesLazy.myLazyValue
}

6 类型系统

6.1 编译时类型与运行时类型

6.2 根类型Any

对象相等性

6.3 基本类型（Primitive Types）

6.3.1 Number: 包含整型与浮点型等

kotlin.Byte

kotlin.Short

kotlin.Int

kotlin.Long

kotlin.Float

kotlin.Double

6.3.2 Char: 字符类型(Character)

6.3.3 Boolean: 布尔类型

6.3.4 String: 字符串类型

字符串常量

字符串函数

字符串模板

转义字符串

Kotlin居然没有自动转型

for(i in 0..arr.lastIndex) print(arr[i] + " ") 不能自动转型，这样写代码多麻烦

for(i in 0..arr.lastIndex) print(arr[i].toString() + " ")

6.3.5 Array: 数组类型

原生数组类型

创建数组

定长数组：val fixedSizeArray = arrayOfNulls(10)
空数组： val empty = emptyArray()
装箱操作：val arr = arrayOf(1, 2, 3) //还有其他比如IntArrayOf，BooleanArrayOf等
闭包初始化：

val arr = Array(100, {num -> num})
for(i in 0..99) println(arr[i])

访问数组

使用[]

[]访问数组元素在这里实际上是进行了操作符的
重载，调用的其实是Array类的getter和setter方法，但是编译成字节码的时候会进行优化，
变成直接访问数组的内存地址，所以并不会造成性能损失！

遍历数组

foreach遍历

for(e in arr) println(e)

根据下标遍历

for(i in arr.indices) println(arr[i])

indices代表下标！范围：(0 <= indices < 数组size)

6.4 特殊类型

kotlin.Any

kotlin.Nothing

kotlin.Unit

kotlin.KClass

6.5 可空类型（Nullable Types）

6.6 函数类型（ Functional Types）

闭包类型

6.7 类型检测

is运算符

as运算符

6.8 类型转换

6.9 类型别名typealias

6.10 泛型

fun genericFunctionsExample(x: T){
println("Value: $x")
}

fun tryGenericFunctionsExampe(){
genericFunctionsExample(5)
genericFunctionsExample("Some word!")
genericFunctionsExample('c')
genericFunctionsExample(5.55)
}

7 面向对象编程（OOP）

7.1 面向对象思想

7.2 类与继承

7.2.1 类

类的横向分类

抽象类

接口类

枚举类

注解类

静态类与伴生对象

sealed 密封类

sealed class SuperEnum {
class Human(val race: String) : SuperEnum()
class Animal(val specie: String, val legsCount: Int) : SuperEnum()
object Bacteria : SuperEnum()
}

fun trySuperEnum(superEnum: SuperEnum): String = when (superEnum) {
is SuperEnum.Human -> "Human {superEnum.specie} with ${superEnum.legsCount} legs."
is SuperEnum.Bacteria -> "Some micro organism ..."
}

data 数据类

data class Person(val name: String, val age: Int){}

fun tryDataClassCopying(){
val p = Person("John Smith", 1985)
val p2 = p.copy()
val p3 = p.copy(age = 1990)
val p4 = p.copy("John Doe")

println(p)
println(p2)
println(p3)
println(p4)

}

data class Employee(val name: String, val age: Int) {}

data class Worker(val name: String = "Unknown", val age: Int = 1970) {}

类的纵向组合

嵌套类Nested Class

内部类Inner Class

匿名内部类Inner Class

声明类

类修饰符

构造函数

主构造函数

次构造函数

类的属性（数据结构）

类的行为（算法函数）

7.2.2 接口与抽象类

接口的默认实现

interface A {
fun foo() { println("A") } // 默认实现, 打印"A"
fun bar()
}

interface B {
fun foo() { println("B") }
fun bar() { println("bar") }
}

// 多继承时，显式指定 super.foo() 以去冲突
class D : A, B {
override fun foo() {
super .foo()
super.foo()
}

《Kotin 编程思想·实战》

《Kotin 编程思想·实战》

《Kotlin极简教程》正式上架：

点击这里 > 去京东商城购买阅读

点击这里 > 去天猫商城购买阅读

Kotlin 开发者社区

你可能感兴趣的:(《Kotin 编程思想·实战》)