Kotlin常用语法糖详解（和java对比）

目录

  1. 变量声明与类型推断
  2. 空安全操作符
  3. 字符串模板
  4. 扩展函数
  5. Lambda表达式
  6. 数据类
  7. when表达式
  8. 区间操作符
  9. 解构声明
  10. 延迟初始化
  11. 伴生对象
  12. 初始化块

一、变量声明与类型推断

1. 说明

Kotlin支持类型推断，可以让编译器根据赋值自动推断变量类型，简化代码。

2. Kotlin代码示例

// 可变变量
var name = "Kotlin"
var age = 5

// 不可变变量（类似Java的final）
val pi = 3.14159
val languages = listOf("Java", "Kotlin", "Python")

// 显式声明类型（较少使用，通常用于复杂情况）
val message: String = "Hello World"
var count: Int = 0

3. 详细解释

  • var 用于声明可变变量，可以被重新赋值
  • val 用于声明不可变变量，一旦赋值就不能更改，类似于Java的final
  • Kotlin编译器会根据右侧的赋值自动推断变量类型，无需显式声明

4. 与Java对比

Java代码：

// 可变变量
String name = "Java";
int age = 25;

// 不可变变量
final double pi = 3.14159;
final List<String> languages = Arrays.asList("Java", "Kotlin", "Python");

Kotlin的优势：

  1. 类型推断减少了样板代码
  2. val关键字比final更简洁明确
  3. 类型声明放在变量名后面，符合现代语言设计趋势

二、空安全操作符

1. 说明

Kotlin的空安全是其最强大的特性之一，通过类型系统来处理空值，避免空指针异常。

2. Kotlin代码示例

// 不可为空的变量（默认）
var name: String = "Kotlin"
// name = null // 编译错误

// 可空变量
var nullableName: String? = "Kotlin"
nullableName = null // 合法

// 安全调用操作符 ?.
val length = nullableName?.length // 如果nullableName为null，返回null

// Elvis操作符 ?: 
val safeLength = nullableName?.length ?: 0 // 如果为null，返回默认值0

// 非空断言操作符 !!.（谨慎使用，可能抛出空指针异常）
val forcedLength = nullableName!!.length // 如果为null，抛出异常

// 安全类型转换 as?
val obj: Any = "Hello"
val str = obj as? String // 如果不能转换，返回null而不是抛出异常

3. 详细解释

  • Kotlin默认所有变量都是非空的，必须显式标记可为空的类型（添加?）
  • ?. 操作符在对象不为null时调用方法，否则返回null
  • ?: 操作符类似于三元运算符，当左侧表达式为null时使用右侧的值
  • !!. 操作符强制调用，若对象为null则抛出NullPointerException
  • as? 安全类型转换，失败时返回null

4. 与Java对比

Java代码：

String nullableName = "Java";

// 空检查样板代码
int length = 0;
if (nullableName != null) {
    length = nullableName.length();
} else {
    length = 0;
}

// 类型转换需额外检查
Object obj = "Hello";
String str = null;
if (obj instanceof String) {
    str = (String) obj;
}

三、字符串模板

1. 说明

Kotlin的字符串模板允许在字符串中嵌入表达式，无需拼接。

2. Kotlin代码示例

val name = "Kotlin"
val version = 1.8

// 基本用法
val message = "Hello, $name!"

// 嵌入表达式
val info = "$name version ${version + 0.2} is coming!"

// 多行字符串（使用三个引号）
val description = """Kotlin is a modern programming language
that makes developers happier."""

// 多行字符串与模板结合
val fullInfo = """Name: $name
Version: $version
Description: ${description.lines().first()}
"""

