android kotlin 打印 kotlin dart

---

"世界上只有两种编程语言：一种经常被人喷，一种没人用。” ——

现代原生移动应用主要由 Swift (iOS) 或者 Kotlin (Android) 编程语言开发。另外有两种主要的跨平台应用开发框架 —— React Native (JavaScript) 和 Flutter，后者以 Dart 作为编程语言。React Native 有自己的利基市场，Flutter 看起来更有前途，并常常被拿来同 Swift 和 Kotlin 比较。

这篇文章会聚焦在 Dart，Kotlin， 和 Swift 之间的异同，包括语法，函数和类声明，以及一些其他重要细节。这些语言有很多相似之处，使得在 Dart 和原生 Kotlin/Swift 应用开发间切换上下文相对更容易。

---

变量和常量

Dart

var myVariable = 42; 
myVariable = 50;
final myConstant = 42;
const myConstant2 = 'John';

Kotlin

var myVariable = 42 
myVariable = 50
val myConstant = 42

Swift

var myVariable = 42 
myVariable = 50
let myConstant = 42

「译者按」在这一项中，留意 Dart 的 const 会比较复杂。可参考这篇文章：

总结：Dart 中的 final 和 const 都能用来表明变量在一次赋值后就不想要被改变或者不需要改变。final 用于编译期不可计算的值，const 则用于编译期可计算的值。const 比 final 更“深度” —— 一个 final 的集合，其集合的元素不是 final 的；而一个 const 的集合，集合内的内容也是 const 的，即所谓的 “the object will be frozen and completely immutable (对象被冻结且完全不可变)”。 const 既可用在左边，也可用在右边，用在右边表明值不可变 (变量本身还可变)。当 const 用在左边，且左边的变量是集合，则隐含了右边的值同时也是 const 的。通过上下文可以得知表达式一定是常量，那么 const 可以被省略，也建议省略。例如：

const primaryColors = [
  Color("red", [255, 0, 0]),
  Color("green", [0, 255, 0]),
  Color("blue", [0, 0, 255]),
];

一个类的成员变量，如果是 const ，必须同时声明为 static ，即类(域)成员变量。这容易理解，因为如果是实例变量，按照设计是跟实例走，而 const 本身要求编译期可知，这就要求类的 const 变量同时也要是 static 变量。 Dart 2.5 之后，你还可以通过类型检查和转换，以及 collection if, spread 操作符来定义 (const) 常量。 const constructor 是一个难点，可以参考这个 stackoverflow 链接里的回答：其中有一个概念叫 "canonical instance"，也就是 a "canonicalized" instance。const constructor 对于还没切换到惰性初始化之前的 Dart 还蛮重要的。

---

显式类型

Dart

num myDoubleOrInt = 5;
int myInt = 5;
double myDouble = 5.0;

Kotlin

val explicitDouble: Double = 70.0

Swift

let explicitDouble: Double = 70

总结：在几种语言中，没有继承关系的数字类型之间不能混用赋值。也就是说，不能用一个 Int 给 Double 赋值，也不能用一个 Double 给一个 Int 赋值。Kotlin 对于右边的书写格式要求严格，只有 70.0 才代表 Double 类型。而 Swift 在初始化时允许不写 .0 ，因为类型注解显式说明了是 Double 类型。反之，如果是声明的 Int 类型，你写 70.0 Swift 也并不允许。所以，显式注释了 Double 类型后可以省略数字后的 .0， 大概是 Swift 语言对书写便利的一种支持。毕竟，直觉上有人可能期望不写小数点编译器也能知道自己想要的是浮点数，但大概不会有人故意加了小数点却期望编译器认为自己想要的是整数。

Dart 中 int 和 double 都继承自 num ，num 在 Dart 2.1 之前可以用来规避一些 int 和 double 之间转换带来的错误。但 2.1 之后什么情况下需要用 num ，我查了一些资料，没有找到答案。

---

动态类型

Dart                       Kotlin                         Swift
// 动态类型                  // 动态类型(not for JVM)        // 动态类型
dynamic name = 'John';     var name: dynamic = ...        N/A

---

类型强制 (Type Coercion)

Dart

