| Java 8 | C# 6 | Swift | |
| 变量 | 类型 变量名; | 类型 变量名; | var 变量名 : 类型; |
| 变量（类型推断） | N/A | var 变量名=初值; | var 变量名=初值; |
| 常量 | final 类型 常量名=初值; | readonly 类型 常量名=初值; | let 常量名 : 类型=初值; |
| 基本类型 |
int short long byte double float boolean char |
int short long byte double float bool char |
Int32 Int16 Int64 Int8 Double Float Bool Character |
| 字符串 | String 变量名=""; | string 变量名=""; | let 变量名 : String=""; |
| 字符串嵌入值 | N/A | "\{表达式}" | "\(表达式)" |
| 可变字符串 | StringBuilder | StringBuilder | var 变量名 : String; |
| 定常数组 | 类型[] 变量名={元素1,元素2}; | 类型[] 变量名={元素1,元素2}; | let 变量名 : 类型名[] = [元素1, 元素2]; |
| 变长数组（列表） | ArrayList<类型> | List<类型> | var 变量名=类型名[](); |
| 追加元素 | add | Add | append |
| 遍历 | for (类型 变量 : 集合) | foreach (类型 变量 in 集合) | for (变量 in 集合) |
| 字典 | TreeMap<键类型, 值类型> | Dictionary<键类型, 值类型> | Dictionary<键类型, 值类型> |
| 字典初始化 |
TreeMap<键类型, 值类型> 变量名 = new TreeMap<键类型, 值类型>() { { put(键1, 值1); put(键2, 值2); } }; |
var 变量名= new Dictionary<键类型, 值类型>() { [键1] = 值1, [键2] = 值2, }; |
var 变量名 : Dictionary<键类型, 值类型>= [ 键1 : 值1, 键2 : 值2 ]; |
| 字典下标 | N/A（使用get方法） | 变量名[键] | 变量名[键] |
| 定义函数（方法） | 返回类型 方法名(参数类型1 形参1, 参数类型2 形参2){} | 返回类型 方法名(参数类型1 形参1, 参数类型2 形参2=默认值){} | func 函数名(形参1 : 参数类型1, 外参名 形参2 : 参数类型2=默认值) -> 返回类型{} |
| 调用函数（方法） | 方法名(实参1, 实参2); | 方法名(实参1, 实参2); | 函数名(实参1, 外参名 : 实参2); |
| 可变参数 | 返回类型 方法名(参数类型… 形参){} | 返回类型 方法名(params 参数类型[] 形参){} | func 函数名(形参 : 参数类型...) -> 返回类型{} |
| 传出参数 | N/A，包在对象里面 |
返回类型 方法名(ref 参数类型 形参){} 返回类型 方法名(out 参数类型 形参){} |
func 函数名(inout 形参 : 参数类型) -> 返回类型{} |
| 调用传出参数 | N/A | 实参 | &实参 |
| 函数类型 | N/A，用单方法接口替代 | Action和Func系列泛型类 | (参数类型1, 参数类型2) –> 返回类型 |
| 闭包 |
(参数类型 形参) -> 表达式 () –> { |
(参数类型 形参) => 表达式 () => |
{ (形参: 参数类型) –> 返回类型 in 表达式} { () –>() in |
| 枚举 |
enum 类型名 { 枚举值1(值1), 枚举值2(值2), 枚举值3(值3); } |
enum 类型名 { 枚举值1=值1, 枚举值2=值2, 枚举值3=值3 } |
enum 类型名 { case 枚举值1=值1, 枚举值2=值2, 枚举值3=值3 } |
| 结构（值类型） | N/A | struct 结构名 { 成员 } | struct 结构名 { 成员 } |
| 类（引用类型） | class 类名 { 成员 } | class 类名 { 成员 } | class 类名 { 成员 } |
| 创建对象实例 | new 类名(实参1, 实参2) | new 类或结构名(实参1, 实参2) | 类或结构名(外参名1 : 实参1, 外参名2 : 实参2) |
| 静态成员 | static | static | 结构和枚举static，类和接口class |
| 访问级别 |
public，公有 protected，保护（包内和子类可访问） 无修饰符，默认（包内可访问） private，私有 |
public，公有 protected，保护（子类可访问） internal，内部（程序集内可访问） protected internal，内部保护（程序集内的子类可访问） private，私有 |
public，公有 internal，内部（模块内可访问） private，私有 |
| 存储属性 | N/A，get set前缀方法命名约定 | 类型 属性名 { get; set; }=初始值; | var 属性名 : 类型=初始值; |
| 计算属性 | N/A，get set前缀方法命名约定 |
类型 属性名 { get { } set { //形参为value } } |
var 属性名 : 类型 { get { } set(形参) { //如不写形参名，默认为newValue } } |
| 索引器（下标） | N/A |
返回类型 this[参数类型 形参] { |
subscript(形参 : 参数类型) –> 返回类型 { get { } set { //形参为newValue } } |
| 构造器 | 类名(参数类型 形参){} | 类名(参数类型 形参){} | init(形参 : 参数类型){} |
| 自身实例 | this | this | self |
| 调用其它构造器 |
类名() { this(实参); } |
类名() : this(实参) { } |
init() { self.init(外参名 : 实参); } |
| 继承 | class 派生类 extends 基类 { 成员 } | class 派生类 : 基类 { 成员 } | class 派生类 : 基类 { 成员 } |
| 调用基类构造器 |
派生类名(参数类型 参数) { super(参数); } |
派生类名(参数类型 参数) : base(参数) { } |
init(参数 : 参数类型) { super.init(外参名 : 参数); } |
| 虚函数 | 默认都可覆盖，不可覆盖标final | 标virtual可覆盖 | 默认都可覆盖, 不可覆盖标@final |
| 密封类 | final | sealed | @final |
| 覆盖（override） | 不加修饰，可加@Override | override | override |
| 调用基类方法 | super.方法(); | base.方法(); | super.方法(); |
| 类型检查 | 基类实例 instanceof 派生类型 | 基类实例 is 派生类型 | 基类实例 is 派生类型 |
| 向下转型 |
(派生类型)基类实例 |
(派生类型)基类实例 基类实例 as 派生类型 |
基类实例 as 派生类型 基类实例 as? 派生类型 |
| 接口 | interface | interface | protocol |
| 实现接口 | class 类 implement 接口 { 成员 } | class 类 : 接口 { 成员 } | class 类 : 接口 { 成员 } |
| 抽象类 | abstract | abstract | N/A |
| 扩展 | 接口的默认方法 | 扩展方法 | extension |
| 命名空间 | package | namespace | 按module |
时间： 2024-11-06 03:37:52