Kotlin VS Swift_Kotlin

       Kotlin是Android的最新開發語言；

       Swift是iOS的最新開發語言；

       二者文法很像， 下面就對比一下。

       Kotlin中文網站：     https://www.kotlincn.net/docs/reference/basic-syntax.html

 按官方文檔順序說明：

功能

Kotlin

Swift

說明

定義包

package com.*.*                                                               執行個體：pacakge com.brycegao.test

import *                                                         執行個體： import UIKit

1、Kotlin聲明定義包跟Java相同，包名必須是小寫字母；                                  2、Swift引用庫時使用import關鍵字。

引用類

import *.*.*                                                                          執行個體：import java.util.*

只需引用庫

Kotlin跟Java相同， Swift不需要引用類、只需要引用庫即可；

定義函數

fun sum(a: Int, b: Int): Int {           

    return a + b    

}                                                                                        如果函數體只有一行代碼，可以簡寫函數。                     fun sum(a: Int, b: Int): Int = a + b                                      調用方法： sum(1, 2)

func sum(label1 a: Int, label2 b: Int)->Int { return a + b}                                                                調用方式： sum(lable1: 1, label2: 2)

1、Kotlin使用fun作為函數關鍵字；  2、func使用func作為函數關鍵字;  3、Kotlin使用:分隔參數和傳回值類型； 4、Swift使用->分隔參數和傳回值類型；

可變參數

var關鍵字           舉例： var a: Int = 1

   var關鍵字      舉例： var a: Int = 1                  var b: Int       //可以不賦值

Kotlin和Swift都是用var關鍵字聲明可變參數，參數值可修改且聲明時不必賦值。

常量參數

val關鍵字           舉例： val a: Int = 1

 let關鍵字            舉例： let a: Int = 1

聲明時必須要賦值，而且參數值不可改

注釋

//一行注釋                                                                                 /*多行注釋*/

//一行注釋                                                                                 /*多行注釋*/

Swift和Kotlin注釋方法相同

字串模板

var a = 1                                                                           var s1 = “a is $a”    //用雙引號包含起來 $後面跟著參數        a = 2                                                                                  val s2 =  “${s1.replace(“is”, “was”)}, but now is $a”

var a = 1

var s1 = "a is \(a)"

a = 2

let s2 = "\(s1.replacingOccurrences(of: "is", with: "was")), but now is \(a)"

1、Kotlin使用$和{}聲明參數或者調用函數；                                                        2、Swift使用\()包含參數；

轉義

val s = “my name is \”zhangsan\” ”

let s = “my name is \”zhangsan\” “

使用\轉義

if條件運算式

fun maxOf(a: Int, b: Int): Int {

    if (a > b) {

        return a

    } else {

        return b

    }

}                                                                                        或者 fun maxOf(a: Int, b: Int): Int = if (a > b) a  else b

func maxOf(label1 a: Int, label2 b: Int)->Int {

    if a > b {

        return a

    } else {

        return b

    }

}

if條件為真則進入函數體，為假進入else函數體

空

null

nil

可空值參數

在類型關鍵字後加問號,例如 var a: Int? = null

var a: Int? = nil

都使用問號表示參數可能為空白

數組

    val arr1 = listOf("apple", "banana", "kiwi")

    val arr2 = byteArrayOf(1, 2, 3, 4)

    val arr3 = IntArray(5)

    val arr4 = FloatArray(5)

    val arr5 = DoubleArray(5)

    val arr6 = BooleanArray(5)

let array1 =[1, 2, 3, 4, 5]   //Int型數組

let array2: Array<Int> = Array()      //聲明並定義了Int型數組

let array3:[Int] =[]     //聲明並執行個體化Int型數組

let array4 = Array(repeating: 0, count: 5)   //數組有5個值，全是0

1、Kotlin必須使用函數來定義數組； 2、Swift定義數組更多樣靈活；

遍曆數組

    for(item in arr1){

        println(item)

    }

    //或

    for(i in arr1.indices) {

        println(arr1[i])   //通過下標取值

    }

for item in array1 {

    print(item)

}

//或

var i = 0

while i < array1.count {

    print(array1[i])

    i += 1

}

1、都支援for-in迴圈；                            2、通過下標遍曆；

區間操作符

..為區間操作符，等價於[]                                                  舉例：                                                                              for(i in 1..5) {

        print(i)      //輸出1，2，3，4，5

  }                                                                                          for (i in1..10 step 2) {
    print(i)  //輸出1，3，5，7，9
}

…為區間操作符，等價於[];  ..<等價於[)              for i in 1...5 {

    print(i)  //輸出1，2，3，4，5

}

for i in 1..<5 {

    print(i)   //輸出1，2，3，4

}

Kotlin支援設定步長step， Swift步長只能是1.

語句分隔字元

使用分號，預設不用寫                                                          var o1 = 1;    //一行只能寫一條語句
var o2 = 2

var o1 = 1;

var o2 = 2

都是用分號分隔，預設不用寫

空傳回值

Unit                                                                                     //傳回值為空白
fun method(): Unit {
   
}

fun method1() {

}

Void                                                              func method() -> Void {

    

}

//或

func method1() {

    

}

函數傳回值為空白，可以省略傳回值類型，或者使用Unit、Void關鍵字

類

//預設不支援繼承，等同於Java的final class

class SomeClass {

    

}

//使用open關鍵字，表示可繼承的類

open class BasicClass constructor(name: String) {

    var value: String

    

    init {

        value = name     //主建構函式

    }                                                                                                                     //次建構函式必須調用主建構函式