final label = "The width is ";
final width = 94;
final width2 = 2.0
final widthLabel = label + width.toString();
final widthSum = width + width2;

Kotlin

val label = "The width is "
val width = 94
val width2 = 2.0
val widthLabel = label + width
val widthSum = width + width2

Swift

let label = "The width is "
let width = 94
let width2 = 2.0
let widthLabel = label + String(width)
let widthSum = width + width2 // 编译错误

总结：几种语言中，Swift 对类型强制(隐式转换)的要求最为严格，连数字类型之间都不能直接运算。Dart 灵活一些， 数字类型之间直接运算，但它们和字符串之间不能直接运算。Kotlin 在数字和字符串相加时，选择了作为字符串拼接处理，这一点跟 Java 一致。当然，死板和灵活是一种观点。“Explicit is better than implicit.” 又是一种理念。

---

字符串和字符串插值(模板)

Dart

// 多行字符串
var s1 = """This is a
multi-line string.""";

// 字符串插值
final apples = 3;
final oranges = 5;
final fruitSummary = “I have ${apples + oranges} pieces of fruit.”;

Kotlin

// 多行字符串
val s1 = """This is a
multi-line string."""

// 字符串插值
val apples = 3
val oranges = 5
val fruitSummary = “I have ${apples + oranges} pieces of fruit.”

Swift

// 多行字符串
let s1 = """This is a
multi-line string."""

// 字符串插值
let apples = 3;
let oranges = 5;
let fruitSummary = “I have (apples + oranges) pieces of fruit.”

总结：Swift 的字符串插值书写方式相对小众，\ 加 () 。Kotlin 和 Dart 是更主流的 $ 和 {}。

---

范围操作符

Dart

N/A

Kotlin

val names = arrayOf("Anna", "Alex", "Brian", "Jack") 
val count = names.count() 
for (i in 0..count - 1) {     
    println("Person ${i + 1} is called ${names[i]}") 
} 
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

Swift

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
   print("Person \(i + 1) is called \(names[i])") 
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

总结：Kotlin 和 Swift 都提供了范围操作符。 Swift 还提供 ... 和 ..< ，即开放和半开放两个版本的范围操作符，前者包含右边的值，后者不包含右边的值。个人更喜欢 Swift 提供的实现，因为在某些情况下，有语义的边界值只有一个，采用有语义的变量标识会比 -1 或者 +1 这种写法更直接。

---

集合

在 Dart，Kotlin 和 Swift 中，数组或者列表都是集合类型。集合中的一个需要注意的点是列表和数组，在很多编程语言中，它们可以被认为是同一个东西。也有些编程语言对两者做了区分。Kotlin 更接近 Java，数组定长内容可变，列表变长内容可变(mutable)或者可不变(immutable)，默认是不可变。Dart 和 Swift 的做法相同之处在于都没有像 Java 或者 Kotlin 那样把列表和数组细分开，不同之处是 Dart 字面名选择了 List ，而 Swift 字面名选择了 Array。

数组 （包含List）

Dart

var emptyList = <int>[];
List fixedLengthList = new List(3);
List growableList = new List();

fixedLengthList[0] = 0; // OK
// fixedLengthList[3] = 0; // 编译错误，超出范围
// fixedLengthList.add(0); // 编译错误，定长list不能 add
// growableList[0] = 0; // 编译错误，虽然是可增长的，但初始长度是0，需要通过 add 来添加
growableList.add(0); // OK

var complexList = []; // 不论是否有显式类型注释，dart 都可以用 [] 来初始化列表，
// 如果不指定类型，则类型是 List<dynamic>
complexList.add(1); // OK
complexList.add(“apple”); // OK，因为类型是 List<dynamic> ，
// 所以列表可以混合存放不同子类型

print(complexList); // 输出 [1, “apple”]

Dart 对于定长和变长的设计，容易理解。但个人对这种用数字参数来区别两种 List 的方式有点不适应，可能是因为 Java 的编程经验导致？
Dart 的 List 添加元素 API 是 add ，打印输出用 [] 注记。

Kotlin

val shoppingList = mutableListOf("catfish", "water", "tulips", "blue paint") 
shoppingList[1] = "bottle of water"
// shoppingList[4] = "rock" // 编译错误，index 越界
shoppingList.add("rock") // OK

