kotlin官方文档-1.0入门

什么是Kotlin？

 

图片发自简书App

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
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。