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) {
|
…爲區間操作符，等價於[]; ..<等價於[) 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 o1 = 1; var o2 = 2 |
都是用分號分隔，默認不用寫 |
|
空返回值 |
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
|
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 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" 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() { [email protected]() //調用 Foo 實現的 f() println([email protected]) //使用 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){
|
使用static關鍵字 final class SingleTon { //單例類的屬性 var name: String var age: Int
private init() { name = "" age = 0 print("SingleTon init is called") }
static let sInstance = SingleTon() } |
1、構造函數聲明爲私有函數，外部類無法實例化； 2、Kotlin需要添加同步鎖synchronized， Swift不需要添加同步鎖； 3、Kotlin使用伴生對象聲明靜態屬性， Swift使用static聲明靜態屬性； |
|
權限 |
private意味着只在這個類內部（包含其所有成員）可見； protected——和 private一樣 +在子類中可見。 internal ——能見到類聲明的 本模塊內的任何客戶端都可見其 internal 成員； public ——能見到類聲明的任何客戶端都可見其 public 成員。 |
open 可以其它作用域被訪問、繼承 public可以訪問自己模塊中源文件裏的任何實體，別人也可以通過引入該模塊來訪問源文件裏的所有實體。 internal可以訪問自己模塊中源文件裏的任何實體，但是別人不能訪問該模塊中源文件裏的實體。 fileprivate文件內私有，只能在當前源文件中使用。 private只能在類中訪問，離開了這個類或者結構體的作用域外面就無法訪問。 |
|
|
擴展 |
擴展方法： fun類名.方法名(參數…):返回值類型 { 函數體 } //擴展方法 fun String.size(): Int { return this.count() } var str = "this is a string" print(str.size()) 擴展屬性：val或var類名.屬性名: 類型 var String.testNum: Int get(): Int { return this.count() } set(value) { print("測試") } |
extension關鍵字，作用域是整個模塊 //僅支持擴展方法，不支持擴展屬性 extension String { func testMethod() { print("extension testMethod") } } var str = "this is a string" str.testMethod() |
1、Kotlin支持擴展屬性和方法； 2、Swift支持擴展方法，但不能擴展屬性； 3、Kotlin不需要關鍵字， Swift使用extension關鍵字； |
|
基類 |
Any，所有類的基類 |
AnyClass |
1、Kotlin使用Any作爲基類，類似於Java的Object； 2、Swift有Any、AnyObject和AnyClass，所有類的基類是AnyClass。3、泛型和基類派生類引用會用到。 |
|
數據類 |
data class User(var id: Int, var name: String) var user: User = User(1, "zhangsan") //實例化 var (id, name) = user //取值 user.name = "lisi" print("${user.component1()} ${user.component2()}") //1 lisi print(" ${user.id} ${user.name}") //1 lisi |
不支持 |
1、Kotlin使用data class關鍵字聲明數據類，即類只有屬性，不需要實現自定義函數； 2、Swift用class實現數據類； |
|
泛型 |
classBox<T>(t:T) { varobj = Box(1) fun
<T> chkType(content:T) { |
class A<T> { var value: T init(param: T) { value = param } } var obj = A(param: 1) print(obj.value) //輸出1 func testType<T>(content: T) { if content is Int { print("整型") } else if content is Float { print("浮點型") } else {
} } |
Kotlin和Swift的泛型聲明方式類似，都是<T>格式，泛型也可以繼承於某類例如<T: String> |
|
枚舉 |
enum classDirection { varenum1 = Direction.EAST |
enum Orientation: Int { case NORTH = 0 case SOURTH case WEST case EAST } var value: Orientation = .EAST print(value.rawValue) //輸出3 |
1、Kotlin聲明枚舉的語法跟Java類似； 2、Swift聲明枚舉的每個值都帶前綴case; |
|
接口 |
interface Base { fun print() } class BaseImpl(val x: Int) : Base { override fun print() { print(x) } } |
protocol Base { func testMethod() } class BaseImple: Base { var age: Int? init(x: Int) { age = x }
func testMethod() { print(" testMethod \(age)") } } var obj = BaseImple(x: 10) obj.testMethod() |
1、Kotlin使用interface關鍵字聲明接口； 2、Swift使用protocol關鍵字聲明接口； 3、冒號實現一個或若干個接口； |
|
類型轉換 |
is as !is as?關鍵字 |
is as as? as! |
類型轉換關鍵字，用法類似； 區別是as！可能拋異常。 |
|
相等性 |
3個等號和2個等號 |
3個等號和2個等號 |
1、 ===表示地址相同； 2、==表示值相等，即equals方法爲真； |
|
註解 |
在類名、函數名同行添加註解 實例：class Tests { //將 @Rule 註解應用於屬性 getter @get:Rule val tempFolder = TemporaryFolder() @Test fun simple() { val f = tempFolder.newFile() assertEquals(42, getTheAnswer()) } } |
一般不使用 例如app的入口類是@UIApplicationMain |
1、Kotlin的註解方法有點特別，是在當前行添加； 2、Swift很少使用註解； |