移动端六大语言速记：第5部分 - 面向对象编程（OOP）
移动端六大语言速记：第5部分 - 面向对象编程（OOP）
本文对比Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的面向对象编程特性，帮助开发者快速掌握各语言的语法差异。
5. 面向对象编程（OOP）
5.1 类与对象
各语言类与对象的语法对比：
| 语言 | 类定义 | 构造函数 | 实例化 | 属性访问 |
|---|---|---|---|---|
| Java | class ClassName {...} |
ClassName() {...} |
new ClassName() |
object.property |
| Kotlin | class ClassName {...} |
constructor(...) {...} |
ClassName() |
object.property |
| Dart | class ClassName {...} |
ClassName() {...} |
ClassName() |
object.property |
| Python | class ClassName: |
def __init__(self): |
ClassName() |
object.property |
| ArkTS | class ClassName {...} |
constructor(...) {...} |
new ClassName() |
object.property |
| Swift | class ClassName {...} |
init() {...} |
ClassName() |
object.property |
示例对比
Java:
// 类定义
public class Person {
// 属性
private String name;
private int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 无参构造函数
public Person() {
this.name = "Unknown";
this.age = 0;
}
// Getter和Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 方法
public void introduce() {
System.out.println("My name is " + name + " and I am " + age + " years old.");
}
}
// 使用类
public class Main {
public static void main(String[] args) {
// 实例化对象
Person person1 = new Person("Alice", 25);
Person person2 = new Person();
// 访问方法
person1.introduce(); // 输出: My name is Alice and I am 25 years old.
person2.introduce(); // 输出: My name is Unknown and I am 0 years old.
// 使用Setter修改属性
person2.setName("Bob");
person2.setAge(30);
person2.introduce(); // 输出: My name is Bob and I am 30 years old.
}
}
Kotlin:
// 类定义（主构造函数在类头部）
class Person(private var name: String, private var age: Int) {
// 次构造函数
constructor() : this("Unknown", 0)
// 属性可以直接在主构造函数中声明并初始化
// Kotlin自动为属性生成getter和setter（对于var）
// 方法
fun introduce() {
println("My name is $name and I am $age years old.")
}
}
// 使用类
fun main() {
// 实例化对象（不需要new关键字）
val person1 = Person("Alice", 25)
val person2 = Person()
// 访问方法
person1.introduce() // 输出: My name is Alice and I am 25 years old.
person2.introduce() // 输出: My name is Unknown and I am 0 years old.
// 使用自动生成的setter修改属性
// 如果属性是private，需要提供自定义的setter
// 这里假设我们将属性改为public或提供了setter
person2.name = "Bob" // 假设有setter
person2.age = 30 // 假设有setter
person2.introduce() // 输出: My name is Bob and I am 30 years old.
}
Dart:
// 类定义
class Person {
// 属性
String name;
int age;
// 构造函数
Person(this.name, this.age); // 简洁的语法直接初始化属性
// 命名构造函数
Person.unknown() {
name = "Unknown";
age = 0;
}
// 方法
void introduce() {
print('My name is $name and I am $age years old.');
}
}
// 使用类
void main() {
// 实例化对象（不需要new关键字，但可以使用）
var person1 = Person("Alice", 25);
var person2 = Person.unknown();
// 访问方法
person1.introduce(); // 输出: My name is Alice and I am 25 years old.
person2.introduce(); // 输出: My name is Unknown and I am 0 years old.
// 直接修改属性（Dart默认提供公共访问）
person2.name = "Bob";
person2.age = 30;
person2.introduce(); // 输出: My name is Bob and I am 30 years old.
}
Python:
# 类定义
class Person:
# 构造函数
def __init__(self, name=None, age=None):
self.name = name if name else "Unknown"
self.age = age if age else 0
# 方法
def introduce(self):
print(f"My name is {
self.name} and I am {
self.age} years old.")
# 使用类
if __name__ == "__main__":
# 实例化对象
person1 = Person("Alice", 25)
person2 = Person()
# 访问方法
person1.introduce() # 输出: My name is Alice and I am 25 years old.
person2.introduce() # 输出: My name is Unknown and I am 0 years old.
# 直接修改属性（Python默认提供公共访问）
person2.name = "Bob"
person2.age = 30
person2.introduce() # 输出: My name is Bob and I am 30 years old.
ArkTS:
// 类定义
class Person {
// 属性
private name: string;
private age: number;
// 构造函数
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
// 静态方法创建默认实例
static createUnknown(): Person {
return new Person("Unknown", 0);
}
// Getter和Setter方法
getName(): string {
return this.name;
}
setName(name: string): void {
this.name = name;
}
getAge(): number {
return this.age;
}
setAge(age: number): void {
this.age = age;
}
// 方法
introduce(): void {
console.log(`My name is ${
this.name} and I am ${
this.age} years old.`);
}
}
// 使用类
function main(): void {
// 实例化对象
let person1 = new Person("Alice", 25);
let person2 = Person.createUnknown();
// 访问方法
person1.introduce(); // 输出: My name is Alice and I am 25 years old.
person2.introduce(); // 输出: My name is Unknown and I am 0 years old.
// 使用Setter修改属性
person2.setName("Bob");
person2.setAge(30);
person2.introduce(); // 输出: My name is Bob and I am 30 years old.
}
Swift:
// 类定义
class Person {
// 属性
private var name: String
private var age: Int
// 构造函数
init(name: String, age: Int) {
self.name = name
self.age = age
}
// 便利构造函数
convenience init() {
self.init(name: "Unknown", age: 0)
}
// 方法
func introduce() {
print("My name is \(name) and I am \(age) years old.")
}
// Getter和Setter（Swift中通常使用计算属性）
func getName() -> String {
return name
}
func setName(_ name: String) {
self.name = name
}
func getAge() -> Int {
return age
}
func setAge(_ age: Int) {
self.age = age
}
}
// 使用类
func main() {
// 实例化对象
let person1 = Person(name: "Alice", age: 25)
let person2 = Person()
// 访问方法
person1.introduce() // 输出: My name is Alice and I am 25 years old.
person2.introduce() // 输出: My name is Unknown and I am 0 years old.
// 使用Setter修改属性
person2.setName("Bob")
person2.setAge(30)
person2.introduce() // 输出: My name is Bob and I am 30 years old.
}
5.2 继承
各语言继承的语法对比：
| 语言 | 继承语法 | 方法重写 | 调用父类方法 | 多重继承 |
|---|---|---|---|---|
| Java | class Child extends Parent |
@Override |
super.method() |
不支持，但可实现多接口 |
| Kotlin | class Child : Parent() |
override fun |
super.method() |
不支持，但可实现多接口 |
| Dart | class Child extends Parent |
@override |
super.method() |
不支持，但可实现多接口和mixin |
| Python | class Child(Parent): |
直接重写 | super().method() |
支持 |
| ArkTS | class Child extends Parent |
override |
super.method() |
不支持，但可实现多接口 |
| Swift | class Child: Parent |
override func |
super.method() |
不支持，但可实现多协议 |
示例对比
Java:
// 父类
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void makeSound() {
System.out.println("Some generic sound");
}
}
// 子类
public class Dog extends Animal {
private String breed;
public Dog(String name, String breed) {
super(name); // 调用父类构造函数
this.breed = breed;
}
@Override // 方法重写
public void makeSound() {
System.out.println("Woof! Woof!");
}
public void makeSound(boolean loud) {
// 方法重载
if