前言

對於kotlin，我是邊寫專案邊學的方式來學習的，這些都是在做專案的時候遇到的問題及擴充套件學習的時候記錄的，雖然有些內容不會涉及，但是我認為這種邊寫程式碼邊學習的方式特別有助於記憶，畢竟紙上得來終覺淺！

類和繼承

Kotlin較Java在繼承和實現上面簡便了很多；Java在繼承上要extend，實現介面要implement，
而Kotlin加個“:”就行了，之後的類和介面用逗號隔開

abstract class BaseActivity() : RxAppCompatActivity() ,IBaseView

構造：Kotlin有主構造和次構造之分

1. 主構造申明在類名的後面，若這個主構造被可見性修飾符或註解修飾，則這個主構造無法省略constructor修飾符

//無法省略constructor
class Customer public @Inject constructor(name: String) { ... }

...
//可以省略constructor
class Customer(name: String){}

在這個主建構函式中無法寫初始化程式碼，但可以宣告屬性（屬性可以有預設值，當然也可以在類體內初始化宣告），而屬性的初始化程式碼可以放到init()程式碼塊裡，而且在init程式碼塊裡可以使用在主構造裡宣告的屬性。

class Customer(name: String) {
    init {
        val customerKey = name.toUpperCase()
 

    }
}

次構造：類也可以宣告字首有 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)
    }
}

如果一個非抽象類沒有宣告任何（主或次）建構函式，它會有一個生成的 不帶引數的主建構函式。建構函式的可見性是 public。如果你不希望你的類 有一個公有建構函式，你需要宣告一個帶有非預設可見性的空的主建構函式：

class DontCreateMe private constructor () {
}

PS1 :在 JVM 上，如果主建構函式的所有的引數都有預設值，編譯器會生成 一個額外的無參建構函式，它將使用預設值。這使得 Kotlin 更易於使用像 Jackson 或者 JPA 這樣的通過無參建構函式建立類的例項的庫。

class Customer(val customerName: String = "")

• 建立例項物件
  
  1. Kotlin裡沒有new關鍵字，so我們可以直接Customer()來例項化物件

val invoice = Invoice()

val customer = Customer("Joe Smith")

• 繼承
  
  1. 如果該類有一個主建構函式，其基型別可以（並且必須） 用（基型別的）主建構函式引數就地初始化。
     如果類沒有主建構函式，那麼每個次建構函式必須 使用 super{：.keyword} 關鍵字初始化其基型別，或委託給另一個建構函式做到這一點。 注意，在這種情況下，不同的次建構函式可以呼叫基型別的不同的建構函式：

class MyView : View {
    constructor(ctx: Context) : super(ctx) {
    }

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) {
    }
}

而在Java程式碼裡我們自定義View，我們初始化構造會經常這樣做

public class EmptyErrLayout extends FrameLayout {

    public EmptyErrLayout(Context context) {
        this(context, null);
    }

    public EmptyErrLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.mContext = context;
        init(attrs);
    }
    ...
}

而在Kotlin裡可以這樣做

    constructor(context: Context):this (context,null){

    }

    constructor(context: Context,atts: AttributeSet?) : super (context,atts){
        init(context,atts)
    }

也可以

//這裡初始化了3個建構函式
class EmptyErrLayout @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = -1) : FrameLayout(context, attrs, defStyleAttr) {...}

@JvmOverloads：表示如果一個方法有N個引數，其中M個具有預設值，則會產生M個過載：第一個採用N-1個引數（除了最後一個引數之外的所有引數），第二個採用N-2個引數，同上。就像上面的例子，構造裡有3個引數，有兩個引數具有預設值（attrs: AttributeSet? = null, defStyleAttr: Int = -1），所以會產生這個建構函式的2個過載
* 覆蓋規則

覆蓋方法需要用到override關鍵字

open class Base {
  open fun v() {}
  fun nv() {}
}
class Derived() : Base() {
//Derived的子類可以再次覆蓋
  override fun v() {}
  //final override fun v() {}，表示子類禁止再次覆蓋
}

在 Kotlin 中，實現繼承由下述規則規定：如果一個類從它的直接超類繼承相同成員的多個實現， 它必須覆蓋這個成員並提供其自己的實現（也許用繼承來的其中之一）。 為了表示採用從哪個超型別繼承的實現，我們使用由尖括號中超型別名限定的 super，如 super：

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()
  }
}

重寫屬性以類似於覆蓋方法的方式工作。注意，可以在主建構函式中使用override關鍵字作為屬性宣告的一部分

open class Foo {
    open val x: Int get { ... }
}

class Bar1(override val x: Int) : Foo() {

}

• 抽象類：類和其中的某些成員可以宣告為 abstract，可以用一個抽象成員覆蓋一個非抽象的開放成員

open class Base {
  open fun f() {}
}

abstract class Derived : Base() {
  override abstract fun f()
}

