Kotlin 基礎學習

時間  2019-11-13
標籤 kotlin 基礎 學習 简体版
原文   原文鏈接

本文重要在記錄基礎學習知識點，以便後續再次回顧，因此也沒有過多的介紹Kotlin了，目前Android studio 3.0往上就開始支持了，因此這裏直接進入正題。java

變量、類型與符號

變量

Java的聲明變量不用多少，相信你們都很熟悉了，那麼kotlin是怎麼樣的呢？數組

var name: String = "Tom"//普通變量聲明

val TAG: String = "MainActivity"//常量變量聲明

這裏只是簡單的給了兩個範例，var對於js的同窗應該很熟悉了，這裏也是一向採用，聲明的順序是變量名在前，用：隔開 接着是類型，並且必定要初始化，不然編譯器不過。app

類型

類型相比Java也是有了必定的改變，沒有了Java基本數據類型，取而代之的是Int，Double，String，Boolean 等ide

符號

首先kotlin去掉了行尾標識，再也不以；爲結尾，你能夠寫只是畫蛇添足而已，編譯器也不會報錯。函數

：冒號的用處有不少，並且很重要，聲明變量須要，並且還用於繼承：oop

open class A(age: Int) {
    
}

class B(age: Int) : A(age) {
    
}

此外，若是你想在Kotlin代碼中使用Java類，也須要用到「:」符號。連續兩個「:」代表對Java類的調用。學習

val intent = Intent(this, MainActivity::class.java)

類型檢測

Java中對於類型的檢測是instanceof 便可，kotlin中採用更簡單直觀this

if(age is Double){

}

字符串模板

Java中使用字符串模板會比較麻煩，並且不太直觀。而Kotlin裏使用則異常便捷好用。spa

// Java中字符串模板兩種經常使用形式
String name = "我";
int age = 25;
String.format("%s今年%d歲", name, age);
MessageFormat.format("{0}今年{1}歲", name, age);
// Kotlin中更直觀的字符串模板形式
var name = "我"
var age = 25
"${name}今年${age}歲"

採用${變量名}的方式。.net

函數與方法

函數的基本聲明以下：

// 普通方法定義
fun common() {
    
}

// 定義函數的參數和返回值
fun common(str: String): String {
    return TAG
}

接下來看一看函數的參數傳遞：

// 普通方法定義
fun common() {
    common("str","name1")
}

// 定義函數的參數和返回值
fun common(str: String,name1:String,name2:String = "jeck"): String {
    return TAG
}

咱們發現參數裏能夠直接用=給定默認值，這樣咱們調用的時候就不用傳遞了。

Java中的可變參數相信你們都不會忘記，...便可，必需要在參數列最後出現

Kotlin的要求比較簡單：

  • 可變參數沒必要是函數的參數列表中的最後一個
  • 用vararg paramName: paramType格式申明一個可變參數
  • 和Java同樣，在函數體內部，能夠以數組的形式使用這個可變參數的形參變量
fun test(vararg parameterName: String, agr: Int) {
    test("", "", "", agr = 1)
}

可變參數值的話，須要用關鍵字vararg來定義。這裏須要注意的是，一個函數僅能有一個可變參數。該可變參數不必定得是最後一個參數，但當這種狀況下時，調用該方法，須要給其餘未指明具體值的參數傳值。

這裏若是可變參數在最後一個位置的話，在以前的參數就能夠直接寫入參數值便可，不用=賦值

fun test(vararg parameterName: String, agr: Int) {
    addNumbers("linchunshu",1,2,3,4,5)//這裏能夠直接寫入linchunshu 而不用name = "linchunshu"
}

fun addNumbers(name: String, vararg args: Int): Int {
    var result = 0
    for (i in args.indices) {
        result += args[i]
    }
    return result
}

這裏是表明能夠傳遞任意類型的參數，個數不限

fun main(args: Array<String>) {
    test(1,"Hello,Kotlin!",'a',User(1,"liuliqianxiao"))
}
//用Any表明任意類型
fun test(vararg args: Any){
    for(it in args){
        println(it)
    }
}
class User(var id: Int,var name: String){
    override fun toString(): String {
        return "User(id=$id, name='$name')"
    }
}

類與繼承

Kotlin中也使用class關鍵字定義類，全部類都繼承於Any類，相似於Java中Object類的概念。類實例化的形式也與Java同樣，可是去掉了new關鍵字。

構造函數

Kotlin的構造函數分爲主構造器（primary constructor）和次級構造器（secondary constructor）。下面咱們來看看他們的寫法。

primary constructor：

open class A(username: String, age: Int) {
    var username: String
    var age: Int

    init {
        this.username = username
        this.age = age
    }
}

init關鍵字在class裏面做用是使參數進行初始化，初始化代碼須要單獨寫在init代碼塊中。

這裏須要注意幾點：

關鍵字constructor：在Java中，構造方法名須和類名相同；而在Kotlin中，是經過constructor關鍵字來標明的，且對於Primary Constructor而言，它的位置是在類的首部（class header）而不是在類體中（class body）。

關鍵字init：init{}它被稱做是初始化代碼塊（Initializer Block），它的做用是爲了Primary Constructor服務的，因爲Primary Constructor是放置在類的首部，是不能包含任何初始化執行語句的，這是語法規定的，那麼這個時候就有了init的用武之地，咱們能夠把初始化執行語句放置在此處，爲屬性進行賦值。

固然上面初始化咱們也能夠在變量聲明直接進行初始化：

