這幾天花了點時間看了下kotlin，對我來說還是有一定難度的，慢慢填坑吧，以下是一部分筆記
有點亂，先湊合吧，沒有太多寫博客經驗，整體過一遍后，再統一整理
Kotlin是面向表達式語言
1. 密封類
使用密封類的最主要的的好處體現在你使用 when 表達式?？梢源_保聲明可以覆蓋到所有的情形，不需要再使用 else 情形
2.伴隨對象
你可以在你的類中聲明一個伴隨對象，這樣你就可以像 java 那樣把它當做靜態方法調用，只需要它的類名做一個識別就好了
- 伴生對象可以用于讓一個類即擁有實例化方法又有靜態方法。
- 伴生對象必須聲明在類中，且使用 companion object 關鍵字進行聲明。
- 伴生對象與類可以互相訪問各自的私有成員。
class TestCompanion{
companion object{
private val CODE="12123"
val URL="http://www.baidu.com"
}
val config ="$CODE , $URL"http://伴生對象與類可以互相訪問各自的私有成員
}
fun main(args: Array<String>) {
println("${TestCompanion().config}")
}
3.對象創建
可以用對象表達式創建匿名內部類，對于函數式java接口，可以使用帶接口類型前綴的lambda表達式創建它
4.main方法創建
快捷鍵：psvm或者main
5.擴展函數
Kotlin的擴展函數功能使得我們可以為現有的類添加新的函數，而不用修改原來的類。例如，我們可以為一個activity添加一個新函數，用于顯示一個toast
fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT){
Toast.makeText(this, message, duration).show()
}
我們可以在任何地方聲明這個函數（例如在一個utils文件中），然后像使用普通函數一樣在這個activity中使用它：
override fun onCreate(savedInstanceState: Bundle?) {
super<BaseActivity>.onCreate(savedInstanceState)
toast("This is onCreate!!")
}
聲明一個擴展函數很簡單，只需要在函數名之前添加指定的類名即可。在調用時，該函數會以導入的方式添加到這個類中。
//擴展類
//class C {
// fun foo() { println("number") }
//}
//
//fun C.foo(i:Int) { println("extention") }
//
//fun main(args: Array<String>) {
// C().foo()
// C().foo(1)
//}
//擴展類
//fun Context.showToast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
// Toast.makeText(this, message, duration).show()
//}
//擴展行為
//val Int.isOdd: Boolean
// get() = this and 1 == 1
class MyClass {
companion object {
val txt1="111"
}
}
//val MyClass.Companion.txt2 ="222"http://不能這么寫，沒有擴展成員屬性，擴展成員屬性是擴展方法的變體，要改成下面的寫法
//擴展類的成員
val MyClass.Companion.txt3: String
get() = "222"
fun main(args: Array<String>) {
println(MyClass.txt1)
println(MyClass.txt3)
}
6.函數式接口
lambda表達式需要“函數式接口”的支持
函數式接口：接口中只有一個抽象方法的接口，稱為函數式接口，可以用注解@FunctionalInterface修飾。可以檢查是否是函數式接口。
比如：
public interface OnClickListener {
void onClick(View v);
}
實現接口：
public interface OnClickListener {
void onClick(View v);
}
這種只有一個抽象方法的接口，就是函數式接口，如果主體只有一條語句，可省略{}、return、語句后面的;
view.setOnClickListener { toast("Click") }
7.我們同樣可以用 <TypeName>::<FunctionName> 的方式來引用類成員方法
8.高階函數，標準庫函數
let：主要用于處理可null對象（一般用于 變量?.let{ 語句塊 } 里作為安全調用的一種方法），比如
if (forecast != null) {
dataMapper.convertDayToDomain(forecast)
}else {
null
}
類似于
forecast?.let {
dataMapper.convertDayToDomain(it)
}
在forecaset對象不為null的情況下，將forecast作為參數，傳給convertDayToDomain方法，在只有一個參數的情況下，缺省為it
with：
val br = BufferedReader(FileReader("hello.txt"))
with(br){
var line: String?
while (true){
line = readLine()?: break
}
close()
}
其中的close和readline方法可以直接調用
而不用with的情況下為：
val br = BufferedReader(FileReader("hello.txt"))
var line: String?
while (true){
line = br.readLine()?: break
}
br.close()
apply：
它看起來于 with 很相似，但是是有點不同之處。 apply 可以避免創建builder的
方式來使用
比如：
class Options{
var scale: Float = 1f
var offsetX: Double = 0.0
var offsetY: Double = 0.0
var rotationX: Float = 0f
var rotationY: Float = 0f
}
假設我們有這么一個類，我們在操作一個地圖變換的時候需要傳入這個東西，告訴地圖該怎么變換。只需要修改部分屬性即可
mapView.animateChange(Options().apply {
//Options 的作用域
scale = 2f
rotationX = 180f
})
9.解構聲明（多重聲明）
所謂的解構聲明就是將一個對象解構(destructure)為多個變量，也就是意味著一個解構聲明會一次性創建多個變量.簡單的來說，一個解構聲明有兩個動作：
聲明了多個變量
將對象的屬性值賦值給相應的變量
比如下面的例子：
其實際意義是創建了三個變量name和age，sex，然后將person的屬性值”Jane”和20及"female"分別賦值給name和age,sex
在數據類中，不需要重新定義componentN()方法和加上operator關鍵字
data class TestComponentN(val name: String, val age: Int,val sex:String) {
}
fun main(args: Array<String>) {
val(name,age,sex)=TestComponentN("Jane", 20,"female")
println("$name,$age,$sex")
}
或者實現多重聲明只要在任意類內部定義了 componentN() 方法（N 為任意自然數）即可并加上 operator 關鍵字即可
class TestComponentN(val name: String, val age: Int,val sex:String) {
operator fun component1(): String {
return name
}
operator fun component2(): Int {
return age
}
operator fun component3():String{
return sex
}
}
fun main(args: Array<String>) {
val person = TestComponentN("Jane", 20,"female")
val (name, age) = person // 多重聲明
val pName = person.component1()
val pAge = person.component2()
val pSex =person.component3()
println("$pName,$pAge,$pSex")
println(person)
}
10.構造函數
- 構造器分為主構造器和輔助構造器
- 默認一個類總會有一個無參的主構造器
輔助構造器
輔助構造器名為 constructor
輔助構造器可以通過 this() 調用其它的輔助構造器，但是任何一個輔助構造器必須調用主構造器
//調用主構造器
constructor(name: String) : this(name, 0) {
}
constructor(age: Int) : this("Default Name", age) {
}
constructor() : this("Default Name") {
主構造器
主構造器直接定義在類名后
class Man(val name: String, val age: Int, private var from: String = "USA", description: String = "none") {
init {
println("sentences in primary constructor")
}
}
- 主構造器會執行類中 init 代碼塊中得所有語句，所以每實例化一個對象，上述例子都會打印一條語句
- 主構造器中可以使用默認參數，如上述的 from
- 主構造器中定義的參數可以是 val 也可以是 var，定義的參數會自動轉換為該類的成員屬性
- 主構造器中的參數也可以不加 var 或 val，此時如果類中的方法有用到該參數，則此參數轉換為成員屬性，否則會被忽略
- 主構造器也可以被聲明為 private，這樣就只能通過輔助構造器來實例化該對象
私有主構造器
class Woman private constructor(val name: String, val age: Int) {
constructor(name: String) : this(name, 0) {
}
}
11.多重實現
- 定義帶有相同方法的一個open類和一個接口，都帶有實現
open class TestSuperClass {
open fun onShow(){}
}
interface TestSuperInterface {
fun onShow(){}
}
一個子類去繼承他們
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
super<TestSuperClass>.onShow()
super<TestSuperInterface>.onShow()
}
}
- 定義帶有相同方法的一個open類和一個接口，open類實現，接口不實現
open class TestSuperClass {
open fun onShow(){}
}
interface TestSuperInterface {
fun onShow()
}
一個子類去繼承他們
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
super<TestSuperClass>.onShow()
}
}
- 定義帶有相同方法的一個抽象類和一個接口，接口實現和不實現都是如下
abstract class TestSuperClass {
abstract fun onShow()
}
interface TestSuperInterface {
fun onShow()
}
一個子類去繼承他們
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
}
}
總結：繼承的父類和實現的接口有相同的方法的，帶有實現的情況下，要在子類重寫的方法里使用super<Base>來表示，如果都沒有實現，則可以不用寫super<Base>
- 復寫規則
在 kotlin 中，實現繼承通常遵循如下規則：如果一個類從它的直接父類繼承了同一個成員的多個實現，那么它必須復寫這個成員并且提供自己的實現(或許只是直接用了繼承來的實現)。為表示使用父類中提供的方法我們用 super<Base>表示:
open class A {
open fun f () { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // 接口的成員變量默認是 open 的
fun b() { print("b") }
}
class C() : A() , B {
// 編譯器會要求復寫f()
override fun f() {
super<A>.f() // 調用 A.f()
super<B>.f() // 調用 B.f()
}
}
可以同時從 A 和 B 中繼承方法，而且 C 繼承 a() 或 b() 的實現沒有任何問題，因為它們都只有一個實現。但是 f() 有倆個實現，因此我們在 C 中必須復寫 f() 并且提供自己的實現來消除歧義。
12.when
when的分支，可以判斷：表達式，值，類型，范圍
fun main(args: Array<String>) {
//in 是閉合的，比如 in 10..20，會包含10和20
//when每個分支執行完后，會跳出，不會繼續執行判斷下一個分支
//匹配值和范圍
val x = 10
val y = when (x) {
1 -> 2
3 -> 4
// 3, 10 -> 30
in 10..20 -> 20
!in 20..30 -> 40
else -> 0
}
println("$y")
////匹配類型
// val x = 10
// when (x) {
// is Int -> println("long")
// else -> println("else")
// }
// //匹配參數
// fun add(x: Int): Int {
// return x + 1
// }
//
// val x = 10
// when (x) {
// add(x) -> println("x=" + x)
// else -> println("else")
// }
}
13.If
條件表達式
if/else 結構與 Java 類型，不過由于 Kotlin 面向表達式，所以可以直接將表達式賦給一個變量。
val s = if (x > 0) 1 else -1
這種方式可以給常量賦值，有點類似 Java 中的三元操作符，此時 s 的類型為 Int
如果是下面這種混合型的，s 的類型就為 Any
val s = if (x > 0) "a" else 65
因為 Kotlin 中表達式都必須有值，所以如果沒有 else 的話，需要引入 Unit 類
val s3: Any = if (x > 0) 1 else Unit
Kotlin 在 if 語句塊的最后可以自動返回最后一行表達式的值，而不需要寫 return 語句
//如果是表達式，則需要有一個else分支
val max = if (1 < 2) {
println("a")
2
} else {
println("b")
1
}
如果不是表達式則不需要else分支
if (a > b) {
println("Choose a")
a
}
14.Ranges
range 表達式是通過 rangeTo 函數形成的。rangeTo 函數擁有形如 .. 的操作符，該操作符是用 in 和 !in 實現的。 Range 可以對任何可比較的類型做操作，但對整數基本類型是優化過的。下面是些例子：
if (i in 1..10) {
println(i)
}
if (x !in 1.0..3.0) println(x)
if (str in "island".."isle") println(str)
數字的范圍有個附加的特性：它們可以迭代。編譯器會把它轉成類似于 java 的 for 循環的形式，且不用擔心越界：
for (i in 1..4) print(i) // prints "1234"
for (i in 4..1) print(i) // prints nothing
for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "
如果你想迭代數字并想反過來，這個相當簡單，你可以使用 downTo() 函數
for (i in 4 downTo 1) print(i)
也可以使用指定步數的迭代，這個用到 step()
for (i in 1..4 step 2) print(i) // prints "13"
for (i in 4 downTo 1 step 2) print(i) // prints "42"
for (i in 1.0..2.0 step 0.3) print("$i ") // prints "1.0 1.3 1.6 1.9 "
例子：
// Checking if value of comparable is in range. Optimized for number primitives.
if (i in 1..10) println(i)
if (x in 1.0..3.0) println(x)
if (str in "island".."isle") println(str)
// Iterating over arithmetical progression of numbers. Optimized for number primitives (as indexed for-loop in Java).
for (i in 1..4) print(i) // prints "1234"
for (i in 4..1) print(i) // prints nothing
for (i in 4 downTo 1) print(i) // prints "4321"
for (i in 1..4 step 2) print(i) // prints "13"
for (i in (1..4).reversed()) print(i) // prints "4321"
for (i in (1..4).reversed() step 2) print(i) // prints "42"
for (i in 4 downTo 1 step 2) print(i) // prints "42"
for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "
for (x in 1.0..2.0 step 0.3) print("$x ") // prints "1.0 1.3 1.6 1.9 "
for (x in 2.0 downTo 1.0 step 0.3) print("$x ") // prints "2.0 1.7 1.4 1.1 "
for (str in "island".."isle") println(str) // error: string range cannot be iterated over
