kotlin是一種運行在java虛擬機上的靜態編程語言，2011年，JetBrains推出了kotlin項目，2016年2月15日正式發布了第一個官方穩定版本V1.0，2017年在google I/O大會上，google正式宣布kotlin成為Android官方開發語言。

配置

在我們的AndroidStudio開發工具中，要想使用Kotlin這個優秀的開發語言，我們需要安裝插件，直接在安裝插件界面搜索Kotlin然后安裝。之后再gradle文件增加如下配置

apply plugin:'kotlin-android'apply plugin:'kotlin-android-extensions'dependencies {
   compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"}

項目gradle文件

buildscript {
   ext.kotlin_version = '1.1.1'   repositories {
       jcenter()
   }
   dependencies {
       classpath 'com.android.tools.build:gradle:2.3.1'       classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"       // NOTE: Do not place your application dependencies here; they belong
       // in the individual module build.gradle files
   }
}

完成上面的配置后，我們就可以愉快的玩耍了。

Kotlin示例

首先我們還和以前一樣，創建一個Android項目，自動創建一個Activity之后我們再創建一個java類

public class MainActivity extends AppCompatActivity {

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
       setSupportActionBar(toolbar);

       FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
       fab.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View view) {
               Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                       .setAction("Action", null).show();
           }
       });
   }

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {
       // Inflate the menu; this adds items to the action bar if it is present.
       getMenuInflater().inflate(R.menu.menu_main, menu);
       return true;
   }

   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
       // Handle action bar item clicks here. The action bar will
       // automatically handle clicks on the Home/Up button, so long
       // as you specify a parent activity in AndroidManifest.xml.
       int id = item.getItemId();

       //noinspection SimplifiableIfStatement
       if (id == R.id.action_settings) {
           return true;
       }

       return super.onOptionsItemSelected(item);
   }
}
public class Test {
   private static String str = null;

   public static void main(String[] args) {
       str = "Code4Android";
       System.out.println(str);
   }
}

那上面的代碼如果用kotlin實現是什么樣子呢。盡管現在我們還不能寫出Kotlin代碼，但是在安裝插件后AS中提供了自動轉換Kotlin代碼的功能

轉換后的Kotlin代碼

class MainActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
       val toolbar = findViewById(R.id.toolbar) as Toolbar
       setSupportActionBar(toolbar)

       val fab = findViewById(R.id.fab) as FloatingActionButton
       fab.setOnClickListener { view ->
           Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                   .setAction("Action", null).show()
       }
   }

   override fun onCreateOptionsMenu(menu: Menu): Boolean {
       // Inflate the menu; this adds items to the action bar if it is present.
       menuInflater.inflate(R.menu.menu_main, menu)
       return true   }

   override fun onOptionsItemSelected(item: MenuItem): Boolean {
       val id = item.itemId
       if (id == R.id.action_settings) {
           return true       }
       return super.onOptionsItemSelected(item)
   }
}

object Test {
   private var str: String? = null

   @JvmStatic fun main(args: Array) {
       str = "Code4Android"       println(str)
   }
}

注意：AS提供的java代碼自動轉換功能，我們不要輕易使用，更不要轉化我們成熟的項目，如果需要就需要我們自己去重構實現。否則會有意向不到的事情等著你，畢竟轉換不是那么智能。上面的代碼只是讓你先簡單熟悉下Kotlin代碼時什么樣子的，接下來我們先去學習一下Kotlin的基本語法。相信很容易上手。

Hello World!

我們由一個簡單的”Hello World!”輸出程序開始。與新建java文件類似，如下圖，我們選擇Kotlin File/Class.創建一個Kotlin文件。

package com.learnrecord

/**
*Created by Code4Android on 2017/4/21.
*/

var str: String = ""fun main(args: Array) {
   str = "Hello World!"   println(str)
}

上述代碼就是簡單的輸出一個字符串“Hello World”，package 后面跟的是包名，我們看出了和java文件的區別，在包名后面沒有以分號“；”結尾。在Kotlin語法中，語句結尾都不在有分號“；”。