println(shoppingList) // 输出 [catfish, bottle of water, tulips, blue paint, rock]

val shoppingArray = arrayOf("catfish", "water", "tulips", "blue paint") 
shoppingArray[1] = "bottle of water"

println(shoppingArray) // 不会直接输出数组元素，需要另外处理

Kotlin 的 集合类型除了 array ，其他都是默认 immutable 的。所以如果你需要修改集合，需要使用 mutableListOf ，mutableSetOf 或者mutableMapOf 。
Kotlin 的 List 添加元素 API 是 add 。打印输出用 [] 注记。

Swift

var shoppingArray = ["catfish", "water", "tulips", "blue paint"]
shoppingArray[1] = "bottle of water"
// shoppingArray[3] = "rock" // 编译错误，index 越界
shoppingArray.append("rock") // OK

var complexArray:Array<Any> = [] // 如果有显式类型注释，[] 可以用来初始化数组，
// 类型是 Array<Any>
complexArray.append(1) // OK
complexArray.append(“apple”) // OK，因为类型是 Array<Any> ，
// 所以数组可以混合存放不同子类型

print(complexArray) // 输出 [1, “apple”]
// 注意，如果两个 array 是 let 声明的，则不能修改

Swift 的数组没有直接细分出定长或变长以及 mutable 或 immutable 。
Swift 的 Array 添加元素 API 是 append ，打印输出用 [] 注记。

Set

Dart

var s = Set<int>();
// 或
Set<int> s = Set<int>();
Set<int> s = {}; // 如果有显式的类型注释，右边可以直接用 {} 初始化
print("s.isEmpty is ${s.isEmpty}");
s.add(1);
s.add(2);
s.add(1);

// 或
Set<int> s = {1, 2, 1};

print(s); // 输出只包含1, 2 的形式，如 {1, 2}

Dart 的 Set 的添加 API 是 add ，注记（打印）形式是用 {} ，显式类型注释时可以直接用花括号初始化集合内容。

Kotlin

val s = mutableSetOf<Int>()
println("s.isEmpty() is ${s.isEmpty()}")

s.add(1)
s.add(2)
s.add(1)

// 或
val s = mutableSetOf<Int>(1, 2, 1)

println(s) // 输出只包含1, 2 的形式，如 [1, 2]

Kotlin 的 Set 的添加 API 也是 add ，注记（打印）形式也是 [] ，声明时初始化是把元素放在函数的圆括号内。

Swift

var s = Set<Int>()
// 或
var s: Set<Int> = Set<Int>()
var s: Set<Int> = [] // 如果有显式的类型注释，右边可以直接用 [] 初始化
print("s.isEmpty is \(s.isEmpty)") // true
s.insert(1)
s.insert(2)
s.insert(1)

// 或
var s: Set<Int> = [1, 2, 1]

print(s) // 输出只包含1, 2 的形式，如 [1, 2]
// 注意，如果 s 是 let 声明的，则不能修改

Swift 的 Set 的添加 API 是 insert ，注记（打印）形式也是 []，显式类型注释时可以直接用中括号初始化集合内容。

Map (字典)

Dart

// 空 Map
var emptyMap = {}; // 不论是否有显式类型注释，dart 都可以用 {} 来初始化 Map，
                  // 如果不指定类型，则类型是 _InternalLinkedHashMap<dynamic, dynamic>

// Mutable Map
var occupations = {"Malcolm": "Captain", "Kaylee": "Mechanic"};
occupations["Jayne"] = "Public Relations";

print(occupations); // 输出 {Malcolm: Captain, Kaylee: Mechanic, Jayne: Public Relations}

Kotlin

val occupations = mutableMapOf("Malcolm" to "Captain", "Kaylee" to "Mechanic")
occupations["Jayne"] = "Public Relations"

println(occupations) // 输出 {Malcolm=Captain, Kaylee=Mechanic, Jayne=Public Relations}

Swift

var occupations = ["Malcolm": "Captain", 
"Kaylee": "Mechanic",] // 虽然没有类型注释，但是key:value形式可以推断出是字典，及类型参数
occupations["Jayne"] = "Public Relations"

