什么是Kotlin？
Kotlin是JetBrains开发的基于JVM的语言，JetBrains想必大家应该很熟悉了，他们创造了很多强大的IDE，android studio谷歌官方的android IDE就是基于Intellij，kotlin可以作为一个插件被用来开发android跟java比kotlin有什么好处？
1.它更容易表现，使用kotlin你可以少写很多代码，比如创建数据类等。
2.它更安全，在用Java开发时，大多数代码都是预防性的。为了不遇到非预期的NullPointerException，在使用之前，要不断的检测对象是否为空。与许多其它语言一样，因为需要使用安全调用运算符显式指明对象是否能够为空（null），所以Kotlin是空类型安全的
3.它是函数式的，Kotlin是基于面向对象的语言。但是就如其他很多现代的语言那样，它使用了很多函数式编程的概念，比如，使用lambda表达式来更方便地解决问题。其中一个很棒的特性就是Collections的处理方式。
4.它可以扩展函数，这意味着我们可以扩展类的更多的特性，甚至我们没有权限去访问这个类
kotlin官方文档传送门：https://kotlinlang.org/docs/reference/basic-syntax.html
1.入门
1.1 基本语法
1.1.1 定义包
包说明应该在源文件的顶部：
package my.demo
import java.util.*
// ...
*不要求包与目录匹配：源文件可以在系统中的任意地方。
1.12 定义函数
函数带有两个int类型参数，并且返回int类型值：
fun sum(a: Int, b: Int): Int {
return a + b
}
函数体可以是个表达式，并可以从中推断出返回值类型：
fun sum(a: Int, b: Int) = a + b
函数也可以返回无意义的值：
fun printSum(a: Int, b: Int): Unit {
print(a + b)
}
Unit返回值类型可以省略：
fun printSum(a: Int, b: Int) {
print(a + b)
}
1.1.3 定义局部变量
一次赋值（只读）局部变量：
val a: Int = 1
val b = 1 // 推断为Int类型
val c: Int // 如果没有初始化就要求说明类型
c = 1 // 明确赋值
可变变量：
var x = 5 // 推断为Int类型
x += 1
就像 Java 和 JavaScript, Kotlin 支持以下两种代码注释方式：
// This is an end-of-line comment
/* This is a block comment on multiple lines. */
1.1.4 使用字符串模板
fun main(args: Array<String>) {
if (args.size == 0) return
print("First argument: ${args[0]}")}
1.1.5 使用条件表达式
fun max(a: Int, b: Int): Int {
if (a > b)
return a
else
return b
}
使用if表达式：
fun max(a: Int, b: Int) = if (a > b) a else b
1.1.6使用nullable值检测空（null）值
当空值可能出现时，引用必须明确标记出可null值。
如果str没有保存一个整数，则返回null：
fun parseInt(str: String): Int? {
// ...
}
用函数返回可null值：
fun main(args: Array<String>) {
if (args.size < 2) {
print("Two integers expected")
return
}
val x = parseInt(args[0])
val y = parseInt(args[1])
// 由于x，y是null，所以使用x*y将产生错误。
if (x != null && y != null) {
// 在null检查后，x和y自动地配置（cast）到非可空
print(x * y)
}
}
或
// ...
if (x == null) {
print("Wrong number format in '${args[0]}'")
return
}
if (y == null) {
print("Wrong number format in '${args[1]}'")
return
}
// 在空检查后，x和y自动的匹配到非可null
print(x * y)
1.1.7 使用类型检查和自动类型转换
is操作符检查表达式是否类型实例。如果对不可变局部的变量或属性进行特定类型检查了，就不需要明确的类型转换。
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 在这个分支中，`obj`自动转换到`String`
return obj.length
}
// 在类型检查分支之外，`obj`仍然是`Any`类型
return null
}
或
fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在这个分支上，`obj`自动转换到`String`
return obj.length
}
甚至
fun getStringLength(obj: Any): Int? {
// 在`&&`右手边条件成立时，`obj`自动转换到`String`
if (obj is String && obj.length > 0)
return obj.length
return null
}
1.1.8 使用for循环
fun main(args: Array<String>) {
for (arg in args)
print(arg)
}
或
for (i in args.indices)
print(args[i])
1.1.9 使用while循环
fun main(args: Array<String>) {
var i = 0
while (i < args.size)
print(args[i++])
}
1.1.10 使用when表达式
fun cases(obj: Any) {
when (obj) {
1 -> print("One")
"Hello" -> print("Greeting")
is Long -> print("Long")
!is String -> print("Not a string")
else -> print("Unknown")
}
}
1.1.11 使用范围
使用in操作符检查一个数字是否在一个范围内：
if (x in 1..y-1)
print("OK")
检查一个数字是否超出范围：
if (x !in 0..array.lastIndex)
print("Out")
遍历整个范围：
for (x in 1..5)
print(x)
1.1.12 使用集合
遍历一个集合：
for (name in names)
println(name)
使用in操作符检查一个集合是否包含一个对象：
if (text in names) // 调用names.contains(text)
print("Yes")
使用Lambda表达式过滤和映射集合：
names
.filter { it.startsWith("A") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { print(it) }
1.2 习惯用语
这里随机收集了一些经常在Kotlin中使用的习惯用语，如果你有喜欢的，也可以贡献出来，和我们的合并。
1.21 创建DTO（POJO/POCO）
data class Customer(val name: String, val email: String)
提供带有下列功能的Customer类：
-所有属性的getter（和var的setter）
-equals()
-hashCode()
-toString()
-copy()
-component1()，component2()
1.2.2 函数参数的默认值
fun foo(a: Int = 0, b: String = "") { ... }
1.2.3 过滤列表
val positives = list.filter { x -> x > 0 }
或者更简洁的写法：
val positives = list.filter { it > 0 }
1.2.4 字符串插值
println("Name $name")
1.2.5 实例检查
when (x) {
is Foo -> ...
is Bar -> ...
else -> ...}
1.2.6 遍历键值对/列表对
for ((k, v) in map) {
println("$k -> $v")
}
k,v可以调用任何东西。
1.2.7 使用范围
for (i in 1..100) { ... }
for (x in 2..10) { ... }
1.2.8 只读列表
val list = listOf("a", "b", "c")
1.2.9 只读映键值对
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
1.2.10 访问键值对
println(map["key"])
map["key"] = value
1.2.11 Lazy属性
val p: String by lazy {
// 计算串
}
1.2.12 扩展函数
fun String.spaceToCamelCase() { ... }"
Convert this to camelcase".spaceToCamelCase()
1.2.13 创建单例模式
object Resource {
val name = "Name"
}
1.2.14 if非空简写
val files = File("Test").listFiles()
println(files?.size)
1.2.15 if非空和else简写
val files = File("Test").listFiles()
println(files?.size ?: "empty")
1.2.16 if空，执行语句
val data = ...
val email = data["email"] ?: throw IllegalStateException("Email is missing!")
1.2.17 if非空，执行语句
val data = ...
data?.let {
... // 如果非空执行这句代码
}
1.2.18 when语句返回值
fun transform(color: String): Int {
return when (color) {
"Red" -> 0
"Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color param value")
}
}
1.2.19 try/catch表达式
fun test() {
val result = try {
count()
} catch (e: ArithmeticException) {
throw IllegalStateException(e)
}
// 和result一起工作
}
1.2.20 if表达式
fun foo(param: Int) {
val result = if (param == 1) {
"one"
} else if (param == 2) {
"two"
} else {
"three"
}
}
1.2.21 返回Unit类型的方法生成器风格用法
fun arrayOfMinusOnes(size: Int): IntArray {
return IntArray(size).apply {
fill(-1) }
}
1.2.22 单一表达式函数
fun theAnswer() = 42
等价于
fun theAnswer(): Int {
return 42
}
这也可以与其他习惯用语有效的组合在一起，简化代码。如：与when表达式：
fun transform(color: String): Int = when (color) {
"Red" -> 0
"Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color param value")
}
1.2.23 在对象实例中（‘with’）调用多方法
class Turtle {
fun penDown()
fun penUp()
fun turn(degrees: Double)
fun forward(pixels: Double)
}
val myTurtle = Turtle()
with(myTurtle) { //绘制100px正方形
penDown()
for(i in 1..4) {
forward(100.0)
turn(90.0)
}
penUp()
}
1.2.24 Java7的try与资源
val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
println(reader.readText())
}
1.3 编码约定
这里是一些Kotlin开发语言的目前编码风格。
1.3.1 命名风格
如有疑问，默认的是Java编码约定，如：
——名称用驼峰式拼写法（并避免在名称中用下划线）
——以大写字母开始
——方法和属性名称以小写字母开始
——用4空格缩进
—— public函数应有文档化，使其能在Kotlin文档中显示
1.3.2 冒号
在用冒号分隔类型和子类型时，冒号前需要添加一个空格；而在分隔实例与类型时，冒号前就不需要空格：
interface Foo<out T : Any> : Bar {
fun foo(a: Int): T
}
1.3.3 Lambda表达式
在Lambda表达式中，空格应该用在花括号两边，以及将参数与函数体分隔的箭头两侧。如果可能，Lambda表达式应该在括号外传递。
list.filter { it > 10 }.map { element -> element * 2 }
在简写且没有嵌套的Lambda表达式中，推荐用it约定替代显式的参数申明。而在带有参数的嵌套Lambda表达式中，应该总是显式申明参数。
1.3.4 Unit
如果函数返回Unit类型，则返回类型应该省略：
1 fun foo() { // 这里省略了“: Unit”。
}
作者：Andrman
链接：https://www.jianshu.com/p/b70011dfba7d
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。