google宣布Kotlin作為andorid一級開發語言有一段時間了。在這段時間，我也在新的模塊上嘗試使用了kotlin進行開發，經過這一段時間的開發，我覺得在開發中使用kotlin是個很棒的選擇。
使用Kotlin的很容易，只需要進行幾步簡單的設置
-
android studio安裝下面兩個插件，其中Parcelable Code Generator不是必要的，主要用于序列化Parcelable，所示最好也安裝一下
image.png - 在
build.grade文件中添加依賴compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" - 在
build.grade文件中應用插件
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
通過以上的幾步，就可以開始我們的kotlin之旅了
1. 變量
在kotlin中變量使用var、val來表示，var表示可變變量，val表示不可變變量（相當于java當中的final）。如下所示
var name: String="ivy"
val age=12
kotlin定義變量時可以不指定變量類型，kotlin會根據你的賦值進行判斷該變量的類型，如例子所示會自動把age設置為Int類型，這里需要注意的是如果需要把變量賦值為Null(var name:String?="ivy")，需要加上？號才表示該變量可以為Null
2. 函數
kotlin方法的使用和java的類似，當沒有返回值的時候可以不寫，或者寫Unit
fun add(one: Int , two: Int) : Int{
return one+two
}
同時，函數還可以為每個參數設置默認值，這樣就可以避免多參數時定義多個方法,如下所示。
fun add(one:Int , two: Int ,three: Int=0){
//當參時沒有設置three的值時，three默認為0
}
這里有一個比較重要的概念。在kotlin當中函數是一級公民，即函數也是可以作為變量、返回值來使用的，如下所示
val add=fun (a: Int,b: Int){ println(a+b) }
add(1,2)
可能有的小伙伴就要說，這有什么卵用，我直接寫個方法，然后調用方法不就好了。是，如果只是簡單的調用是可以，那如果把函數作為方法的參數，這在java就無法做到了，而把函數作為參數能給我們帶來很大的方便，代碼看起來也更有邏輯性。如下所示
fun judgeHasMoney(doHappyThing: ()->Unit){
if (User.hasMoney()){
println("no money")
}else{
doHappyThing()
}
}
judgeHasMoney(BuyCompany())
judgeHasMoney(BuyPhone())
這就可以非常方便對能否能購買東西進行判斷，代碼少了，看上去也更有邏輯性。還有很多函數作為一級公民好處的實例，這里就不一一演示了，for循環、List、Map之類的太量操作符也是利用了這個特性進行實現。
3. 類的定義
class Boy(var name: String) : Person, interface{
init {
}
constructor(name:String,age: Int) : this(name) {
}
}
如例子所示，這就是kotlin中類的定義。無論是接口還是父類都是寫在冒號后面，用逗號分割，不再使用extends和implement。在kotlin中，分主構造函數和次構造函數，主構造函數就是類名Boy括號后面參數（如果想在類中直接使用構造函數的參數，需要加上val或者var）,次構造函數必須以constructor開頭，并且必須繼承調用主構造函數，所有的構造函數初始化后都會調用 Init{}方法，所以可以在Init()當中進行初始化操作。
在kotlin類中還有一些需要注意的：
- 1 在
Kotlin中，所有的方法都是不開放的（即子類無法重寫），如果子類要重寫父類的方法，需要在父類方法前面加上open - 2 如果繼承了兩個類中含有共同的方法，可以通過
super<類名>.方法名進行調用
class SuperMan(): Person(), Boy {
override fun run(){
super<Person>.run()
}
}
- 3 生成一個對象很簡單，直接
var girl=Girl()就可以，不再需要new一個妹子了
4. 空安全
在android開發中，空指針異常是最讓我們頭痛的也是導致應用崩潰率最高的問題。我們之前已經提到過，在kotlin中，在定義變量的時候就需要指定變量是否允許為空，這在一定程度上幫助我們減少空指針異常的可能性。但是還是不能完成避免空指針的出現，因為有些變量就是可空可不為空，當我們調用時，就有可能因為沒有做出判斷而出現空指針異常。kotlin也考慮到這個問題，所以在調用可為空的變量時，kotlin會要求我們加上？號，如下所示：
var school?=Class()
school?.grade?.class?student?.size()
如果我們想查找一個班的學生的人數，可以使用以上的方法，就可以獲取到學生的人數，當中的任何一個變量為空，后面的都不會繼續執行，這個鏈式調用就會返回null，避免任何一個階段為空出現NPE的問題。
5. List、Map的使用
在開發中，List和Map是我們最經常用到的類了。在kotlin中，List和Map也分為可變和不可變
var a = listOf(4)
var b = mutableListOf<String>()
var c = mapOf(Pair("3","4"))
var d = mutableMapOf<String,String>()
不可變的概念即和數組類似，只能夠改變每個位置的值，不能減少或者增加size
遍歷List有三種比較常用的方法
for(position in list.indices){
//每一個位置遍歷
}
for(str in list){
//每一個對象遍歷
}
for((position,str) in list.withIndex()){
//每一個位置和對象遍歷
}
遍歷Map比較常用的方法
for((key,value) in map){
}
kotlin的遍歷方法相對于java來說，還是很方便和實用的，但是！！！這不是最好用的！！最方便的是kotlin加入了一系列的操作符，使用Rx的小伙伴應該知道操作符有多棒。下面我就來演示一個例子，查找一個班里面年齡超過15歲的女生名字
java：看我的
for(student in students){
if(student.getSex()=="girl"&&student.getAge>15){
System.out.println(student.getName())
}
}
kotlin:小樣，看我的
students.filter{ it.sex=="girl" }
.filter{ it.age>15 }
.forEach{ print(student.name") }
是不是整個邏輯一目了然。但是，有些喜歡挑事的小伙伴可能就會說我覺得上面那個沒有很方便啊。我就喜歡上面那個。
好，那我就再給你舉兩個例子，你寫java代碼對比一下
- 1 15歲以上的女生是否有單身的！！！
students.filter { it.sex=="girl" }
.filter { it.age >15 }
.any{ !it.hasBoyFriend }
- 2 把15歲以上的女生年齡排序一下，打印出名字
students.filter { it.sex=="girl" }
.filter { it.age >15 }
.sortedBy { it.age }
.forEach { print(it.name) }
還有其它更棒，更好用的操作符，大家可以查看源碼。操作符可以大大提高開發速度，我在這里就不一一展示了（Map一樣有各種好用的操作符）
6. 流程控制
- 1
for語句的使用和java的類似，也包含了很多的操作符（和List類似）
for(i in 0 .. 100){
//0到100
}
for(i in 0 until 100){
//0到99
}
for (i in 100 downTo 0){
//100到0
}
- 2 在
java中，when語句中的case判斷只能是int，后來也支持了String，但是支持的類型還是很少。而且，只支持相同的類型，這樣就導致我們在開發中遇到復雜業務的時候，往往還需要在case中編寫if語句，這就給我帶來了很大的麻煩，而且代碼也比較混亂。但是kotlin的when語句很好的解決了這個問題。當when(x)有參數時，可以在參數中添加參數所屬類型的表達式。當when不帶參數時，可以添加各種表達式和方法，而不只是常量。
when (x) {
1 -> print("x == 1")
2,3 -> print("x == 2 or 3")
in 10..20 -> print("x is in the range")
else -> { // 注意這個塊
print("x is shen me gui")
}
}
var x:Int=0
when {
x==1 -> print("x == 1")
x in 10..20 -> print("x is in the range")
isBigNum(x) -> print("big")
else -> { // 注意這個塊
print("x is shen me gui")
}
}
- 3 在循環中，
java經常會用到break跳出循環，那kotlin是怎么實現的呢？請看例子，可以通過直接標簽的形式，回到指定位置，和java類似
tag@ for (i in 0..100) {
for (j in 0..100) {
if (i==j)
break@tag
}
}
7. 數據類
相信java的小伙伴從剛開始學java的時候就知道建立對象先寫個javabean，要寫get、set方法，比較的時候要重寫equal等方法，copy對象的時候要實現Cloneable接口。非常的麻煩，而且容易出錯。kotlin給出了一種簡單的方法
data class person(var age: int ,var name: String)
編繹器會自動使該Bean擁有以下特性：
- 1
get/set方法，當var改為val時，則沒有set方法 - 2
equals()/hashCode() - 3
toString()方法，格式person(age=18, name=ivy) - 4
copy()拷貝功能
8. 靜態變量、靜態方法
在kotlin中，沒有靜態方法的說法。都是通過伴生對象companion object來實現。使用靜態變量可以通過
const val staticName: String ="123"來實現（必須寫在類的頂部），一般用于無法確定歸屬的全局變量。但是最好使用伴生對象，對靜態變量歸類到所屬的類中。使用方法如下
class TestActivity{
companion object{
var username: String="ivy"
fun startActivity(context: Context):Unit{
val intent=Intent(context,KotlinHomeActivity::class.java)
context.startActivity(intent)
}
}
}
//調用
TestActivity.companion.startActivity(context)
伴生對象并不是真正意義上的靜態變量，本質也是一個對象
kotlin的單例寫法如下：
companion object{
fun getUser() : String{
return UserManager.user
}
private object UserManager{
val user=User()
}
}
9. 泛型
kotlin的泛型和java的類似，有以下幾點不同：
- 1 可以通過
T::class來獲取到T的具體類型 - 2
kotlin不支持通配符，即class person(? extends T) - 3 聲明處型變,即如下所示，只控制一個類中只有返回值才有可能需要校驗
T泛型，輸入是不會出現T泛型這種情況的（同時也有<in T>表示輸入）
abstract class Person<out T> {
abstract fun getSomeThing(): T
}
那么這樣有什么好處呢？看下面的代碼，這在java中不可行，是禁止這樣操作的。但是實際上，這樣是極為安全的
fun demo(strs: Person<String>) {
val objects: Person<Any> = strs
// ...
}
10. 代理
在kotlin當中可以對類和屬性進行代理
- 1 代理類（代理模式）
interface Person{
fun run()
}
class SuperMan() : Person{
override fun run() { print("i can fly") }
}
class Delegate(person: Person) : Person by person
fun main(args: Array<String>) {
val superMan = SuperMan()
Delegate(b).run() //打印 i can fly"
}
- 2 代理屬性，這是一個超級棒的功能，這里面和很多功能，這里我就介紹兩種
- 代理屬性
class Example {
var p: String by Delegate()
}
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return 'someThing"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("value'")
}
}
這個這可以在屬性獲取值和設置值的時候進行代理攔截，這個功能非常強大，例子如下 （代碼來源《Kotlin for Android Developer》）
class Preference<T>(val context: Context, val name: String, val default: T, val prefName: String = "default") : ReadWriteProperty<Any?, T> {
val prefs by lazy { context.getSharedPreferences(prefName, Context.MODE_PRIVATE) }
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return findPreference(name, default)
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
putPreference(name, value)
}
private fun <U> findPreference(name: String, default: U): U = with(prefs) {
val res: Any = when (default) {
is Long -> getLong(name, default)
is String -> getString(name, default)
is Int -> getInt(name, default)
is Boolean -> getBoolean(name, default)
is Float -> getFloat(name, default)
else -> throw IllegalArgumentException("This type can be saved into Preferences")
}
res as U
}
private fun <U> putPreference(name: String, value: U) = with(prefs.edit()) {
when (value) {
is Long -> putLong(name, value)
is String -> putString(name, value)
is Int -> putInt(name, value)
is Boolean -> putBoolean(name, value)
is Float -> putFloat(name, value)
else -> throw IllegalArgumentException("This type can be saved into Preferences")
}.apply()
}
}
當使用get方法時，會自動從sharePreference當中取，當給變量設值的時候會自動給把值存儲更新到sharePreference當中，可以像使用正常變量一樣使用sharePreference，使用方法如下：
class TestActivity : Activity(){
var version: Int by Preference(this, "version", 1.0.0)
}
- 可觀察屬性（
observable properties）
這個的作用，是當一個變量的值改變時，會進行通知，并告知舊值和新值。這個在開發中就非常實用了，比如定位功能，可以判斷定位的值是否發生變化，設置了定位信息，從而允許接下來的邏輯。
var locationCity: String by Delegates.observable("<no location>") {
prop, old, new ->
println("$old -> $new")
}
在開發中我們通常會通過 一個helper工具類來實現對某個對象的屬性值來進行控制。比如，當設置的年齡小于15歲的時候不允許更改，在這里使用Delegates.observable()就很方便了，而且邏輯看起來更加清晰明了。
也可以通過Delegates.vetoable()來控制變量的值是否可以修改(使用方法和 Delegates.observable()一樣)
- 3 屬性延遲
在開發中，我們經常會做一件事件，當一個對象需要使用時才初始化，不使用不初始化。這在kotlin中就很方便實現，當第一次使用時才初始化，隨后直接使用初始化后的值(該方法默認是同步的，如果不需要同步可以加上LazyThreadSafetyMode.NONE)
val user:Student by lazy {
Student("girl",18,true)
}
11. 擴展
kotlin的擴展是我最喜歡的一個新功能了，之前開發ios的時候就喜歡得不得了，現在在Android中終于可以使用了。在java世界中每個開發者都有一堆自己的工具類，如StringUtils、ViewUtils、ToastUtils等等。但是這樣會有一個問題，比如View的一個工具類，誰知道你的工具類名叫什么?就算知道，也很麻煩。比如設置paddlingLeft的一般套路
ViewUtils.setPaddingLeft(view,paddingLeft)
但是通過擴展，就完成清晰明了，和調系統方法沒有任務區別，首先編寫一個擴展
fun View.setPaddingLeft(paddingLeftNew: Int){
setPadding(paddingLeftNew,paddingTop,paddingRight,paddingBottom)
}
//調用：
view.paddingLeft=12
是不是很贊！！！擴展功能非常強大，我們可以把各種工具類進行簡化。比如Toast
fun Any.toast(text: String){
Toast.makeText(applicationContext,text,Toast.LENGTH_SHORT).show()
}
當然擴展不止于此，腦洞有多大，擴展就有多強！
12. 和ButterKnife say goodbye
每個Android的開發者曾經都為findViewById()而煩惱不已，直到后來ButterKnife的出現。但是ButterKnife是不是就完美了，并不是！當布局復雜的時候，activity里面前面一堆View的變量。那有沒有辦法去掉這一堆變量，有！
import kotlinx.android.synthetic.main.activity_kotlin.*
class Activity{
btnCommint.text="xxx"
}
activity_kotlin.xml
<Button
android:id="@+id/btnCommit"
android:layout_width="match_parent"
android:layout_height="40dp"
android:text="i am kotlin button"/>
只需要把import布局文件，就可以直接把Id當成變量來使用。輕輕松松和ButterKnife say goodbye。
13. 一些小細節
- 1
Class對象的獲取
View::class.java //在kotlin中獲取class對象傳遞到java代碼中
View::javaClass //在kotlin中獲取class對象傳遞到kotlin代碼中
- 2
this的使用
class KotlinActivity{
fun isBigNum(num: Int){
}
inner class Person{
open fun run(){
this@Person.run()
this@KotlinActivity.isBigNum(3)
}
}
}
- 3
SmartCast（類型轉換）
java:
TextView view=(TextView)findViewById(R.id.tv)
kotlin:
var view=findViewById(R.id.tv) as TextView
- 4 字符串拼接
java:
System.out.println("username:"+user.getUsername()+"--age:"+age)
kotlin:
print("username:${user.username}--age:$age)
- 5 三目運算符
在kotlin當中沒有三目運算符，實現三目運算符的方法：
var maxValue= if(a>b) a else b