• 密封類：密封類用來表示受限的類層次結構：當一個值為有限集中的 型別、而不能有任何其他型別時。在某種意義上，他們是列舉類的擴充套件：列舉型別的值集合 也是受限的，但每個列舉常量只存在一個例項，而密封類 的一個子類可以有可包含狀態的多個例項。

//要宣告一個密封類，需要在類名前面新增 sealed 修飾符。雖然密封類也可以 有子類，但是所以子類宣告都必須巢狀在這個密封類宣告內部。
sealed class Expr {
    class Const(val number: Double) : Expr()
    class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}

Anko

Anko is a Kotlin library which makes Android application development faster and easier. It makes your code clean and easy to read, and lets you forget about rough edges of the Android SDK for Java.

Anko是能使Android開發更快更容易的一個Kotlin庫，是你的程式碼清潔並且易讀，能讓人忘掉Android SDK for Java時的粗糙不友好

使用

//使用Anko所有的元件庫，包括commons，layouts，sqlite，coroutiness
dependencies {
    compile "org.jetbrains.anko:anko:$anko_version"
}

//也可以只用其中一部分，新增想要使用的那一部分依賴
dependencies {
    // Anko Commons
    compile "org.jetbrains.anko:anko-commons:$anko_version"

    // Anko Layouts
    compile "org.jetbrains.anko:anko-sdk25:$anko_version" // sdk15, sdk19, sdk21, sdk23 are also available
    compile "org.jetbrains.anko:anko-appcompat-v7:$anko_version"

    // Coroutine listeners for Anko Layouts
    compile "org.jetbrains.anko:anko-sdk25-coroutines:$anko_version"
    compile "org.jetbrains.anko:anko-appcompat-v7-coroutines:$anko_version"

    // Anko SQLite
    compile "org.jetbrains.anko:anko-sqlite:$anko_version"
}

組成

• Anko Commons: 一個用於Intent意圖，對話方塊，列印等方面的輕量級安全庫
• Anko Layouts: 一種快速和安全的方式來編寫動態Android佈局
• Anko SQLite：針對Android SQLite的查詢DSL和解析器集合;
• Anko Coroutines：基於kotlinx.corutines庫的實用程式。

Anko Commons

(1) intent

• 原始的意圖跳轉需要4至5行程式碼左右

val intent = Intent(this, SomeOtherActivity::class.java)
intent.putExtra("id", 5)
intent.setFlag(Intent.FLAG_ACTIVITY_SINGLE_TOP)
startActivity(intent)

• 而使用Anko以後只需要一行就可以搞定

//若沒有開啟Flag，直接把.singleTop()去掉就行，更加簡單
startActivity(intentFor<SomeOtherActivity>("id" to 5).singleTop())

(2) dialogs：使用還需新增以下依賴

// Anko Layouts
    compile "org.jetbrains.anko:anko-sdk25:$anko_version" // sdk15, sdk19, sdk21, sdk23 are also available

• toast使用

toast("Hi there!")
toast(R.string.message)
longToast("Wow, such a duration")

• 普通的對話方塊

alert("Hi, I'm Roy", "Have you tried turning it off and on again?") {
    yesButton { toast("Oh…") }
    noButton {}
}.show()

• appcompat中的Dialogs

//這是Activity中的方法
alert(Appcompat, "Some text message").show()
//Fagment中使用
activity.alert(Appcompat, "Some text message").show()

• 自定義dialog

alert {
    customView {

        editText()//自定義佈局
        //也可以這樣
        var  view = View.inflate(mContext,R.layout.fragment_news_main_layout,null)
        addView(view,ViewGroup.LayoutParams(100,100))
    }
}.show()

• 選擇對話方塊

 val countries = listOf("Russia", "USA", "Japan", "Australia")
            selector("Where are you from?", countries, { dialogInterface, i ->
                toast("So you're living in ${countries[i]}, right?")
            })

• 進度對話方塊

val dialog = progressDialog(message = "Please wait a bit…", title = "Fetching data")

(3) log

class SomeActivity : Activity(), AnkoLogger {
    private fun someMethod() {
        info("London is the capital of Great Britain")
        debug(5) // .toString() method will be executed
        warn(null) // "null" will be printed
    }
}

(4) 佈局相關
* anko能簡便地進行dip，sp設定和px-dip,sp之間的轉換

        button.sp(16)
        button.dip(26)
        button.px2dip(20)
        button.px2sp(80)

• applyRecursively()：如果佈局是一個ViewGroup，裡面有幾個相同的子view，此方法可以迭代對子View進行設定

verticalLayout {
    editText {
        hint = "Name"
    }
    editText {
        hint = "Password"
    }
}.applyRecursively { view -> when(view) {
    is EditText -> view.textSize = 20f
}}

Anko Layouts

(1).預設情況下，Android中的UI是使用XML編寫的。這在以下方面是不方便的：

• 這不是安全的;
• 它不是無效的;
• 它迫使您為每個佈局編寫幾乎相同的程式碼 ;
• 在裝置上解析XML浪費CPU時間和電池;
• 最重要的是，它不允許程式碼重用。