3. 详细解释

  • 使用$符号引用变量或表达式
  • 对于复杂表达式，需要用${}包裹
  • 三个引号(""")创建多行字符串，保留换行和缩进
  • 模板表达式在运行时求值

4. 与Java对比

Java代码：

String name = "Java";
double version = 17.0;

// 字符串拼接
String message = "Hello, " + name + "!";

// 复杂表达式拼接
String info = name + " version " + (version + 0.2) + " is coming!";

// 多行字符串（Java 15+支持）
String description = """Java is a programming language
that powers millions of applications.""";

// 格式化字符串
String formatted = String.format("Name: %s\nVersion: %.1f", name, version);

Kotlin的优势在于更简洁的语法和更强大的模板能力，特别是在复杂表达式和多行字符串场景下。

四、扩展函数

1. 说明

扩展函数允许在不修改原始类的情况下向现有类添加新函数，是Kotlin最受欢迎的特性之一。

2. Kotlin代码示例

// 为String类添加扩展函数
fun String.isPalindrome(): Boolean {
    val clean = this.lowercase().filter { it.isLetterOrDigit() }
    return clean == clean.reversed()
}

// 为Int类添加扩展函数
fun Int.isEven(): Boolean {
    return this % 2 == 0
}

// 使用扩展函数
val word = "Racecar"
println(word.isPalindrome()) // true

val number = 42
println(number.isEven()) // true

// 扩展属性
val String.lastChar: Char
    get() = this[this.length - 1]

println("Kotlin".lastChar) // 'n'

3. 详细解释

  • 扩展函数的声明形式为：fun 接收者类型.函数名(参数列表): 返回类型 { 函数体 }
  • 在扩展函数内部，可以使用this引用接收者对象
  • 扩展函数不会修改原始类的字节码，而是通过静态方法实现
  • 可以为任何类添加扩展，包括Java标准库类
  • 还可以定义扩展属性

4. 与Java对比

Java没有原生的扩展函数机制，通常的替代方案是：

// 工具类方式
public class StringUtils {
    public static boolean isPalindrome(String str) {
        String clean = str.toLowerCase().replaceAll("[^a-zA-Z0-9]", "");
        String reversed = new StringBuilder(clean).reverse().toString();
        return clean.equals(reversed);
    }
}

// 使用
boolean result = StringUtils.isPalindrome("Racecar");

Kotlin的扩展函数比Java的工具类更加直观和易用，代码可读性也更高。

五、Lambda表达式

1. 说明

Kotlin对函数式编程有很好的支持，Lambda表达式提供了简洁的函数表示方式。

2. Kotlin代码示例

// 基本Lambda表达式
val sum = { a: Int, b: Int -> a + b }
println(sum(3, 5)) // 8

// 作为函数参数
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) // [2, 4]

// it关键字（单个参数的隐式名称）
val doubled = numbers.map { it * 2 }
println(doubled) // [2, 4, 6, 8, 10]

// 末尾Lambda表达式（如果Lambda是最后一个参数，可以移到括号外）
numbers.forEach { println(it) }

// 使用下划线忽略参数
numbers.forEachIndexed { index, _ -> println("Index: $index") }

// 函数引用
val sorted = numbers.sortedByDescending(::abs)

3. 详细解释

  • Lambda表达式的基本形式：{ 参数列表 -> 函数体 }
  • 对于只有一个参数的Lambda，可以使用it作为隐式参数名
  • 如果Lambda是函数的最后一个参数，可以将其移到括号外
  • 可以使用::来引用已有的函数
  • Kotlin的标准库提供了丰富的高阶函数（如map、filter、forEach等）

4. 与Java对比

Java 8引入了Lambda表达式，但语法相对冗长：

// 基本Lambda表达式
BinaryOperator<Integer> sum = (a, b) -> a + b;
System.out.println(sum.apply(3, 5)); // 8

// 集合操作
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                  .filter(n -> n % 2 == 0)
                                  .collect(Collectors.toList());

// 方法引用
numbers.sort(Comparator.comparing(String::valueOf));

Kotlin的Lambda语法更加简洁，并且有更多的语法糖（如it关键字、末尾Lambda等）。

六、数据类

1. 说明

数据类用于存储数据，Kotlin自动为其生成equals()、hashCode()、toString()、copy()等标准方法。

2. Kotlin代码示例

// 声明数据类
data class User(val id: Int, val name: String, val email: String? = null)

// 创建实例
val user = User(1, "Alice", "alice@example.com")

// 自动生成的toString()
println(user) // User(id=1, name=Alice, email=alice@example.com)

// 解构声明
val (id, name, email) = user
println("$id, $name, $email") // 1, Alice, alice@example.com

// copy()方法（可以指定修改某些属性）
val updatedUser = user.copy(email = "alice.new@example.com")

// 组件函数（用于解构）
val component1 = user.component1() // 1
val component2 = user.component2() // "Alice"

3. 详细解释

  • 数据类使用data关键字标记
  • 主构造函数至少需要有一个参数
  • 参数通常使用val声明为不可变
  • Kotlin自动生成以下方法：
    • equals()：比较属性值相等性
    • hashCode()：基于属性计算哈希码
    • toString()：格式化输出所有属性
    • copy()：创建对象副本，可以修改指定属性
    • componentN()：用于解构声明的组件函数
  • 可以为数据类定义其他方法和属性

4. 与Java对比

Java中需要手动编写或使用IDE生成大量样板代码：

public class User {
    private final int id;
    private final String name;
    private final String email;
    
    // 构造函数
    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    // Getter方法
    public int getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    
    // equals()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && 
               Objects.equals(name, user.name) && 
               Objects.equals(email, user.email);
    }
    
    // hashCode()
    @Override
    public int hashCode() {
        return Objects.hash(id, name, email);
    }
    
    // toString()
    @Override
    public String toString() {
        return "User{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", email='" + email + '\'' +
               '}';
    }
    
    // Builder模式或复制方法
    public User withEmail(String newEmail) {
        return new User(id, name, newEmail);
    }
}

Kotlin的数据类大大减少了样板代码，提高了开发效率和代码可读性。

七、when表达式

1. 说明

when表达式是Kotlin中强大的条件控制结构，相当于Java的switch语句，但功能更强大。

2. Kotlin代码示例

// 基本用法
val x = 3
when (x) {
    1 -> println("One")
    2 -> println("Two")
    3, 4 -> println("Three or Four") // 多个值
    in 5..10 -> println("Between 5 and 10") // 区间
    else -> println("Other")
}

// 不带参数的when
val temperature = 25
val feeling = when {
    temperature < 0 -> "Freezing"
    temperature < 10 -> "Cold"
    temperature < 20 -> "Cool"
    temperature < 30 -> "Warm"
    else -> "Hot"
}

// 类型匹配
fun process(value: Any) {
    when (value) {
        is String -> println("Length: ${value.length}")
        is Int -> println("Square: ${value * value}")
        is List<*> -> println("Size: ${value.size}")
        else -> println("Unknown type")
    }
}

// 作为表达式返回值
val result = when (x) {
    in 1..10 -> "Small"
    in 11..100 -> "Medium"
    else -> "Large"
}

3. 详细解释

  • when可以带参数或不带参数
  • 分支条件可以是值、表达式、区间、类型等
  • 可以将多个条件合并到一个分支（用逗号分隔）
  • in操作符用于检查值是否在区间或集合中
  • is操作符用于类型检查
  • when可以作为表达式使用，返回最后一个表达式的值
  • 不需要break语句，每个分支执行完自动跳出

4. 与Java对比

Java的switch语句（Java 17）：

int x = 3;
switch (x) {
    case 1 -> System.out.println("One");
    case 2 -> System.out.println("Two");
    case 3, 4 -> System.out.println("Three or Four");
    default -> System.out.println("Other");
}

// Java 14引入的模式匹配预览
Object value = "Hello";
if (value instanceof String s) {
    System.out.println("Length: " + s.length());
}

Kotlin的when表达式比Java的switch更灵活、更强大，支持更多类型的条件和更简洁的语法。

八、区间操作符

1. 说明

Kotlin提供了简洁的区间表示和操作语法，使范围操作更加直观。

2. Kotlin代码示例

// 闭区间：包含起止值
val range1 = 1..5 // 1, 2, 3, 4, 5

// 半开区间：包含起始值，不包含结束值
val range2 = 1 until 5 // 1, 2, 3, 4

// 降序区间
val range3 = 5 downTo 1 // 5, 4, 3, 2, 1

// 步长
val range4 = 1..10 step 2 // 1, 3, 5, 7, 9

// 字符区间
val charRange = 'a'..'z'

// 检查值是否在区间内
val isInRange = 3 in range1 // true

// 区间迭代
for (i in 1..3) {
    println(i)
}

// 集合中的区间
val list = listOf(1, 2, 3, 4, 5)
val subList = list[1..3] // [2, 3, 4]

3. 详细解释

  • .. 创建闭区间（包含两端的值）
  • until 创建半开区间（包含起始值，不包含结束值）
  • downTo 创建降序区间
  • step 指定步长
  • in 操作符检查值是否在区间内
  • 区间可以用于任何实现了Comparable接口的类型
  • Kotlin的区间是闭包的，包含了大量有用的方法

4. 与Java对比

Java没有原生的区间类型，通常使用循环和条件判断：

// 普通循环
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

// 步长循环
for (int i = 1; i <= 10; i += 2) {
    System.out.println(i);
}

// 降序循环
for (int i = 5; i >= 1; i--) {
    System.out.println(i);
}

// 检查范围
boolean isInRange = x >= 1 && x <= 5;

Kotlin的区间语法更加直观和简洁，使代码更易读。

九、解构声明

1. 说明

解构声明允许将一个对象的多个属性同时赋值给多个变量，简化代码。

2. Kotlin代码示例

// 数据类解构
data class Person(val name: String, val age: Int)
val person = Person("Bob", 30)
val (name, age) = person
println("$name is $age years old")

// 集合解构
val pair = Pair("key", "value")
val (key, value) = pair

// 列表解构（最多支持5个元素）
val list = listOf(1, 2, 3, 4, 5)
val (first, second, third) = list

// 循环中的解构
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
for ((k, v) in map) {
    println("$k -> $v")
}

// 自定义解构（实现componentN()函数）
class Point(val x: Int, val y: Int) {
    operator fun component1() = x
    operator fun component2() = y
}
val point = Point(10, 20)
val (x, y) = point

3. 详细解释

  • 解构声明通过componentN()函数实现，其中N表示属性的位置
  • 数据类自动生成componentN()函数
  • 标准库中的Pair、Triple、Map.Entry等也支持解构
  • 可以在循环中使用解构
  • 可以通过实现componentN()函数使自定义类支持解构
  • 解构声明的变量个数可以少于对象的属性个数

4. 与Java对比

Java没有原生的解构功能，通常需要单独获取每个属性：

// 普通方式
Person person = new Person("Bob", 30);
String name = person.getName();
int age = person.getAge();

// 循环Map
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String k = entry.getKey();
    Integer v = entry.getValue();
    System.out.println(k + " -> " + v);
}

// Java 14+的record类
record Point(int x, int y) {}
Point point = new Point(10, 20);
int x = point.x();
int y = point.y();

Kotlin的解构声明提供了更简洁的语法来提取对象的多个属性。

十、延迟初始化

1. 说明

延迟初始化允许在声明变量时不立即初始化，而是在稍后需要时再初始化，避免了不必要的初始化开销。

2. Kotlin代码示例

// 使用lateinit延迟初始化（只能用于var，不能用于基本类型）
class MyService {
    lateinit var database: Database
    
    fun initialize() {
        database = Database()
    }
    
    fun useDatabase() {
        if (::database.isInitialized) { // 检查是否已初始化
            database.query()
        }
    }
}

// 使用lazy委托（用于val，线程安全）
class Config {
    val settings: Map<String, String> by lazy {
        println("Loading settings...")
        loadSettingsFromFile() // 首次访问时执行
    }
    
    private fun loadSettingsFromFile(): Map<String, String> {
        // 模拟加载配置
        return mapOf("app.name" to "MyApp", "app.version" to "1.0")
    }
}

// 自定义lazy线程模式
val data by lazy(LazyThreadSafetyMode.NONE) { expensiveOperation() }

3. 详细解释

  • lateinit用于可变变量(var)，不能用于基本类型
  • 必须确保在使用前初始化，否则会抛出UninitializedPropertyAccessException
  • 可以通过::变量名.isInitialized检查是否已初始化
  • by lazy用于不可变变量(val)，提供线程安全的延迟初始化
  • lazy默认是线程安全的(LazyThreadSafetyMode.SYNCHRONIZED)
  • 可以通过参数指定不同的线程安全模式
  • 初始化函数只在第一次访问时执行一次

4. 与Java对比

Java中实现延迟初始化需要手动编写更多代码：

// 简单的延迟初始化
private Database database;

public void initialize() {
    if (database == null) {
        database = new Database();
    }
}

public void useDatabase() {
    if (database != null) {
        database.query();
    } else {
        throw new IllegalStateException("Database not initialized");
    }
}

// 线程安全的延迟初始化（双重检查锁定）
private volatile Settings settings;

public Settings getSettings() {
    if (settings == null) {
        synchronized (this) {
            if (settings == null) {
                settings = loadSettingsFromFile();
            }
        }
    }
    return settings;
}

Kotlin的延迟初始化语法更加简洁和安全，减少了手动实现的错误风险。

十一、伴生对象

1. 说明

伴生对象（Companion Object）是Kotlin中实现类似Java静态成员的机制，它允许在类级别定义可以通过类名直接访问的成员。

2. Kotlin代码示例

// 基本伴生对象
class MyClass {
    companion object {
        // 伴生对象中的常量
        const val MAX_COUNT = 100
        
        // 伴生对象中的方法
        fun create(): MyClass {
            return MyClass()
        }
        
        // 伴生对象中的属性
        val version = "1.0"
    }
}

// 使用伴生对象成员
val instance = MyClass.create()
println(MyClass.MAX_COUNT) // 100
println(MyClass.version) // "1.0"

// 命名伴生对象
class AnotherClass {
    companion object Factory {
        fun create(): AnotherClass {
            return AnotherClass()
        }
    }
}

// 实现接口的伴生对象
interface Loggable {
    fun log(message: String)
}

class Service {
    companion object : Loggable {
        override fun log(message: String) {
            println("[Service] $message")
        }
    }
}

// 伴生对象的扩展函数
fun MyClass.Companion.isValid(value: Int): Boolean {
    return value > 0 && value <= MAX_COUNT
}

// 使用扩展函数
println(MyClass.isValid(50)) // true

3. 详细解释

  • 伴生对象使用companion object关键字声明
  • 伴生对象中的成员可以通过类名直接访问，不需要创建类的实例
  • 可以在伴生对象中定义常量、变量、方法和初始化代码
  • 可以为伴生对象命名（默认为Companion）
  • 伴生对象可以实现接口
  • 可以为伴生对象定义扩展函数
  • 伴生对象在编译后会生成一个静态嵌套类

4. 与Java对比

Java代码：

public class MyClass {
    // 静态常量
    public static final int MAX_COUNT = 100;
    
    // 静态变量
    private static String version = "1.0";
    
    // 静态方法
    public static MyClass create() {
        return new MyClass();
    }
    
    // 静态getter
    public static String getVersion() {
        return version;
    }
}

// 使用静态成员
MyClass instance = MyClass.create();
System.out.println(MyClass.MAX_COUNT);
System.out.println(MyClass.getVersion());

// 静态嵌套类实现工厂方法
public class AnotherClass {
    public static class Factory {
        public static AnotherClass create() {
            return new AnotherClass();
        }
    }
}

Kotlin的伴生对象相比Java的静态成员具有更多优势：

  1. 可以实现接口
  2. 可以被扩展
  3. 可以访问外部类的私有成员
  4. 更加面向对象，符合Kotlin的设计理念

十二、初始化块

1. 说明

初始化块（init{}）是Kotlin中用于在创建类实例时执行初始化代码的代码块，它可以与构造函数配合使用，实现更复杂的初始化逻辑。

2. Kotlin代码示例

// 基本初始化块
class Person {
    val name: String
    val age: Int
    private val isValid: Boolean
    
    // 主构造函数
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
        this.isValid = name.isNotBlank() && age >= 0
    }
    
    // 初始化块
    init {
        println("Creating person: $name, $age")
        if (!isValid) {
            println("Warning: Invalid person data!")
        }
    }
}

// 主构造函数参数与初始化块
class Car(val brand: String, model: String) {
    val fullName: String
    
    // 初始化块可以使用主构造函数的参数
    init {
        fullName = "$brand $model"
    }
    
    // 多个初始化块按顺序执行
    init {
        println("Car created: $fullName")
    }
}

// 初始化块与属性初始化器
class Rectangle(width: Double, height: Double) {
    val width: Double = if (width > 0) width else {
        println("Invalid width, using default")
        1.0
    }
    
    val height: Double = if (height > 0) height else {
        println("Invalid height, using default")
        1.0
    }
    
    val area: Double
    
    init {
        area = width * height
        println("Rectangle area: $area")
    }
}

// 二级构造函数与初始化块
class Student {
    val name: String
    val id: String
    val grade: Int
    
    // 初始化块（会在所有构造函数之前执行）
    init {
        println("Initializing student")
    }
    
    // 主构造函数
    constructor(name: String, id: String) {
        this.name = name
        this.id = id
        this.grade = 1
        println("Primary constructor called")
    }
    
    // 二级构造函数
    constructor(name: String, id: String, grade: Int) : this(name, id) {
        this.grade = grade
        println("Secondary constructor called")
    }
}

3. 详细解释

  • 初始化块使用init关键字标记
  • 初始化块在创建类实例时执行，无论使用哪个构造函数
  • 如果有多个初始化块，它们按在代码中出现的顺序执行
  • 初始化块可以访问主构造函数的参数
  • 属性初始化器和初始化块的执行顺序与它们在代码中出现的顺序一致
  • 初始化块在二级构造函数委托给主构造函数后执行
  • 初始化块常用于执行验证、日志记录、复杂的属性计算等

4. 与Java对比

Java代码：

public class Person {
    private final String name;
    private final int age;
    private final boolean isValid;
    
    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.isValid = name != null && !name.isEmpty() && age >= 0;
        
        // 构造函数中的初始化代码
        System.out.println("Creating person: " + name + ", " + age);
        if (!isValid) {
            System.out.println("Warning: Invalid person data!");
        }
    }
}

// 静态初始化块（类加载时执行）
public class Config {
    public static final String VERSION;
    
    static {
        VERSION = "1.0";
        System.out.println("Config class initialized");
    }
}

Kotlin的初始化块相比Java的构造函数初始化代码具有以下优势：

  1. 可以将初始化逻辑分散到多个初始化块中，使代码结构更清晰
  2. 初始化块与属性初始化器按顺序执行，便于控制初始化流程
  3. 提供了更灵活的初始化机制，特别是在处理多个构造函数的情况下

Kotlin的伴生对象初始化块相当于Java的静态初始化块。

# java # kotlin
Logo
开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

【Flutter For OpenHarmony第三方库】Flutter 三方库 lottie 的鸿蒙化适配指南

lottie 在 Flutter for OpenHarmony 平台上的适配过程比想象中顺利得多！作为一个基于 Flutter Canvas 实现的库，它完美继承了 Flutter 引擎的跨平台特性，在鸿蒙设备上表现出色。体积优化：用三十五 KB 的 JSON 文件替代了原本两百多 MB 的帧序列图，体积减少了百分之九十九点九八开发效率：设计师导出动画后，开发者只需一行代码就能集成，开发周期从三

avatar 开源鸿蒙跨平台开发者社区

Flutter 三方库 flutter_view_trailer 的鸿蒙化适配指南

嘿，各位开发者小伙伴们！今天要跟大家分享一个超级有趣的话题——如何在鸿蒙设备上实现炫酷的页面转场效果！想象一下，当用户点击一个按钮，页面不是干巴巴地跳转，而是像变魔术一样优雅地过渡，是不是瞬间感觉应用的高级感拉满了？作为一名在 Flutter 和鸿蒙双平台摸爬滚打的开发者，我最近接到了一个颇具挑战的任务：将 flutter_view_trailer 这个页面转场预览库适配到 OpenHarmony

avatar 开源鸿蒙跨平台开发者社区
cover

Flutter for OpenHarmony三方库适配实战：share_plus 分享功能

avatar 开源鸿蒙跨平台开发者社区