print(occupations) // 输出 [“Jayne”: “Public Relations”, “Malcolm”: “Captain”, “Kaylee”: “Mechanic”]
// 注意，如果 occupations 是 let 声明的，则不能修改

总结：Dart，Kotlin 的类型参数都是写在 <> 里 (Java 也是)，在 Swift 中，对于数组和字典，则直接把类型参数(类型注释)写在 [] 里。

在 Collection 场景下，Dart 对中括号和花括号的使用可以说比较“豪放” —— 不指定类型的话，[] 默认表示 List<dynamic> ，{} 默认表示 _InternalLinkedHashMap<dynamic, dynamic> 。在有类型注释的时候，{} 还可以用来注记 Set 。
Kotlin 用 [] 注记 List 和 Set ，用 {} 注记 Map 。
Swift “克制” 一些，三种 Collection 的打印输出都是 [] ，有类型注释或者能够推断类型的时候可以分别用来初始化 Array，Set，Dictionary 。

值得注意的是，对于 Swift ，值的 mutability 也是交给绑定的类型决定的，如果是变量，则集合是 mutable 的；如果是常量，则集合是 immutable 的。也是说，var 或者 let 同时决定了绑定和值是否可变；对于 Dart ，final 用于声明，确定绑定是否可变。const 用于声明，隐含了 final ，同时要求值是编译期可计算的。const 用于修饰值，则相当于确定值是 immutable 的；对于 Kotlin ，绑定的 mutability 和值的 mutability 是分离的，前者由 var 或者 val 确定，后者通过不同的 API 直接区分，如 mapOf / mutableMapOf 的区分。

// Dart 的 immutable binding 和 immutable object
final array = const [1, 2, 3];
const array2 = [1, 2, 3]; // 当类型为集合时，右边隐含 const，Effective Dart 建议不写。

---

可空性 & 可选型（可空类型）

Dart (tested <= v2.7)       Kotlin                        Swift

// 声明 // 声明 // 声明
int id = null; var id: Int? = null var id: Int? = nil
id.abs(); //异常 id.inc() // 编译错误 id.signum() // 编译错误
id?.abs(); // 安全的调用 id!!.inc() // 异常 id?.signum() // 安全的调用

// Null aware 操作符 // Elvis 操作符 // 空合操作符
int id = null; val id: Int? = null let id: Int? = nil
var userId = id ?? -1; var userId = id ?: -1 var userId = id ?? -1

// 可选型(还在实现中) // 可选型 // 可选型
int? id; // 需要启用实验特性 val id: Int? var id: Int? // 可选型
var userId = id ?? -1; var userId = id ?: -1 var userId = id ?? -1
// 编译错误：id 必须先被初始化 // 输出 -1

总结：Dart 目前还不是严格区分可空和非空两种类型的“严格”的类型系统，但 NNBD (non-nullable (by default)) 一直都是呼声很高的特性，到 Dart 2.7 ，NNBD 已经部分实现，不过需要通过启用实验特性的方式体验。当然，还有许多迁移工作有待完成，开发者需要耐心等待。

Kotlin，Swift，包括 C# 等现代编程语言，大多都支持可空和非空的严格类型。Kotlin 的变量在使用前需要显式赋值——包括可空类型的 null 初值 (编译期的静态检查)，而 Swift 如果是可空类型，不显式赋值的话则默认为 nil 。

---

控制流

关于 Kotlin 和 Swift 的控制流比较，这篇文章写的不错，推荐阅读，这里就不再赘述。

https://hujiangtech.github.io/tech/android/2017/06/02/swiftvskotlin-control-flow.htmlSwift vs. Kotlin 漫谈之控制流https://hujiangtech.github.io/tech/android/2017/06/02/swiftvskotlin-control-flow.html hujiangtech.github.io/tech/android/2017/06/02/swiftvskotlin-control-flow.html

感受一下：

Dart

// Switch case 
var id = 5;
switch (id) {
  case 1:
    print("id == 1");
    break;
  case 2:
    print("id == 2");
    break;
  default:
    print("id is undefined");
}

// Inclusive for loop
for (var i = 1; i <= 5; i++) {}

// range match
// N/A

