| | 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[参数类型 形参] {
get
{
}
set
{ //形参为value
}
} | 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 |
客服电话
APP下载
官方微信
请发表评论