(2) DSL動態佈局

DSL使同樣的程式碼佈局邏輯較於之前的程式碼佈局邏輯容易閱讀，易於編寫，並且沒有執行時開銷

verticalLayout {
    val name = editText()
    button("Say Hello") {
        onClick { toast("Hello, ${name.text}!") }
    }
}

(3) AnkoComponent:使用提供的AnkoComponent介面，您還可以免費獲得DSL 佈局預覽功能。

配合Anko Support外掛可以在IDE佈局視窗中預覽用anko程式碼寫的佈局

class MyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        MyActivityUI().setContentView(this)
    }
}

class MyActivityUI : AnkoComponent<MyActivity> {
    override fun createView(ui: AnkoContext<MyActivity>) = ui.apply {
        verticalLayout {
            val name = editText()
            button("Say Hello") {
                onClick { ctx.toast("Hello, ${name.text}!") }
            }
        }
    }.view
}

將游標放在MyActivityUI宣告內的某個地方，開啟Anko Layout Preview工具視窗（“View”→“Tool Windows”→“Anko Layout Preview”），然後按重新整理。

這需要構建專案，所以在影象實際顯示之前可能需要一些時間。

該外掛還支援將佈局從XML格式轉換為Anko Layouts程式碼。開啟一個XML檔案並選擇“程式碼”→“轉換為安科佈局DSL”。您可以同時轉換多個XML佈局檔案。

(4) 包含標籤:很容易將XML佈局插入到DSL中。使用include()功能

include<View>(R.layout.something) {
    backgroundColor = Color.RED
}.lparams(width = matchParent) { margin = dip(12) }

(5) 介面監聽：

在Java中

button.setOnClickListener(object : OnClickListener {
    override fun onClick(v: View) {
        launch(UI) {
            val user = myRetrofitService.getUser().await()
            showUser(user)
        }
    }
})

使用Kotlin及Anko

button("Login") {
    onClick {
        val user = myRetrofitService.getUser().await()
        showUser(user)
    }
}

在kotlin中一個監聽有很多方法而沒使用anko，程式碼會是這樣

seekBar.setOnSeekBarChangeListener(object : OnSeekBarChangeListener {
    override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
        // Something
    }
    override fun onStartTrackingTouch(seekBar: SeekBar?) {
        // Just an empty method
    }
    override fun onStopTrackingTouch(seekBar: SeekBar) {
        // Another empty method
    }
})

而使用Anko

seekBar {
    onSeekBarChangeListener {
        onProgressChanged { seekBar, progress, fromUser ->
            // Something
        }
    }
}

(6) Layouts and LayoutParams

在xml裡寫佈局

<ImageView 
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginLeft="5dip"
    android:layout_marginTop="10dip"
    android:src="@drawable/something" />

在anko中，LayoutParams可以在View描述之後指定lparams()：如果指定lparams()，但省略width和/或height，它們的預設值都是wrapContent。

例舉一些屬性：（linearLayout的屬性，各佈局不同）

• horizontalMargin 設定左右邊距，
• verticalMargin 設定頂部和底部，
• margin 同時設定所有四個邊距。

linearLayout {
    button("Login") {
        textSize = 26f
    }.lparams(width = wrapContent) {
        horizontalMargin = dip(5)
        topMargin = dip(10)
    }
}

(7) 助手塊：如果您不需要為某些View設定任何屬性，則可以省略{}並寫入button(“Ok”)，甚至只是button()：

verticalLayout {
    button("Ok")
    button(R.string.cancel)
}

(8) 主題塊：可以很方便的設定view的屬性

verticalLayout {
    themedButton("Ok", theme = R.style.myTheme)
}

Anko SQLite

Anko提供了大量的擴充套件功能，以簡化與SQLite資料庫的工作，在專案中我還是會選擇第三方資料庫，這裡就跳過了，想看的請移步AnkoSQlite

Anko Coroutines：有兩個比較有用的方法

• asReference():非同步獲取例項Activity或Fragment可能會導致記憶體洩漏。
  asReference()在這種情況下使用：

suspend fun getData(): Data { ... }

class MyActivity : Activity() {
    fun loadAndShowData() {
    // Ref<T> uses the WeakReference under the hood
    val ref: Ref<MyActivity> = this.asReference()

    async(UI) {
        val data = getData()

        // Use ref() instead of [email protected]
        ref().showData()
    }
    }

    fun showData(data: Data) { ... }
}

• bg()：可以使用bg()在後臺執行緒上輕鬆執行程式碼：

fun getData(): Data { ... }
fun showData(data: Data) { ... }

async(UI) {
    val data: Deferred<Data> = bg {
    // Runs in background
    getData()
    }

    // This code is executed on the UI thread
    showData(data.await())
}

Github（剛開始寫，主要是把以前推薦的專案改成Kotlin版的）

拼搏在技術道路上的一隻小白And成長之路