// Cascade notation (…)
querySelector(‘#confirm’)
…text = ‘Confirm’
…classes.add(‘important’)
…onClick.listen((e) =>
window.alert(‘Confirmed!’));

Kotlin

// When
val id = 5
when (id) {
  1 -> print("id == 1")
  2 -> print("id == 2")
else -> {
  print("id is undefined")
  }
}

// Inclusive for loop
for (index in 1..5) {}

// range match
val nb = 42
when (nb) {
in 0..7, 8, 9 -> println(“single digit”)
10 -> println(“double digits”)
in 11..99 -> println(“double digits”)
in 100..999 -> println(“triple digits”)
else -> println(“four or more digits”)
}

// Cascade notation (…)
// N/A，可以用 Builder 模式或者 apply, also 函数

Swift

// Switch case
let id = 5
switch id {
  case 1:
    print("id == 1")
  case 2:
    print("id == 2")
  default:
    print("id is undefined")
}

// Inclusive for loop
for index in 1.…5 {}

// range match
let nb = 42
switch nb {
case 0.…7, 8, 9: print(“single digit”)
case 10: print(“double digits”)
case 11.…99: print(“double digits”)
case 100.…999: print(“triple digits”)
default: print(“four or more digits”)
}

// Cascade notation (…)
// N/A，用 Builder 或者 apply{} 扩展

总结：Kotlin，Swift 的控制流都各有许多减少代码量，增加代码清晰度的花样。比如 Kotlin 用增强版的 when 取代了 switch ，if 和 when 不仅可做控制语句，也可作表达式使用。Swift 的 switch 语句支持元组，where 语句添加额外判断等。

Dart 的 switch 跟 Java 一样，需要主动 break，Swift 则相反，匹配到则自动退出 switch ，想要显式继续执行的话要用 fallthrough 。

Dart 的级联注记 (Cascade notation) 也算它的一个小特色了，不过其他语言也有各自的替代方案。严格说来，它并不算一个操作符，只是 Dart 的一种特殊语法。笔者自己在写 Java 代码时也封装 API 做过类似的操作。这种书写方式最大的好处是：把一堆高度相关的代码逻辑“强制”聚在一处，使代码看起来更流畅，整洁。

---

函数

Dart

String greet(String name, String day) {
    return "Hello $name, today is $day.";
}
greet("Bob", "Tuesday");

Kotlin

fun greet(name: String, day: String): String {
    return "Hello $name, today is $day."
}
greet("Bob", "Tuesday")

Swift

func greet(_ name: String, _ day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")

总结：Swift 和 Kotlin 都是类型后置的风格，注意 Swift 返回值用 -> ， Kotlin 仍是用冒号。
下划线在 Swift 中有许多用法，其中有一类主要是“忽略”，包括忽略元组元素，循环的局部变量，以及函数中的外部参数名。Standard Library 中有大量 API 的第一个参数都是可以忽略外部参数名的。
Kotlin 用 fun，Swift 用 func，Dart 和 Java ，C 等语言一样，没有为函数声明引入额外的关键字。

可变数量的参数

Dart

N/A

Kotlin

fun sumOf(vararg numbers: Int): Int {     
    var sum = 0
    for (number in numbers) {         
        sum += number     
    }     
    return sum
}
sumOf(42, 597, 12)

一个 Kotlin 函数只能有一个可变数量的参数。对于顺序，没有强制约束，可以放在普通参数之前或者之后。当同时包含可变参数和普通参数时，调用时普通参数需要使用命名参数的调用语法。

fun sumOfNumbers(vararg numbers: Double, initialSum: Double): Double {
    var sum = initialSum
    for(number in numbers) {
        sum += number
    }
    return sum
}
sumOfNumbers(1.5, 2.5, initialSum=100.0) // Result = 104.0

Swift

func sumOf(_ numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf(42, 597, 12)

可变数量的参数在 Swift 官方文档中称为 variadic parameter 。同样，一个函数只允许至多一个 variadic parameter 。

函数类型

Dart

// 写法1
int Function(int) makeIncrementer(int a) {
    return (a) {
        return 1 + a;
    };
}

// 写法2
int Function(int) makeIncrementer2(int a) {
int myInnerFunction(a) {
return 1 + a;
}

<span >final</span> <span >myFunction</span> <span >=</span> <span >myInnerFunction</span><span >;</span>
<span >return</span> <span >myFunction</span><span >;</span>

}

// 写法3：类型是 Closure: (int) => int
int Function(int) increment = (int a) {
return 1 + a;
};

// 写法4：类型是 Closure: (dynamic) => num
var increment2 = (a) {
return 1 + a;
};

print(makeIncrementer);
print(makeIncrementer(1));
print(makeIncrementer(1)());

print(increment);
print(increment(1));

Kotlin

fun makeIncrementer(): (Int) -> Int {     
    val addOne = fun(number: Int): Int {         
        return 1 + number     
    }     
    return addOne 
} 
val increment = makeIncrementer() 
increment(7)

// makeIncrementer 可以写成更短的形式
fun makeIncrementer2() = fun(number: Int) = 1 + number

Swift

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
let increment = makeIncrementer()
increment(7)

总结：在这几种语言中，函数都是一等公民。Swift 是中规中矩的写法，Kotlin 提供了简短的版本。Dart 也有几种写法。当然，写法 1、2 和写法 3 、4 并不对等，推荐 3、4 的写法。留意结尾的分号，这里有没有分号结尾的差别类似于 C++ 中的声明和定义。写法1、2 仅声明，写法 3、4 声明的同时也定义了，所以必须加分号。

映射

Dart

final numbers = [20, 19, 7, 12];

// 写法1
numbers.map((number) => 3 * number).toList();

// 写法2：类似 Python 的语法
[for (var number in numbers) 3 * number];

Kotlin

val numbers = listOf(20, 19, 7, 12)
numbers.map { 3 * it }

Swift

let numbers = [20, 19, 7, 12]
numbers.map { 3 * 排序 }

Dart

var list = [1, 5, 3, 12, 2]; list.sort();

Kotlin

listOf(1, 5, 3, 12, 2).sorted()

Swift

var mutableArray = [1, 5, 3, 12, 2].sorted()

命名参数

Dart

// Dart 的命名参数同时也是可选参数，用 {} 包裹 int area({int width, int height}) { return width * height; }

Kotlin

area(width: 2, height: 3)
// 命名参数可以按任意顺序书写
area(height: 3, width: 2)

// Dart 的可选顺序参数，用 [] 包裹
int area([int width, int height]) {
return width * height;
}

area(); // 可编译，运行时错误
area(2); // 可编译，运行时错误
area(2, 3); // OK

fun area(width: Int, height: Int) = width * height area(width = 2, height = 3)

Swift

// 混合顺序参数和命名参数的写法
area(2, height = 3)

// 全部采用命名参数时可以按任意顺序书写
area(height = 3, width = 2)

func area(width: Int, height: Int) -> Int { return width * height } area(width: 2, height: 3)

类

总结：Swift 的参数列表设计最为严格，参数需要同时匹配顺序和名称 (命名的作用仅仅只是为了使代码含义更清晰) 。Kotlin 类似 Python，纯命名参数方式可以随意调整顺序，意味着开发者记忆 API 不需要记顺序。 Dart 的命名参数同时也是可选参数。

当然，得益于强大的现代集成开发环境，准确记忆 API 的完整参数列表这种需求对大多数程序员是不存在的。

---

声明和定义

Dart

class Shape { var numberOfSides = 0; String simpleDescription() { return "A shape with $numberOfSides sides."; } }

Kotlin

var shape = Shape();
shape.numberOfSides = 7;
var shapeDescription = shape.simpleDescription();

class Shape { var numberOfSides = 0 fun simpleDescription() = "A shape with $numberOfSides sides." }

Swift

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

class Shape { var numberOfSides = 0 func simpleDescription() -> String { return "A shape with \(numberOfSides) sides." } }

继承

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

Dart

class NamedShape { int numberOfSides = 0; String name; <span >NamedShape</span><span >(</span><span >String</span> <span >name</span><span >)</span> <span >{</span> <span >this</span><span >.</span><span >name</span> <span >=</span> <span >name</span><span >;</span> <span >}</span> <span >// 或者采用语法糖写法

<span >String</span> <span >simpleDescription</span><span >()</span> <span >{</span>
    <span >return</span> <span >"A shape with </span><span >$</span><span >numberOfSides</span><span > sides."</span><span >;</span>
<span >}</span>

NamedShape(this.name);

<span >Square</span><span >(</span><span >this</span><span >.</span><span >sideLength</span><span >,</span> <span >String</span> <span >name</span><span >)</span> <span >:</span> <span >super</span><span >(</span><span >name</span><span >)</span> <span >{</span>
    <span >numberOfSides</span> <span >=</span> <span >4</span><span >;</span>
<span >}</span>

<span >double</span> <span >area</span><span >()</span> <span >{</span>
    <span >return</span> <span >sideLength</span> <span >*</span> <span >sideLength</span><span >;</span>
<span >}</span>

<span >// Dart 官方建议审慎使用 @override 注解，当超类不在自身控制下时使用

}

class Square extends NamedShape {
double sideLength;

Kotlin

// 这个注解主要是为了超类更改了代码，子类不知情仍正常工作时可以提醒程序员
@override
String simpleDescription() {
return “A square with sides of length $sideLength.”;
}
}

final test = Square(;5.2, “square”);
print(test.area());
print(test.simpleDescription());

open class NamedShape(val name: String) { var numberOfSides = 0 <span >open</span> <span >fun</span> <span >simpleDescription</span><span >()</span> <span >=</span> <span >"A shape with $numberOfSides sides."</span>

<span >fun</span> <span >area</span><span >()</span> <span >=</span> <span >sideLength</span><span >.</span><span >pow</span><span >(</span><span >2</span><span >)</span>

<span >override</span> <span >fun</span> <span >simpleDescription</span><span >()</span> <span >=</span>
    <span >"A square with sides of length $sideLength."</span>

}

class Square(var sideLength: BigDecimal, name: String) :
NamedShape(name) {
init {
numberOfSides = 4
}

Swift

}

val test = Square(BigDecimal(“5.2”), “square”)
println(test.area())
println(test.simpleDescription())

class NamedShape { var numberOfSides: Int = 0 let name: String <span >init</span><span >(</span><span >name</span><span >:</span> <span >String</span><span >)</span> <span >{</span> <span >self</span><span >.</span><span >name</span> <span >=</span> <span >name</span> <span >}</span> <span >func</span> <span >simpleDescription</span><span >()</span> <span >-></span> <span >String</span> <span >{</span> <span >return</span> <span >"A shape with </span><span >\(</span><span >numberOfSides</span><span >)</span><span > sides."</span> <span >}</span>

<span >init</span><span >(</span><span >sideLength</span><span >:</span> <span >Double</span><span >,</span> <span >name</span><span >:</span> <span >String</span><span >)</span> <span >{</span>
    <span >self</span><span >.</span><span >sideLength</span> <span >=</span> <span >sideLength</span>
    <span >super</span><span >.</span><span >init</span><span >(</span><span >name</span><span >:</span> <span >name</span><span >)</span>
    <span >self</span><span >.</span><span >numberOfSides</span> <span >=</span> <span >4</span>
<span >}</span>

<span >func</span> <span >area</span><span >()</span> <span >-></span> <span >Double</span> <span >{</span>
    <span >return</span> <span >sideLength</span> <span >*</span> <span >sideLength</span>
<span >}</span>

<span >override</span> <span >func</span> <span >simpleDescription</span><span >()</span> <span >-></span> <span >String</span> <span >{</span>
    <span >return</span> <span >"A square with sides of length "</span> <span >+</span>
       <span >String</span><span >(</span><span >sideLength</span><span >)</span> <span >+</span> <span >"."</span>
<span >}</span>

}

class Square: NamedShape {
var sideLength: Double

总结：

}

let test = Square(sideLength: 5.2, name: “square”)
print(test.area())
print(test.simpleDescription())

// Kotlin class NamedShape constructor(val name: String) { /*……*/ } // 如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。继承的书写方式在各种编程语言中可谓五花八门。像 Python 是将父类放在 () 里紧跟在子类名后，Ruby 是用 < 。典型的 C 家族是用 ：。现代编程语言主要在构造器上玩一些花样。其中 Kotlin 的花样特别多，分为主从两类构造器，主构造器必有 (没声明的话会默认生成无参的 public 主构造器) ，主构造器隐含初始化块等。写法上主构造器是直接跟在类头。

 override

Swift 的 init 其实也挺复杂。可以参考下面这篇文章

类型检查

Dart

final test = Square(5.2, "square"); if (test is Square) { print("test is square."); }

Kotlin

if (test is! Square) {
print(“test is not square.”);
}

// 获取类型
print(test.runtimeType);

val test = Square(BigDecimal("5.2"), "square") if (test is Square) { println("test is square.") } if (test !is Double) { println("test is not square.") }

Swift

// 获取类型
println(test.javaClass.kotlin);

let test = Square(sideLength: 5.2, name: "square") if (test is Square) { print("test is square.") } if !(test is Double) { print("test is not square.") }

接口（协议）编程

// 获取类型
print(type(of: test));

Dart

// 被声明为 abstract 因此不能被实例化 abstract class AbstractContainer { // 定义构造器, 字段, 方法... void updateChildren(); // Abstract method. }

// Dart 移除了显式接口声明，
// 每个类都隐式的定义个了一个包含该类和该类实现的接口的所有实例成员
// (说人话：类就是接口)。
// 一个类通过 implements 语句声明它们实现一个或者多个接口，
// 然后提供接口要求的 API，例如：

// Person. 包含了 greet() 方法的隐式接口
class Person {
// 仅库可见，属于接口的一部分
 final _name;<span >// 不属于接口的一部分，因为这是个构造器 Person(this._name);
<span >// 属于接口的一部分 String greet(String who) => ‘Hello, _name.’;
}// 一个 Person 接口的实现
class Impostor implements Person {
get _name => ‘’;<span >String</span> <span >greet</span><span >(</span><span >String</span> <span >who</span><span >)</span> <span >=></span> <span >'Hi </span><span >$</span><span >who</span><span >. Do you know who I am?'</span><span >;</span>}
String greetBob(Person person) => person.greet(‘Bob’);
void main() {
print(greetBob(Person(‘Kathy’)));
print(greetBob(Impostor()));
}// 如果想要像 Java 那样的接口，建议用抽象类作为接口，相当于是把关心的部分提炼出来

Kotlin

interface Nameable { fun name(): String }

fun <T: Nameable> f(x: T) {
println("Name is " + x.name())
}class NameX : Nameable {
override fun name() : String {
return “NameX”;
}
}f(x = NameX())
Swift
 
protocol Nameable {
    func name() -> String
} 
func f<T: Nameable>(x: T) {
print("Name is " + x.name())
}class NameX: Nameable {
func name() -> String {
return “NameX”;
}
}f(x: NameX())

Lambda 表达式、闭包

---

Dart

lambda 表达式，简单理解为匿名函数，它是“函数字面值”，即未声明的函数， 但立即做为表达式传递。闭包，简单理解为持有外部环境变量的函数。两者都是函数，并非所有的匿名函数都是闭包，也并非所有的闭包都是匿名的。

// 匿名函数标准形式 // ([[Type] param1[, …]]) { // codeBlock; // }; var list = ['apples', 'bananas', 'oranges']; list.forEach((item) { print('${list.indexOf(item)}: $item'); });

Kotlin

// Lambda 表达式标准形式 val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y } println(sum(1, 2))

// 拖尾 lambda 表达式
// 如果函数的最后一个参数是函数，那么作为相应参数传入的 lambda 表达式可以放在圆括号之外：
val product = items.fold(1) { acc, e -> acc * e }// 唯一参数 lambda 表达式
// 如果该 lambda 表达式是调用时唯一的参数，那么圆括号可以完全省略：
run { println(“…”) }

Swift

// 闭包表达式标准形式 // { (parameters) -> return type in // statements // } reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 })

// 拖尾闭包
// 如果函数的最后一个参数是函数，那么作为相应参数传入的闭包表达式可以放在圆括号之外：
reversedNames = names.sorted() {  >  }// 唯一参数闭包
// 如果该闭包是调用时唯一的参数，那么圆括号可以完全省略
reversedNames = names.sorted {  >  }

---