苏州seo网络优化公司欧美seo查询
移动端六大语言速记:第1部分 - 基础语法与控制结构
本文将对比Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的基础语法与控制结构,帮助开发者快速理解各语言间的差异与共性。
1. 基础语法
1.1 数据类型
各语言的基本数据类型对比:
语言 | 整数类型 | 浮点类型 | 字符串 | 布尔值 | 特殊类型 |
---|---|---|---|---|---|
Java | byte, short, int, long | float, double | String | boolean | char |
Kotlin | Byte, Short, Int, Long | Float, Double | String | Boolean | Char, Any, Unit, Nothing |
Dart | int | double | String | bool | dynamic, Symbol |
Python | int (无大小限制) | float | str | bool | None, complex |
ArkTS | number, byte, short, int, long | float, double | string | boolean | char, any |
Swift | Int, Int8, Int16, Int32, Int64 | Float, Double | String | Bool | Character, Any, AnyObject |
示例对比
Java:
int number = 10;
double price = 99.99;
String name = "Java";
boolean isActive = true;
char grade = 'A';
Kotlin:
val number: Int = 10
val price: Double = 99.99
val name: String = "Kotlin"
val isActive: Boolean = true
val grade: Char = 'A'
// 类型推断
val inferredNumber = 10 // 自动推断为Int类型
Dart:
int number = 10;
double price = 99.99;
String name = "Dart";
bool isActive = true;
// var关键字进行类型推断
var inferredNumber = 10; // 自动推断为int类型
Python:
number = 10 # 自动为int类型
price = 99.99 # 自动为float类型
name = "Python" # 自动为str类型
is_active = True # 布尔值首字母大写
ArkTS:
let number: number = 10;
let price: number = 99.99;
let name: string = "ArkTS";
let isActive: boolean = true;
// 类型推断
let inferredNumber = 10; // 自动推断为number类型
Swift:
let number: Int = 10
let price: Double = 99.99
let name: String = "Swift"
let isActive: Bool = true
// 类型推断
let inferredNumber = 10 // 自动推断为Int类型
1.2 变量与常量
各语言变量和常量的声明方式:
语言 | 变量声明 | 常量声明 | 类型声明位置 | 类型推断 |
---|---|---|---|---|
Java | type name; | final type name; | 类型在前 | 有限支持(Java 10+的var) |
Kotlin | var name: Type | val name: Type | 类型在后 | 完全支持 |
Dart | var name; 或 Type name; | final name; 或 const name; | 类型在前或省略 | 支持 |
Python | name = value | 无显式常量(约定用大写) | 无显式类型声明 | 默认行为 |
ArkTS | let name: Type | const name: Type | 类型在后 | 支持 |
Swift | var name: Type | let name: Type | 类型在后 | 完全支持 |
变量作用域对比
Java:
// 类级别变量
public class Example {private int classVar = 10; // 实例变量private static int staticVar = 20; // 静态变量public void method() {int localVar = 30; // 局部变量if (true) {int blockVar = 40; // 块级变量// blockVar只在if块内可用}// localVar在整个方法内可用}
}
Kotlin:
// 类级别变量
class Example {private val classVar = 10 // 实例变量companion object {private val staticVar = 20 // 类似Java静态变量}fun method() {val localVar = 30 // 局部变量if (true) {val blockVar = 40 // 块级变量// blockVar只在if块内可用}// localVar在整个方法内可用}
}
Dart:
// 类级别变量
class Example {int classVar = 10; // 实例变量static int staticVar = 20; // 静态变量void method() {int localVar = 30; // 局部变量if (true) {int blockVar = 40; // 块级变量// blockVar只在if块内可用}// localVar在整个方法内可用}
}
Python:
# 类级别变量
class Example:class_var = 10 # 类变量def __init__(self):self.instance_var = 20 # 实例变量def method(self):local_var = 30 # 局部变量if True:block_var = 40 # Python没有真正的块级作用域# block_var在整个方法内可用,这与其他语言不同
ArkTS:
// 类级别变量
class Example {private classVar: number = 10; // 实例变量private static staticVar: number = 20; // 静态变量method() {let localVar: number = 30; // 局部变量if (true) {let blockVar: number = 40; // 块级变量// blockVar只在if块内可用}// localVar在整个方法内可用}
}
Swift:
// 类级别变量
class Example {private var classVar = 10 // 实例变量private static var staticVar = 20 // 静态变量func method() {let localVar = 30 // 局部变量if true {let blockVar = 40 // 块级变量// blockVar只在if块内可用}// localVar在整个方法内可用}
}
1.3 运算符
各语言常见运算符对比:
运算符类型 | Java | Kotlin | Dart | Python | ArkTS | Swift |
---|---|---|---|---|---|---|
算术运算符 | +, -, *, /, %, ++, – | +, -, *, /, %, ++, – | +, -, *, /, ~/, %, ++, – | +, -, *, /, //, %, ** | +, -, *, /, %, ++, – | +, -, *, /, %, 无自增自减 |
比较运算符 | ==, !=, >, <, >=, <= | ==, !=, >, <, >=, <= | ==, !=, >, <, >=, <= | ==, !=, >, <, >=, <= | ==, !=, >, <, >=, <= | ==, !=, >, <, >=, <= |
逻辑运算符 | &&, ||, ! | &&, ||, ! | &&, ||, ! | and, or, not | &&, ||, ! | &&, ||, ! |
位运算符 | &, |, ^, ~, <<, >> | &, |, ^, ~, <<, >> | &, |, ^, ~, <<, >> | &, |, ^, ~, <<, >> | &, |, ^, ~, <<, >> | &, |, ^, ~, <<, >> |
赋值运算符 | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= | =, +=, -=, *=, /=, //=, %=, **=, &=, |=, ^= | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>= |
示例对比
Java:
// 算术运算符
int a = 10;
int b = 3;
int sum = a + b; // 13
int diff = a - b; // 7
int product = a * b; // 30
int quotient = a / b; // 3 (整数除法)
int remainder = a % b; // 1
a++; // a现在是11// 比较运算符
boolean isEqual = (a == b); // false
boolean isNotEqual = (a != b); // true
boolean isGreater = (a > b); // true// 逻辑运算符
boolean condition1 = true;
boolean condition2 = false;
boolean andResult = condition1 && condition2; // false
boolean orResult = condition1 || condition2; // true
boolean notResult = !condition1; // false
Kotlin:
// 算术运算符
val a = 10
val b = 3
val sum = a + b // 13
val diff = a - b // 7
val product = a * b // 30
val quotient = a / b // 3 (整数除法)
val remainder = a % b // 1
var c = a
c++ // c现在是11// 比较运算符
val isEqual = (a == b) // false
val isNotEqual = (a != b) // true
val isGreater = (a > b) // true// 逻辑运算符
val condition1 = true
val condition2 = false
val andResult = condition1 && condition2 // false
val orResult = condition1 || condition2 // true
val notResult = !condition1 // false// 特殊运算符
val obj: Any = "Kotlin"
val isString = obj is String // true
val str = obj as String // 类型转换
Dart:
// 算术运算符
int a = 10;
int b = 3;
int sum = a + b; // 13
int diff = a - b; // 7
int product = a * b; // 30
double quotient = a / b; // 3.3333... (浮点除法)
int intQuotient = a ~/ b; // 3 (整数除法)
int remainder = a % b; // 1
a++; // a现在是11// 比较运算符
bool isEqual = (a == b); // false
bool isNotEqual = (a != b); // true
bool isGreater = (a > b); // true// 逻辑运算符
bool condition1 = true;
bool condition2 = false;
bool andResult = condition1 && condition2; // false
bool orResult = condition1 || condition2; // true
bool notResult = !condition1; // false
Python:
# 算术运算符
a = 10
b = 3
sum_result = a + b # 13
diff = a - b # 7
product = a * b # 30
quotient = a / b # 3.3333... (浮点除法)
int_quotient = a // b # 3 (整数除法)
remainder = a % b # 1
power = a ** b # 1000 (幂运算)# 比较运算符
is_equal = (a == b) # False
is_not_equal = (a != b) # True
is_greater = (a > b) # True# 逻辑运算符
condition1 = True
condition2 = False
and_result = condition1 and condition2 # False
or_result = condition1 or condition2 # True
not_result = not condition1 # False
ArkTS:
// 算术运算符
let a: number = 10;
let b: number = 3;
let sum: number = a + b; // 13
let diff: number = a - b; // 7
let product: number = a * b; // 30
let quotient: number = a / b; // 3.3333... (浮点除法)
let remainder: number = a % b; // 1
a++; // a现在是11// 比较运算符
let isEqual: boolean = (a == b); // false
let isNotEqual: boolean = (a != b); // true
let isGreater: boolean = (a > b); // true// 逻辑运算符
let condition1: boolean = true;
let condition2: boolean = false;
let andResult: boolean = condition1 && condition2; // false
let orResult: boolean = condition1 || condition2; // true
let notResult: boolean = !condition1; // false// 特殊运算符
let obj: any = "ArkTS";
let isString: boolean = obj instanceof String; // 类型检查
let str: string = obj as string; // 类型转换
Swift:
// 算术运算符
let a = 10
let b = 3
let sum = a + b // 13
let diff = a - b // 7
let product = a * b // 30
let quotient = a / b // 3.333... (浮点除法)
let remainder = a % b // 1
// Swift没有自增自减运算符
var c = a
c += 1 // c现在是11// 比较运算符
let isEqual = (a == b) // false
let isNotEqual = (a != b) // true
let isGreater = (a > b) // true// 逻辑运算符
let condition1 = true
let condition2 = false
let andResult = condition1 && condition2 // false
let orResult = condition1 || condition2 // true
let notResult = !condition1 // false// 特殊运算符
let optionalValue: String? = "Swift"
let unwrappedValue = optionalValue ?? "默认值" // 空合运算符
let isString = optionalValue is String // 类型检查
if let str = optionalValue as? String { // 条件类型转换// 使用str
}
1.4 特殊操作符
各语言特殊操作符对比:
操作符类型 | Java | Kotlin | Dart | Python | ArkTS | Swift |
---|---|---|---|---|---|---|
条件操作符 | ? : | ? : | ? : | value if condition else other_value | ? : | ? : |
类型比较操作符 | instanceof | is, !is | is, is! | isinstance(), type() | instanceof | is, as, as? |
空安全操作符 | 无 | ?., ?:, !! | ?., ??, ??= | 无 | ?. | ?., ?? |
范围操作符 | 无 | …, until, downTo, step | … | range() | 无 | …, …< |
展开/收集操作符 | 无 | *, ** (用于函数参数) | … (展开), … (收集) | * (解包列表), ** (解包字典) | … (展开) | 无 |
示例对比
Java:
// 赋值操作符
int a = 10;
a += 5; // a = a + 5, 现在a是15// 条件操作符
int max = (a > 7) ? a : 7; // 如果a>7,max=a,否则max=7// 类型比较操作符
String str = "Hello";
boolean isString = str instanceof String; // true
Kotlin:
// 赋值操作符
var a = 10
a += 5 // a = a + 5, 现在a是15// 条件操作符
val max = if (a > 7) a else 7 // 如果a>7,max=a,否则max=7
// 或使用三元操作符语法
val max2 = if (a > 7) a else 7// 类型比较操作符
val str: Any = "Hello"
val isString = str is String // true
val notString = str !is String // false// 空安全操作符
val nullableStr: String? = "Kotlin"
val length = nullableStr?.length // 安全调用,如果nullableStr为null,则length为null
val nonNullLength = nullableStr?.length ?: 0 // Elvis操作符,如果左侧为null,则使用右侧值
val forcedLength = nullableStr!!.length // 非空断言,如果nullableStr为null,则抛出异常// 范围操作符
for (i in 1..5) { // 包含5println(i) // 打印1, 2, 3, 4, 5
}
for (i in 1 until 5) { // 不包含5println(i) // 打印1, 2, 3, 4
}
for (i in 5 downTo 1) { // 降序println(i) // 打印5, 4, 3, 2, 1
}
for (i in 1..10 step 2) { // 步长为2println(i) // 打印1, 3, 5, 7, 9
}
Dart:
// 赋值操作符
int a = 10;
a += 5; // a = a + 5, 现在a是15// 条件操作符
int max = (a > 7) ? a : 7; // 如果a>7,max=a,否则max=7// 类型比较操作符
var str = "Hello";
var isString = str is String; // true
var notString = str is! String; // false// 空安全操作符
String? nullableStr = "Dart";
int? length = nullableStr?.length; // 安全调用,如果nullableStr为null,则length为null
var nonNullStr = nullableStr ?? "Default"; // 如果nullableStr为null,则使用"Default"
nullableStr ??= "New Value"; // 如果nullableStr为null,则赋值为"New Value"// 级联操作符
var list = [1, 2];
list..add(3)..add(4); // 链式调用方法,list现在是[1, 2, 3, 4]// 展开操作符
var list1 = [1, 2, 3];
var list2 = [0, ...list1, 4]; // list2是[0, 1, 2, 3, 4]
Python:
# 赋值操作符
a = 10
a += 5 # a = a + 5, 现在a是15# 条件操作符(三元操作符)
max_val = a if a > 7 else 7 # 如果a>7,max_val=a,否则max_val=7# 类型比较操作符
str_val = "Hello"
is_string = isinstance(str_val, str) # True
type_check = type(str_val) == str # True# 解包操作符
list1 = [1, 2, 3]
list2 = [0, *list1, 4] # list2是[0, 1, 2, 3, 4]# 字典解包
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, **dict1} # dict2是{"c": 3, "a": 1, "b": 2}# 海象操作符(Python 3.8+)
if (n := len("hello")) > 3: # 赋值并使用nprint(f"Length is {n}")
ArkTS:
// 赋值操作符
let a: number = 10;
a += 5; // a = a + 5, 现在a是15// 条件操作符
let max: number = (a > 7) ? a : 7; // 如果a>7,max=a,否则max=7// 类型比较操作符
let str: any = "Hello";
let isString: boolean = str instanceof String; // 类型检查
let castedStr: string = str as string; // 类型转换// 空安全操作符
let nullableObj: Object | null = { name: "ArkTS" };
let name: string | undefined = nullableObj?.name; // 安全调用,如果nullableObj为null,则name为undefined// 展开操作符
let obj1 = { a: 1, b: 2 };
let obj2 = { ...obj1, c: 3 }; // obj2是{ a: 1, b: 2, c: 3 }
Swift:
// 赋值操作符
var a = 10
a += 5 // a = a + 5, 现在a是15// 条件操作符
let max = (a > 7) ? a : 7 // 如果a>7,max=a,否则max=7// 类型比较操作符
let anyValue: Any = "Hello"
let isString = anyValue is String // true// 类型转换操作符
if let str = anyValue as? String { // 条件类型转换print(str.count) // 安全地使用String方法
}
let forcedStr = anyValue as! String // 强制类型转换,如果失败会崩溃// 空安全操作符
let nullableStr: String? = "Swift"
let length = nullableStr?.count // 安全调用,如果nullableStr为null,则length为null
let nonNullLength = nullableStr ?? "Default" // 空合运算符,如果左侧为null,则使用右侧值// 范围操作符
for i in 1...5 { // 闭区间,包含5print(i) // 打印1, 2, 3, 4, 5
}
for i in 1..<5 { // 半开区间,不包含5print(i) // 打印1, 2, 3, 4
}
总结
本文对比了Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的基础语法,包括数据类型、变量与常量、运算符和特殊操作符。通过对比可以看出:
-
数据类型:各语言都支持基本的整数、浮点数、字符串和布尔类型,但在命名和特殊类型上有所差异。
-
变量与常量:Java和Dart使用类型在前的声明方式,而Kotlin、ArkTS和Swift使用类型在后的声明方式;Python则无需显式声明类型。
-
运算符:基本运算符在各语言中较为一致,但Python使用英文单词表示逻辑运算符,Swift没有自增自减运算符。
-
特殊操作符:Kotlin、Dart和Swift提供了丰富的空安全操作符;Kotlin和Swift有强大的范围操作符;Python和Dart支持解包操作。
在第2部分中,我们将继续探讨这六种语言的控制结构,包括条件语句、循环语句和异常处理等内容。