在Kotlin中變量聲明有兩種類型，val修飾變量是只讀變量即只能賦值一次，再次賦值時就會編譯錯誤，如果我們需要多次修改值就需要使用var。在上面的 var str: String = “”中，str是變量名，：String,表明該變量是String類型變量，后面就是賦值語句。我們也可以這樣寫var str= “”省略了生命變量類型，它可以根據賦的值而自動推斷出類型。如果我們使用下面賦值語句str=null，發現null是不能賦值的，這就是Kotlin的特性，如果我們想賦值null,可以修改為 var str:String?=””。 fun就是函數生命，而這個main函數就和我們java中的main方法一樣，是程序執行的入口。println就是一個打印輸出。

Kotlin聲明類型

在Kotlin中有如下幾種Number類型，他們都是繼承自Number抽象類。

Float（32位）,Double（64）,Int（32）,Byte（8）,Short（16），Long(64,類型用大寫L，如12L)，Any（任意類型），數組類型Array 根據傳入的泛型數據自動匹配類型，Kotlin還提供了指定類型的Array,如ByteArray，CharArray，ShortArray，IntArray，LongArray，FloatArray，DoubleArray，BooleanArray。在數組類型中都提供了get(index),set(index,value)及iterator（）方法供我們使用。

   val iArray: IntArray = intArrayOf(1, 2, 3)
   val sArray: Array = Array(3, { i -> i.toString() })
   val anyArray: Array = arrayOf(1, "2", 3.0, 4.1f) // 可將類型進行混排放入同一個數組中
   val lArray: LongArray = longArrayOf(1L, 2L, 3L)

函數

我們先來實現一個簡單的數值求和的函數，通用實現方法如下

   fun sum(a: Int, b: Int): Int {
       return a + b
   }

傳入兩個Int型數值，sum是函數名，括號后面的：Int表示該函數返回Int的值，函數體中對兩個數字相加并返回。在Kotlin中表達式也可以作為函數體，編譯器可以推斷出返回類型，可以簡化為

fun sum(a: Int, b: Int) = a + b

為了更好理解表達式可以作為函數體，我們可以創建一個函數獲取兩個數的最大值，如下：

fun max1(a:Int,b:Int)=if (a>b) a else b

需要注意的是若if后有多個表達式,如下

   fun max1(a:Int,b:Int)= if (a > b) {
       println(a)
       a
   } else {
       println(b)
       //如果我們將println(b)放到b的下面,運行會返回kotlin.Unit為無類型，
      //返回值總是最后一個表達式的返回值或值
       b
   }
   println(max1(1,3))

括號中的表達式順序決定了返回的值及其類型。

如果我們的方法體僅僅是打印字符串，并不返回值則

   fun printInt(a: Int): Unit {
       println(a)
   }

Unit就類似我們java中的void，即沒有返回值，此時我們可以省略

   fun printInt(a: Int) {
       println(a)
   }

對于函數體，方法或者類等和java一樣也有一些修飾符，如下

• abstract //抽象類標示
• final //標示類不可繼承，默認屬性
• enum //標示類為枚舉
• open //類可繼承，類默認是final的
• annotation //注解類
• private //僅在同一個文件中可見
• protected //同一個文件中或子類可見,不可修飾類
• public //所有調用的地方都可見
• internal //同一個模塊中可見,若類不加修飾符，則默認為該修飾符，作用域為同一個應用的所有模塊，起保護作用，防止模塊外被調用。

操作符

直接上代碼如下

   //操作符  shl 下面對Int和Long
   var a: Int = 4
   var shl: Int = a shl (1)  //Java中的左移運算符 >
   var ushr: Int = a ushr (3) //無符號右移，高位補0 >>>
   var and: Int = 2 and (4)   //按位與操作 &
   var or: Int = 2 or (4) //按位或操作 |
   var xor: Int = 2 xor (6)  //按位異或操作 ^
   print("/nshl:" + shl + "/nshr:" + shr + " /nushr:" + ushr )
   print( "/nand：" + and + "/nor:" + or + "/nxor:" + xor)

