Java转Kotlin，对语法、声明和一些符号的使用不是很清楚，特此记录
变量定义方式
val 只读变量，只能赋值一次
var 读写变量，可多次赋值
val a: Int = 1 // 立即赋值
val b = 2 // 自动推断出 `Int` 类型
val c: Int // 如果没有初始值类型不能省略
c = 3 // 明确赋值
理解自动类型推断
函数的定义
//带有两个 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 {
println("sum of $a and $b is ${a + b}")
}
//Unit 返回类型可以省略：
fun printSum(a: Int, b: Int) {
println("sum of $a and $b is ${a + b}")
}
模板字符串
在字符串中引用变量，或者在字符串中使用任意表达式
var a = 1
val s1 = "a is $a1"
a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a"
s2的输出结：a was 1, but now is 2
表达式
与Java类似，if(){}，if(){}else{}
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
fun maxOf(a: Int, b: Int) = if (a > b) a else b
两种写法都一样
空值检测和和使用
当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空
fun parseInt(str: String): Int? {
//表示该方法可以返回一个整型或者null
}
使用类型检测及自动类型转换
is 运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换：
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// `obj` 在该条件分支内自动转换成 `String`
return obj.length
}
// 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
return null
}
fun getStringLength(obj: Any): Int? {
// `obj` 在 `&&` 右边自动转换成 `String` 类型
if (obj is String && obj.length > 0) {
return obj.length
}
return null
}
emmmm.....这里的is和Java的instanceof是一个意思，其中is作用范围内自动转换数据类型比较Java方便了不少
if条件表达式
// 传统用法
var max = a
if (a < b) max = b
// With else
var max: Int
if (a > b) {
max = a
} else {
max = b
}
// 作为表达式
val max = if (a > b) a else b
//if的分支可以是代码块，最后的表达式作为该块的值
val max = if (a > b) {
print("Choose a")
a
} else {
print("Choose b")
b
}
与Java的if不同在于，Kotlin的if可以作为语句，也可一作为表达式，当它作为表达式时，每一个分支中最后一个表达式的值为分支的值
When表达式
Kotlin使用when取代了switch
when (x) {
1 -> print("x == 1")
2 -> print("x == 2")
else -> { // 注意这个块
print("x is neither 1 nor 2")
}
}
//多分支合并，和switch真的很像
when (x) {
0, 1 -> print("x == 0 or x == 1")
else -> print("otherwise")
}
//任意表达是作为分支
when (x) {
parseInt(s) -> print("s encodes x")
else -> print("s does not encode x")
}
//任意区间判断作为分支
when (x) {
in 1..10 -> print("x is in the range")
in validNumbers -> print("x is valid")
!in 10..20 -> print("x is outside the range")
else -> print("none of the above")
}
//Since Kotlin 1.3, it is possible to capture when subject in a variable using following syntax:
//强大到令人发指？？
fun Request.getBody() =
when (val response = executeRequest()) {
is Success -> response.body
is HttpError -> throw HttpException(response.status)
}
和if一样，when也可以作为表示式使用，但是需要注意：如果 when 作为一个表达式使用，则必须有 else 分支， 除非编译器能够检测出所有的可能情况都已经覆盖了
伴生对象
类内部的对象声明可以用 companion 关键字标记
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
该伴生对象的成员可通过只使用类名作为限定符来调用：
val instance = MyClass.create()
其自身所用的类的名称（不是另一个名称的限定符）可用作对该类的伴生对象 （无论是否命名）的引用
class MyClass1 {
companion object Named { }
}
val x = MyClass1
class MyClass2 {
companion object { }
}
val y = MyClass2
emmm...看起来很像Java的static，但是它不是static，请注意，即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口
interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
val f: Factory<MyClass> = MyClass
对象表达式和对象声明之间有一个重要的语义差别：
对象表达式是在使用他们的地方**立即**执行（及初始化）的
对象声明是在第一次被访问到时**延迟**初始化的
伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配
创建基本类和实例
不需要关键字new，直接类名称就能创建一个对象
val rectangle = Rectangle(5.0, 2.0) // 不需要“new”关键字
val triangle = Triangle(3.0, 4.0, 5.0)
主构造函数和次构造函数以及初始化
在 Kotlin 中的一个类可以有一个主构造函数以及一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（与可选的类型参数）后
class Person constructor(firstName: String) { ... }
//如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字
class Person(firstName: String) { ... }
//事实上，声明属性以及从主构造函数初始化属性，Kotlin 有简洁的语法：
class Person(val firstName: String, val lastName: String, var age: Int) { …… }
主构造函数不能包含任何的代码
初始化代码应该放在init{}中
在实例初始化期间，初始化块按照它们出现在类体中的顺序执行，与属性初始化器交织在一起
class InitOrderDemo(name: String) {
val firstProperty = "First property: $name".also(::println)
init {
println("First initializer block that prints ${name}")
}
val secondProperty = "Second property: ${name.length}".also(::println)
init {
println("Second initializer block that prints ${name.length}")
}
}
fun main() {
InitOrderDemo("hello")
}
First property: hello
First initializer block that prints hello
Second property: 5
Second initializer block that prints 5
如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是 public
这一点和Java挺像的
类也可以声明前缀有 constructor的次构造函数
class Person {
constructor(parent: Person) {
parent.children.add(this)
}
}
如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
属性、访问器、幕后字段、幕后属性
这里我看api文档是真的没有看懂。。。。。。感谢依然范特希西大佬
Kotlin 什么是幕后字段？
接口
使用关键字 interface 来定义接口
Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含实现。
需要注意实现多个接口冲突的覆盖
//接口的定义
interface MyInterface {
fun bar()
fun foo() {
// 可选的方法体
}
}
/**在接口中声明的属性要么是抽象的，要么提*供访问器的实现。
在接口中声明的属性不能有幕后字段（backingfield），
因此接口中声明的访问器不能引用它们*/
interface MyInterface {
val prop: Int // 抽象的
val propertyWithImplementation: String
get() = "foo"
fun foo() {
print(prop)
}
}
//接口冲突的覆盖和重写
class Child : MyInterface {
override val prop: Int = 29
}
interface A {
fun foo() { print("A") }
fun bar()
}
interface B {
fun foo() { print("B") }
fun bar() { print("bar") }
}
class C : A {
override fun bar() { print("bar") }
}
class D : A, B {
override fun foo() {
super<A>.foo()
super<B>.foo()
}
override fun bar() {
super<B>.bar()
}
}
接口里面不仅是声明方法，还可以定义方法体。。。但是和抽象类还是有很大的区别，与抽象类不同的是，接口无法保存状态。它可以有属性但必须声明为抽象或提供访问器实现。
访问修饰符
- 如果你不指定任何可见性修饰符，默认为
public，这意味着你的声明将随处可见； - 如果你声明为
private，它只会在声明它的文件内可见； - 如果你声明为
internal，它会在相同模块内随处可见； -
protected不适用于顶层声明。
对模块的理解：可见性修饰符 internal 意味着该成员只在相同模块内可见。更具体地说， 一个模块是编译在一起的一套 Kotlin 文件：
- 一个 IntelliJ IDEA 模块；
- 一个 Maven 项目；
- 一个 Gradle 源集（例外是 test 源集可以访问 main 的 internal 声明）；
- 一次 <kotlinc> Ant 任务执行所编译的一套文件。
扩展函数和扩展属性
声明一个扩展函数，我们需要用一个 接收者类型 也就是被扩展的类型来作为他的前缀。 下面代码为 MutableList<Int> 添加一个swap 函数：
fun MutableList<Int>.swap(index1: Int, index2: Int) {
val tmp = this[index1] // “this”对应该列表
this[index1] = this[index2]
this[index2] = tmp
}
与函数类似，Kotlin 支持扩展属性：
val <T> List<T>.lastIndex: Int
get() = size - 1
注意：由于扩展没有实际的将成员插入类中，因此对扩展属性来说幕后字段是无效的。这就是为什么扩展属性不能有初始化器。他们的行为只能由显式提供的 getters/setters 定义。