open class A(username: String, age: Int) {
    var username: String = username
    var age: Int = age

}

能夠看出，咱們的寫法二實際上就是對咱們在寫法一前面提到的兩個關鍵字的簡化。

當咱們定義一個類時，咱們若是沒有爲其顯式提供Primary Constructor，Kotlin編譯器會默認爲其生成一個無參主構造，這點和Java是同樣的。好比有這樣的一個類：

class Person {
    private val username = "David"
    private var age = 23

    fun printInfo() {
        println("username = $username, age = $age")
    }
}
fun test(args: Array<String>) {
    val person = Person()
    person.printInfo()
}

Secondary Constructor：

和Primary Constructor相比，很明顯的一點，Secondary Constructor是定義在類體中。第二，Secondary Constructor能夠有多個，而Primary Constructor只會有一個。

open class C(username: String, age: Int) {
    var username: String
    var age: Int
    var sex: String
    var isMarried: Boolean

    init {
        this.age = age
        this.username = username
        this.sex = "男"
        this.isMarried = false
    }

    constructor(username: String, age: Int, sex: String) : this(username, age) {
        this.sex = sex
    }

    constructor(username: String, age: Int, sex: String, isMarried: Boolean) : this(username, age, sex) {
        this.isMarried = isMarried
    }
}

咱們看上面的例子，首先主構造函數包含了兩個參數，次級構造函數咱們設置了兩個，而且參數依次多一個，咱們很感興趣的就是this（），這裏咱們是在次級構造函數裏面調用主構造函數，咱們發現四個參數的調用三個參數的，三個參數的調用主構造函數，這也說明了，次級構造函數直接或者間接的調用了主構造函數，而且若是咱們不調用就會報錯。

繼承

類的繼承使用符號「:」表示，接口的實現也同樣。kotlin和Java在這裏有一個很明顯的區別就是咱們定義一個類的時候，咱們不能隨意的繼承某個類，換句話說若是某個類想要被繼承那就必須得聲明爲open，上面的例子中的代碼也有寫道，kotlin取消了final這個關鍵字，因此默認都是不可繼承的。

伴隨對象

Kotlin 取消了關鍵字static，也就沒法直接聲明靜態成員，因此引入了伴生對象這個概念，能夠理解爲「影子」

  • 伴生對象之於它所在的類是「如影隨形」
  • 使用關鍵字companion表示伴隨，object表示對象
    實例：

其實跟Java的static靜態代碼塊很相似：

class B(name: String, age: Int) : A(name, age) {

    companion object haha{
        fun sys(){
            println("haha")
        }
    }
}
B.sys()

聲明和使用其實很簡單，至關於靜態方法調用的過程，這裏的haha能夠不用寫，咱們能夠直接聲明伴隨對象。

再詳細的伴隨對象知識後面我會寫一篇博客。

邏輯語句

接下來是咱們常常用到的一些邏輯語句，使用上會有所變化。

if-else語句沒有改變，該怎麼用仍是怎麼用。

if-else語句能夠做爲一個邏輯表達式使用

var age:Int = if(x > y) x else y

這是kotlin的特色，還能夠做爲代碼塊出現：

var age1: Int = if (x > y) {
    print("x")
    x
} else {
    print("y")
    y
}

咱們能夠作不少事代碼塊裏面。

when

這個用起來也是比較簡單：

fun t(x: Int):String {
    when (x){
        1 -> return "1"
        2 -> return "2"
        3 -> return "3"
        else -> return "-1"
    }
}

標籤

Kotlin中能夠對任意表達式進行標籤標記，形式爲abc@，xyz@。而這些標籤，能夠搭配return、break、continue等跳轉行爲來使用。

fun returnDemo2() {
    println("START : " + ::returnDemo2.name)
    val intArray = intArrayOf(1, 2, 3, 4, 5, 6, 7)
    intArray.forEach here@{
        if (it == 3) return@here//指令跳轉到lambda表達式標籤here@處。
        println(it)          //繼續下一個it = 4遍歷循環
    }
    println(" END : " + ::returnDemo2.name)//結果一、二、四、五、六、7
}
fun main(args: Array<String>) {
    loop@ for (i in 1..4) {
        for (j in 1..4) {
            if (i == 2 && j == 2) {
                break@loop
            }
            println("i = $i, j = $j")
        }
    }
}

這樣能夠直接跳出外層循環

跟java相似：

public void t() {
    loop:
    for (int i = 1; i <= 4; i++) {
        for (int j = 1; j <= 4; j++) {
            if (i == 2 && j == 2) {
                break loop;
            }
            System.out.println("i = " + i + ", j = " + j);
        }
    }
}

在外層循環處聲明一個標籤loop@，當須要 break 的時候，直接使用break@loop就能夠跳出外層循環。

fun main(args: Array<String>) {
    val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
    ints.forEach {
        if (it == 0) return
        print(it)
    }
}

上面代碼輸出爲：123，在0時直接返回不會繼續打印。

val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
ints.forEach lit@ {
    if (it == 0) return@lit
    print(it)
}

這裏加上標籤就會直接過濾掉0，打印位：123456

上面方式還能夠寫成隱藏標籤：

val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
ints.forEach {
    if (it == 0) return@forEach
    print(it)
}

直接返回標籤forEach便可。

for

fun mainList(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

其餘的就跟Java都同樣啦！

基礎知識大概就這麼多，後面還會詳細的記錄個別的深刻使用方法！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程