輸出信息為

shl:8
shr:2
ushr:0
and：0
or:6
xor:4

在上面的部分操作符可達到邏輯操作符， 當我們使用Boolean時，or() 相當于 ||，and() 相當于 &&， xor() 當操作符兩邊相反時為true，否則為false ，not()時取反。

數組遍歷及控制語句

遍歷數組

   fun forLoop(array: Array) {
       //第一種方式直接輸出字符（類似java foreach）
       for (str in array) {
           println(str)
       }
       //Array提供了forEach函數
       array.forEach {
         println(it)
        }
       //array.indices是數組索引
       for (i in array.indices) {
           println(array[i])
       }
       //(類似javafor(int i=0;iwhile (i

使用when判斷類型

fun whenFun(obj: Any) {
       when (obj) {
           25 -> println("25")
           "Kotlin" -> println("Kotlin")
           !is String -> println("Not String")
           is Long -> println("Number is Long")
           else -> println("Nothing")
       }
   }

is 和java中instanceof是一個作用判斷是否為某個類型。!is即判斷不是某個類型。

//@定義label，一般用在內層循環中跳到外層循環:i in 0..2等價于java中 for（int i=0;ifor (i in 0..2) {
       for (j in 0..3) {
           println("i:" + i + "  j:" + j)
           if (j == 2)
           //continue@loop//跳到外層循環，繼續往下執行
               break@loop  //跳到外層循環label處，跳出改層循環
       }
   }

倒序輸出是downTo

   //倒序輸出5 4 3 2 1 0
   for (i in 5 downTo 0) {
       println(i)
   }
   //設置輸出數據步長
    for (i in 1..5 step 3) print(i) // 輸出 14
    //step和downTo混合使用
    for (i in 5 downTo 1 step 3) print(i) //輸出52

類與枚舉

/*** constructor:構造函數
* constructor無修飾符(如：private)時，constructor可以省略：
* 當是無參構造函數時，整個構造函數部分也可以省略，省略的構造函數默認是public的
* 由于primary constructor不能包含任何代碼，因此使用 init 代碼塊對其初始化,
* 同時可以在初始化代碼塊中使用構造函數的參數
*/
open class People private constructor(var id: String, var name: String) {
   //可以類中初始化屬性：
   var customName = name.toUpperCase() //初始化屬性
   //次構造函數，使用constructor前綴聲明，且必須調用primary constructor，使用this關鍵字
   constructor( id: String, name: String, age: Int) : this(id, name) {
       println("constructor")
   }
   init {
       println("初始化操作，可使用constructor參數")
   }
   //需要open修飾，子類才可以
   open fun study() {
       print("study")
   }
   //People前的冒號":"是繼承的意思，實現類接口的時候也是冒號
class Student(id: String, name: String) : People(id, name) {
   var test: Number = 3
   private var name1: String?
       get() {
           return name1
       }
       set(value) {
           name1 = value
       }
 //override修飾的方法，默認是可以被繼承的。若希望不被繼承，可以使用 final 關鍵詞修飾
   override fun study() {
       super.study()
   }
}

}

數據類用來保存數據，類似于POJO類，使用data關鍵詞進行定義，編譯器默認會為數據類生成以下四個方法

• equals()
• hashCode()
• toString()
• copy() 通過數據類你會看到Kotlin的簡潔性，我們創建一個Staff類，有String類型的name，position和泛型T(使用泛型僅僅是為了在Kotlin中接觸以下泛型) java實現代碼：

public class StaffJ {
   private String name;
   private String position;
   private T age;
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
   public String getPosition() {
       return position;
   }

   public void setPosition(String position) {
       this.position = position;
   }
   public T getAge() {
       return age;
   }
   public void setAge(T age) {
       this.age = age;
   }
}

Kotlin數據類：

data class Staff(var name: String,  val position: String,var age:T)