    constructor(age: Int, name: String): this(name) {

        //函數體

    }

    //...屬性方法

}

class Ext: BasicClass("basic") {

    //...屬性、方法

}

class BasicClass {

    var name: String?

    var age: Int?

    

    init(param: String?) {  //建構函式

        name = param

        print("調用建構函式1 \(name)")

    }

    

    convenience init(age param1: Int, name param2: String) {

        self.init(param: param2)

        age = param1

    }

     //...屬性和函數

    

    deinit {

        //解構函式

    }

}

let obj1 = BasicClass(age: 10, name: “zhangsan")                                                     //衍生類別

class Ext: BasicClass {

    //...屬性和函數

}

1、Kotlin類預設不支援繼承，必須要用open關鍵字表示可繼承；                         2、Swift預設支援繼承；                         3、Kotlin使用contructor定義建構函式，且分為主構造和次建構函式，次建構函式必須調用主建構函式；                          4、Kotlin使用this調用其它建構函式； 5、Swift使用this調用其它建構函式，但必須添加convenience關鍵字；                6、Swift使用init作為建構函式，deinit作為解構函式；

結構體

不支援

struct關鍵字                實值型別

Swift類和結構體的區別是參考型別、實值型別

自增或自減

vara1 = 1
print(a1++)   //輸出1
print(++a1)   //輸出3

print(a1--)   //刪除3
print(--a1)   //輸出1

var a = 1

a += 1

a -= 1

1、Kotlin支援++和—;                               2、Swift不支援++和—, 但支援+=和-+。

控制流程

 var x = 10

    when(x) {   //不用break關鍵字

        0, 1 -> {     //使用逗號分隔，當x等於0或1時執行

            print("第一條語句")

            print("第二條語句")

        }

        2 -> {    //只有1個值時

            print("值等於2")

        }

        in 3..10 -> {  //區間操作符，關鍵字是in和..值為[3,10]

            print("區間操作符")

        } 

        !in 11..20 -> { //值不在[11,20]範圍內

            

        } else -> {

            //條件都不符合，預設處理

        }

    }

var a = 100                                                    switch a {

case 0,1:  //多個條件

    print("第一條語句")

    print("第二條語句")

case 2:  //一個條件

    print("值等於2")

case 3...10:  //區間操作符

    print("區間操作符")

case 10...1000 where a%10==0:   //添加where條件判斷條件

    print("執行where語句")

default:

    print("預設處理")

}

1、Kotlin使用when作為條件判斷關鍵字，不用break關鍵字；                             2、Swift使用switch關鍵字作為分支判斷關鍵字；

if

vara = 1
var b = 2
val max = if(a>b) {
    print("choose a")
    a
} else {
    print("choose b")
    b
}

var a = 1

var b = 2

var max: Int

if a > b {

    max = a

} else {

    max = b

}

Kotlin和Swift的if語句邏輯一樣，區別是Swift if語句不需要括弧

非空操作符

vals1 = "this is a string"
val s2: String? =null
val ret1 = s1 ?:return
val ret2 = s1 ?:"default value"
val ret3 = s2 ?:"default value"
val ret4 = s1 ?: "default"
print(ret1)   //this is a string
print(ret2)   //default value
print(ret3)   //default value
print(ret4)   //this is a string

Kotlin使用?:作為操作符，如果前面值非空則等於前面的值， 否則取後面的值

let s1 = "this is a string"

let s2: String? = nil

let ret1 = s1 ?? "default"  //this is a string

let ret2 = s2 ?? "default"  //default

1、Kotlin使用?:作為操作符取非空值；    2、Swift使用??作為操作符取非空值；

標籤

標識符後加@， 可以作為代碼跳轉的地方;文法類似於C語言的goto。                                                                       loop@ for (i in 1..100) {

    for (j in 1..100) {

        if (……) break@loop

    }

}

不支援

1、Kotlin使用的分支跳轉文法；                2、早就被淘汰的文法，影響代碼整體邏輯； 不建議使用。

介面

interface關鍵字

protocol關鍵字

不用實現函數體

內部類

inner關鍵字,  內部類訪問外部類時持有引用。執行個體：super@Outer

open class Foo {

    open fun f() { println("Foo.f()") }

    open val x: Int get() = 1  //唯讀屬性

}

class Bar : Foo() {

    override fun f() { /* …… */ }

    override val x: Int get() = 0

    inner class Baz {

        fun g() {

           super@Bar.f() //調用 Foo 實現的 f()

            println(super@Bar.x) //使用 Foo 實現的 x的 getter

        }

    }

}

class Ext: Basic {

    override func method() {

        print("Ext class method")

    }

    

    //內部類不能訪問外部類

    class Baz {

        func  g() {

            

        }

    }

}

1、Kotlin內部類持有外部類的引用，但是文法有區別。                                          2、Kotlin支援覆蓋方法和屬性；          3、Swift支援覆蓋方法，不支援覆蓋屬性；                                                        4、Swift內部類不能訪問外部類的方法、屬性；                                                    5、都使用override關鍵字覆蓋方法；

單例

Kotlin不支援靜態類型，使用伴生對象。 使用私人建構函式並添加同步鎖,類不能被繼承；                                                             class SingleTon private constructor(str: String){
    var name: String? =null
    var age: Int =0
    var addr: String ="address"

    init {
        println("str is $str")
        name = str
    }

    companion object {
        @Volatile
        private var instance: SingleTon? =null

        fun getInstance(c: String): SingleTon {
            if (instance ==null) {
        &