「Kotlin初探 | 掘金技術徵文」

時間 2019-11-05

標籤 kotlin 初探技術徵文简体版

原文原文鏈接

示例源碼傳送門

前言

Kotlin是一種在 Java虛擬機上執行的靜態型別編程語言，它主要是由俄羅斯聖彼得堡的JetBrains開發團隊所發展出來的編程語言。該語言有幾個優點javascript

簡潔
它大大減小你須要寫的樣板代碼的數量。
安全
避免空指針異常等整個類的錯誤。
通用
構建服務器端程序、Android 應用程序或者在瀏覽器中運行的前端程序。
互操做性
經過 100% Java 互操做性，利用 JVM 既有框架和庫。
配置
在咱們的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
    }
}複製代碼

完成上面的配置後，咱們就能夠愉快的玩耍了。java

Kotlin示例

首先咱們還和之前同樣，建立一個Android項目，自動建立一個Activity以後咱們再建立一個java類android

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代碼的功能git

轉換後的Kotlin代碼github

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<String>) {
        str = "Code4Android"
        println(str)
    }
}複製代碼

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

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<String>) {
    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<String> = Array<String>(3, { i -> i.toString() })
    val anyArray: Array<Any> = 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 shr: Int = a shr (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 + "\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<String>) {
        //第一種方式直接輸出字符（相似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;i<arry.length;i++))
        var i = 0
        while (i < array.size) {
            println(array[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;i<=2;i++）效果
    loop@ for (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<T> {
    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<T>(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<String>){
    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()} anotherStaff toString(): ${anotherStaff.toString()}")
    println("staff hashCode(): ${staff.hashCode()} 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
    Color.valueOf("BLACK") // 轉換指定name爲枚舉值，若未匹配成功，會拋出IllegalArgumentException
    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<String>) {
    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<String>) {
    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<Int> 類型的屬性，它容許咱們使用 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<Field> = 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")
        }
    }
}複製代碼

好了，今天就介紹到這裏，文中如有錯誤歡迎指出，Have a wonderful day.

Kotlin英文官網
 Kotlin學習中文官網
 在線學習示例

本次徵文活動的連接： juejin.im/post/58d8e9…