通過對比我們就看出了優點了，一行代碼就實現了,具體使用

var staff = Staff("code4Android","Android工程師","22")  //實例化對象

要獲取某個屬性如獲取名字staff.name,賦值就是staff.name=”code4Android2″，既然說了這樣可以賦值，但是動手的小伙伴說為什么我敲的報錯啊，如下

staff.position="前端"

編譯報錯了，在前面我們說過val修飾的屬性只能賦值一次，那在這里val修飾的屬性我們是不能再次賦值的。

fun main(arg:Array){
   var staff = Staff("code4Android","Android工程師","22")  //實例化對象
   staff.name="code4Android2"   var staff1=staff.copy()
   //使用copy的時候可以指定默認值，可以指定任意個用逗號","隔開
   var staff2=staff.copy(name="ccc",position = "kotlin")
   println("name:${staff2.name} position:${staff2.position} age ${staff2.age}")
   //staff.position="Kotiln" //val不能再次賦值
   var anotherStaff= Staff("code4Android","Android工程師",22) //實例化對象

   println("staff toString(): ${staff.toString()} ")
   println("anotherStaff toString(): ${anotherStaff.toString()}")
   println("staff hashCode(): ${staff.hashCode()} ")
   println("anotherStaff hashCode(): ${anotherStaff.hashCode()}")
   println("staff is equals another staff ? ${staff.equals(anotherStaff)}")
}

上面使用了字符模板，在Kotlin中有兩種字符模板形式，/變量、{}

   var name:String="Code4Android"   println("我的名字叫$name")
   println("我的名字叫${name}")
/**
* java允許使用匿名內部類;kotlin也有類似的概念，稱為對象表達式-object expressions
*/
open class KeyBord{
   open fun onKeyEvent(code:Int):Unit = Unit
}

/**匿名內部類**/
var key=object :KeyBord(){
   override open fun onKeyEvent(code:Int):Unit = Unit
}

枚舉

enum class Color{
   RED,BLACK,BLUE,GREEN,WHITE
}
fun display(){
   var color:Color=Color.BLACK
 // 轉換指定name為枚舉值，若未匹配成功，會拋出IllegalArgumentException
   Color.valueOf("BLACK")
   Color.values() //已數組的形式，返回枚舉值
   println(color.name)////獲取枚舉名稱
   println(color.ordinal)//獲取枚舉值在所有枚舉數組中定義的順序,0開始
}

在Kotlin中枚舉還支持方法。

擴展

/**
* fun receiverType.functionName(params){
*body
*}
* receiverType : 待擴展的類名
* .            ：修飾符為擴展符
* functionName ：為自定義的擴展函數名,
* params       ：為自定義的擴展函數參數，可為空
* 擴展函數作用域，受函數的visibility modifiers影響
* 擴展函數并沒有對原類做修改，而是為被擴展類的對象添加新的函數。
* 有一條規則，若擴展函數和類原有函數一致，則使用該函數時，會優先使用類本身的函數。
*/
class Employee(var name: String) {
   fun print() {
       println("Employee")
   }
}

//擴展函數
fun Employee.println() {
   print("println:Employee name is $name")
}

/**
* 可以擴展一個空對象
*/
fun Any?.toString1(): String {
   if (this == null)
       return "toString1:null"   else {
       return "toString1" + toString()
   }
}

/**
* 擴展屬性
* 由于擴展屬性實際上不會向類添加新的成員,
* 因此無法讓一個擴展屬性擁有一個后端域變量. 所以,對于擴展屬性不允許存在初始化器.
* 擴展屬性的行為只能通過明確給定的取值方法與設值方法來定義，也就意味著擴展屬性只
* 能被聲明為val而不能被聲明為var.如果強制聲明為var，即使進行了初始化，
* 在運行也會報異常錯誤，提示該屬性沒有后端域變量。
*/
val Employee.lastName: String
   get() {
       return "get:"+name
   }

使用

fun main(arg: Array) {
   var employee = Employee("Code4Android")
   employee.print()
   employee.println()
   println(employee.toString1())
   println(employee.lastName)
}

代理

**
* 被代理接口
*/
interface Base {
   fun display()
}

/**
* 被代理類
*/
open class BaseImpl : Base {
   override fun display() = print("just display me.")
}

/**
* 代理類，使用:以及關鍵詞by進行聲明
* 許代理屬性和其他繼承屬性共用
* class Drived(base: Base) : Base by base,BaseImpl()
*/
class Drived(base: Base) : Base by base

//使用
fun show() {
   var b = BaseImpl()
   var drived = Drived(b)
   drived.display()

}

**
* 代理類型：
* 懶加載：Lazy
* 觀察者：Delegates.observable()
* 非空屬性：Delegates.notNull()
*/
class Water {

   public var weight:Int by Delegates.notNull()
   /**
    * 代理屬性
    */
   public val name: String by lazy {
       println("Lazy.......")
       "Code4Android"   }
   public var value: String by Delegates.observable("init value") {
       d, old, new ->
       println("$d-->$old->$new")
   }
}

fun main(arg: Array) {
   show()
   var water = Water()
   println(water.name)
   println(water.name)
   water.value = "11111"   water.value = "22222"   water.value = "33333"   println(water.value)
   println(water.value)
   //必須先賦值否則IllegalStateException: Property weight should be initialized before get.
   water.weight=2
   print(water.weight)
}

操作符::

val String.lastChar: Char
   get() = this[this.length - 1]

class A(val p: Int)
 //1,反射得到運行時的類引用:
   val c = Student::class
   //2,函數引用
   fun isOdd(x: Int) = x % 2 != 0
   val numbers = listOf(1, 2, 3)
   println(numbers.filter(::isOdd))

   //3，屬性引用(在此引用main函數主體外聲明的變量)
   println(::x.get())
   ::x.set(2)
   println(x)
   //4，::x 表達式評估為 KProperty 類型的屬性
  //它允許我們使用 get() 讀它的值或者使用名字取回它的屬性
   val prop = A::p
   println(prop.get(A(1)))

   //5，對于擴展屬性
   println(String::lastChar.get("abc"))

   //6，與 java 反射調用
   println(A::p.javaClass),
   var f: Array = A::p.javaClass.declaredFields

伴生對象

伴生對象(companion object )類似于java中的靜態關鍵字static。在Kotlin沒有這個關鍵字，而是伴生對象，具體用法

open class People constructor(var id: String,  var name: String){
   //可以類中初始化屬性：
   var customName = name.toUpperCase() //初始化屬性

   //使用constructor前綴聲明，且必須調用primary constructor，使用this關鍵字
   constructor( id: String, name: String, age: Int) : this(id, name) {
       println("constructor")
   }

   init {
       println("初始化操作，可使用constructor參數")
   }
  //,Kotlin的class并不支持static變量,所以需要使用companion object來聲明static變量,
  // 其實這個platformStatic變量也不是真正的static變量,而是一個伴生對象,
   companion object {
       val ID = 1
   }
}

使用的話直接People.ID。

單例模式

在Kotlin中使用object修飾類的時候，。該類是單例對象。

/**
* 使用object定義類，該類的實例即為單例，訪問單例直接使用類名，
* 不能通過構造函數進行訪問，不允許有構造函數
* Place.doSomething() // 訪問單例對象
*/
object Singleton {
   fun doSomething() {
       println("doSomething")
   }
}

/**
* 實例化的時候，單例是懶加載，當使用的時候才去加載；而對象表達式是在初始化的地方去加載。
*
* 當在類內部使用 object 關鍵詞定義對象時，允許直接通過外部類的類名訪問*內部對象進
*而訪問其相關屬性和方法，相當于靜態變量
* 可以使用companion修飾單例，則訪問其屬性或方法時，允許省略單例名
* MyClass.doSomething() // 訪問內部單例對象方法
*/
class MyClass {
   companion object Singleton {
       fun doSomething() {
           println("doSomething")
       }
   }
}