kotlin的密封类

已于 2024-09-17 14:56:19 修改
阅读量775 收藏 6
点赞数 20
分类专栏： kotlin学习 文章标签： kotlin 开发语言 android
于 2024-09-17 09:24:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wulong756273/article/details/142310629
版权

引言

密封类是一种特殊的类，它用来表示受限的类继承结构，即一个类只能有有限的几种子类，而不能有任何其他类型的子类。

这不就是JAVA的枚举么。

概念

密封类使用sealed关键字声明，

在Kotlin 1.0中，密封类的所有子类必须嵌套在密封类内部；

在Kotlin 1.1中，这个限制放宽了，允许将子类定义在同一个文件中；

在Kotlin 1.5中，这个限制进一步放宽了，允许将子类定义在任何地方，只要保证子类可见性不高于父类。

密封类通常用于代替枚举类。密封类的优点在于可以更灵活地定义子类，而枚举类的每个成员都是固定的。密封类还可以帮助你编写更加类型安全的代码。

密封类最大的优点是可以配合when表达式实现完备性检查（exhaustive check），即编译器可以检测出是否覆盖了所有可能的分支情况，如果没有则会报错或提示警告。这样可以避免遗漏某些情况导致逻辑错误或运行时异常。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

很抽象。

密封类和枚举的区别是什么？

相同点：所有成员都属于本类本身

不同点：枚举只能有一个实例，而密封类的子类可以有多个实例。

密封类的子类可以携带自己独有的状态参数以及行为方法来记录更多的实现信息以完成更多的功能，这是枚举类所不具备的。

例子：

sealed class MyScore {
 
    object FAIL_A_GRADE : MyScore()//分数差
    object PASS_THE_MARK : MyScore()//分数及格
    object SCORE_WELL : MyScore()//分数良好
    class EXCELLENT_MARKS(val name: String) : MyScore()//分数优秀
 
}

密封类的所有成员都继承本类MyScore ，但是允许个别成员拥有自己特殊属性如 EXCELLENT_MARKS 。

三、使用

密封类的代数数据类型

密封类与 when结合，使用 is 进行判断类型，跟枚举类相似

fun show() = when (myScore) {
        is MyScore.FAIL_A_GRADE -> "分数差"
        is MyScore.PASS_THE_MARK -> "分数及格"
        is MyScore.SCORE_WELL -> "分数良好"
        is MyScore.EXCELLENT_MARKS -> "分数优秀，name=${myScore.name}"
        
    }

密封类实例

当某个成员需要特殊属性的时候，用枚举就比较难实现这个需求，密封类就是为了解决这个问题而出现的。

如下实例：当我们想知道优秀学生的名字的时候，只用枚举去实现就不好实现

//密封类，所有成员都继承本类
//当某个成员需要特殊属性的时候，用枚举就比较难实现这个需求
sealed class MyScore {
 
    object FAIL_A_GRADE : MyScore()//分数差
    object PASS_THE_MARK : MyScore()//分数及格
    object SCORE_WELL : MyScore()//分数良好
    class EXCELLENT_MARKS(val name: String) : MyScore()//分数优秀
 
}
 
 
class Teachers(private val myScore: MyScore) {
 
    fun show() = when (myScore) {
 
        is MyScore.FAIL_A_GRADE -> "分数差"
        is MyScore.PASS_THE_MARK -> "分数及格"
        is MyScore.SCORE_WELL -> "分数良好"
        is MyScore.EXCELLENT_MARKS -> "分数优秀，name=${myScore.name}"
 
    }
 
}
 
//todo kotlin语言的密封类学习
fun main() {
    println(Teachers(MyScore.FAIL_A_GRADE).show())
    println(Teachers(MyScore.EXCELLENT_MARKS("kotlin")).show())
 
}

输出：

分数差
分数优秀，name=kotlin

四、密封类与设计模式

1.状态模式

状态模式是一种行为型设计模式，它允许一个对象在其内部状态改变时改变它的行为。状态模式将状态封装成独立的类，并将请求委托给当前的状态对象，从而实现状态的切换和行为的变化。

1.1kotlin实现

密封类可以表示一个有限的状态集合，而且可以在when表达式中进行完备的检查，不需要使用else分支。例如，假设有一个电灯类，它有两种状态：开和关，每种状态下可以执行不同的操作。可以用以下的代码来实现：

// 定义一个密封类表示状态
sealed class State {
    // 定义一个抽象方法表示操作
    abstract fun operate()
}

// 定义一个开状态的子类，继承自State
class On : State() {
    // 重写操作方法，打印信息并切换到关状态
    override fun operate() {
        println("The light is on, turn it off.")
        Light.state = Off()
    }
}

// 定义一个关状态的子类，继承自State
class Off : State() {
    // 重写操作方法，打印信息并切换到开状态
    override fun operate() {
        println("The light is off, turn it on.")
        Light.state = On()
    }
}

// 定义一个电灯类，它有一个状态属性，初始为关状态
object Light {
    var state: State = Off()

    // 定义一个方法，根据当前状态执行操作
    fun switch() {
        state.operate()
    }
}

// 测试代码
fun main() {
    // 创建一个电灯对象
    val light = Light
    // 调用switch方法，根据当前状态执行操作
    light.switch() // The light is off, turn it on.
    light.switch() // The light is on, turn it off.
    light.switch() // The light is off, turn it on.
}
1.2java实现

在java中，实现状态模式的一种方式是使用枚举类，因为枚举类也可以表示一个有限的状态集合，而且可以实现接口或抽象类，从而定义不同的行为。例如，用java实现上面的例子，可以用以下的代码：

// 定义一个接口表示状态
interface State {
    // 定义一个抽象方法表示操作
    void operate();
}

// 定义一个枚举类表示状态，实现State接口
enum LightState implements State {
    // 定义两个枚举常量，分别表示开和关状态
    // 在每个枚举常量的构造器中，传入一个State对象，表示该状态下的行为
    ON(new State() {
        // 重写操作方法，打印信息并切换到关状态
        @Override
        public void operate() {
            System.out.println("The light is on, turn it off.");
            Light.state = OFF;
        }
    }),
    OFF(new State() {
        // 重写操作方法，打印信息并切换到开状态
        @Override
        public void operate() {
            System.out.println("The light is off, turn it on.");
            Light.state = ON;
        }
    });

    // 定义一个私有的State属性，表示该枚举常量对应的状态对象
    private final State state;

    // 定义一个私有的构造器，接收一个State对象作为参数，赋值给state属性
    private LightState(State state) {
        this.state = state;
    }

    // 定义一个公共的方法，调用state属性的operate方法
    public void operate() {
        state.operate();
    }
}

// 定义一个电灯类，它有一个状态属性，初始为关状态
class Light {
    // 定义一个静态的LightState属性，表示电灯的状态，初始为OFF
    public static LightState state = LightState.OFF;

    // 定义一个方法，根据当前状态执行操作
    public void switch() {
        state.operate();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建一个电灯对象
        Light light = new Light();
        // 调用switch方法，根据当前状态执行操作
        light.switch(); // The light is off, turn it on.
        light.switch(); // The light is on, turn it off.
        light.switch(); // The light is off, turn it on.
    }
}

可以看出，使用kotlin的密封类实现状态模式的优点是：

  • 代码更简洁，不需要定义接口或抽象类，也不需要使用匿名内部类
  • 代码更安全，不需要担心在其他地方出现未知的状态，也不需要使用else分支处理默认情况
  • 代码更易读，可以清楚地看出状态之间的层次关系和转换逻辑

使用java的枚举类实现状态模式的优点是：

  • 代码更统一，不需要在不同的类中定义状态，也不需要使用对象来表示状态
  • 代码更高效，不需要创建多个状态对象，也不需要使用多态来调用操作方法

2. 访问者模式

访问者模式是一种行为型设计模式，它允许在不修改已有类的结构的情况下，定义作用于这些类的新操作。访问者模式将元素的结构和元素的操作分离，使得操作可以根据不同的元素类型而变化。

2.1kotlin实现

在kotlin中，可以使用密封类来实现访问者模式，因为密封类可以表示一个有限的元素集合，而且可以在when表达式中进行完备的检查，不需要使用else分支。例如，假设有一个表达式类，它有两种子类：数字和加法，每种子类都可以被访问者访问，执行不同的操作。可以用以下的代码来实现：

// 定义一个密封类表示表达式
sealed class Expr {
    // 定义一个抽象方法表示接受访问者的访问
    abstract fun <R> accept(visitor: Visitor<R>): R
}
    // 定义一个数字的子类，继承Expr类，有一个value属性表示数字的值
    data class Num(val value: Int) : Expr() {
        // 重写accept方法，调用访问者的visitNum方法，传入自己作为参数
        override fun <R> accept(visitor: Visitor<R>): R {
            return visitor.visitNum(this)
        }
    }

    // 定义一个加法的子类，继承Expr类，有两个Expr属性表示左右操作数
    data class Sum(val left: Expr, val right: Expr) : Expr() {
        // 重写accept方法，调用访问者的visitSum方法，传入自己作为参数
        override fun <R> accept(visitor: Visitor<R>): R {
            return visitor.visitSum(this)
        }
    }

    // 定义一个访问者接口，泛型参数R表示访问的结果类型
    interface Visitor<R> {
        // 定义一个访问数字的方法，接收一个Num对象作为参数，返回一个R类型的结果
        fun visitNum(num: Num): R
        // 定义一个访问加法的方法，接收一个Sum对象作为参数，返回一个R类型的结果
        fun visitSum(sum: Sum): R
    }

    // 定义一个求值的访问者类，实现Visitor接口，泛型参数为Int
    class EvalVisitor : Visitor<Int> {
        // 重写访问数字的方法，返回数字的值
        override fun visitNum(num: Num): Int {
            return num.value
        }
        // 重写访问加法的方法，返回左右操作数的求值结果的和
        override fun visitSum(sum: Sum): Int {
            return sum.left.accept(this) + sum.right.accept(this)
        }
    }

    // 定义一个打印的访问者类，实现Visitor接口，泛型参数为String
    class PrintVisitor : Visitor<String> {
        // 重写访问数字的方法，返回数字的字符串表示
        override fun visitNum(num: Num): String {
            return num.value.toString()
        }
        // 重写访问加法的方法，返回加法的字符串表示，用括号括起来
        override fun visitSum(sum: Sum): String {
            return "(${sum.left.accept(this)} + ${sum.right.accept(this)})"
        }
    }

    // 测试代码
    fun main() {
        // 创建一个表达式对象，表示1 + (2 + 3)
        val expr = Sum(Num(1), Sum(Num(2), Num(3)))
        // 创建一个求值的访问者对象
        val evalVisitor = EvalVisitor()
        // 创建一个打印的访问者对象
        val printVisitor = PrintVisitor()
        // 调用表达式的accept方法，传入求值的访问者，打印求值的结果
        println(expr.accept(evalVisitor)) // 6
        // 调用表达式的accept方法，传入打印的访问者，打印表达式的字符串表示
        println(expr.accept(printVisitor)) // (1 + (2 + 3))
    }

可以看出，使用kotlin的密封类实现访问者模式的优点是：

  • 代码更简洁，不需要定义抽象方法或接口，也不需要使用类型转换或类型检查
  • 代码更安全，不需要担心在其他地方出现未知的表达式类型，也不需要使用else分支处理默认情况
  • 代码更易读，可以清楚地看出表达式之间的层次关系和访问者的操作逻辑
2.2 java实现
// 抽象元素
interface Animal {
    void accept(Visitor visitor); // 接受一个抽象访问者
}

// 具体元素Lion
class Lion implements Animal {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this); // 调用具体访问者对自己进行操作
    }

    public String roar() {
        return "Roar!";
    }
}

// 具体元素Tiger
class Tiger implements Animal {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this); // 调用具体访问者对自己进行操作
    }

    public String growl() {
        return "Growl!";
    }
}

// 具体元素Elephant
class Elephant implements Animal {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this); // 调用具体访问者对自己进行操作
    }

    public String trumpet() {
        return "Trumpet!";
    }
}

// 抽象访问者
interface Visitor {
    void visit(Lion lion); // 访问具体元素Lion

    void visit(Tiger tiger); // 访问具体元素Tiger

    void visit(Elephant elephant); // 访问具体元素Elephant
}

// 具体访问者Feed
class Feed implements Visitor {
  @Override 
  public void visit(Lion lion) { 
      System.out.println("Feed the lion with meat.");
  } 

  @Override 
  public void visit(Tiger tiger) { 
      System.out.println("Feed the tiger with chicken.");
  } 

  @Override 
  public void visit(Elephant elephant) { 
      System.out.println("Feed the elephant with banana.");
  } 
}

// 具体访问者Observe
class Observe implements Visitor { 
  @Override 
  public void visit(Lion lion) { 
      System.out.println("Observe the lion: " + lion.roar());
  } 

  @Override 
  public void visit(Tiger tiger) { 
      System.out.println("Observe the tiger: " + tiger.growl());
  } 

  @Override 
  public void visit(Elephant elephant) { 
      System.out.println("Observe the elephant: " + elephant.trumpet());
  }  
}

// 具体访问者Train
class Train implements Visitor {  
   @Override  
   public void visit(Lion lion) {  
       System.out.println("Train the lion to jump through a hoop.");  
   }  

   @Override  
   public void visit(Tiger tiger) {  
       System.out.println("Train the tiger to stand on a ball.");  
   }  

   @Override  
   public void visit(Elephant elephant) {  
       System.out.println("Train the elephant to sit on a stool.");  
   }   
}  

// 对象结构类Zoo

class Zoo {

 private List<Animal> animals = new ArrayList<>();

 // 添加一个新动物   
public void add(Animal animal) {   
     animals.add(animal);   
}   

 // 移除一个已有动物   
public void remove(Animal animal) {   
     animals.remove(animal);   
}   

 // 接受一个抽象访问者，并将所有动物传递给它进行处理    
public void accept(Visitor visitor) {    
     for (Animal animal : animals) {    
         animal.accept(visitor);    
     }    
}   
}

测试代码：

public class Test {

   public static void main(String[] args) {

       Zoo zoo = new Zoo();

       zoo.add(new Lion());
       zoo.add(new Tiger());
       zoo.add(new Elephant());

       Visitor feed = new Feed();
       Visitor observe = new Observe();
       Visitor train = new Train();

       zoo.accept(feed);
       zoo.accept(observe);
       zoo.accept(train);
   }
}

运行测试代码并显示输出结果：

Feed the lion with meat.
Feed the tiger with chicken.
Feed the elephant with banana.
Observe the lion: Roar!
Observe the tiger: Growl!
Observe the elephant: Trumpet!
Train the lion to jump through a hoop.
Train the tiger to stand on a ball.
Train the elephant to sit on a stool.

五、与final类对比

特性密封类final类
可继承性部分可继承，只能被指定的类继承不可继承
受保护成员或虚成员不允许，因为密封类的子类必须是密封类或final类允许，因为final类没有子类
抽象性允许，因为密封类可以是抽象的或具体的不允许，因为抽象类必须被继承
相似之处都是限制类的继承，都不能声明为抽象的，都可以继承别的类或接口都是限制类的继承，都不能声明为抽象的，都可以继承别的类或接口
不同之处可以指定哪些类可以作为其子类，可以实现多态性，可以用于一些特定的设计模式不能有任何子类，不能实现多态性，不能用于一些特定的设计模式
优点可以保证封装性和多态性，可以提高代码的可读性和可维护性，可以避免不必要的继承或实现可以保证封装性和不变性，可以提高代码的执行效率，可以避免类的滥用
缺点可能增加代码的复杂度和冗余，可能限制类的扩展性和灵活性，可能与一些框架或库不兼容可能增加代码的耦合度和僵化度，可能限制类的扩展性和灵活性，可能与一些框架或库不兼容
应用场景可以用于实现一些特定的设计模式，例如状态模式、策略模式、访问者模式等，这些模式需要明确地定义一组有限的子类或实现类可以用于实现一些不需要继承的类，例如工具类、常量类、单例类等，这些类需要保证其不变性和唯一性


六、应用

如果说，我们一个需求，控制档位，有两种模式，一种是inch 一种是mm。怎么表达？

我们想到是两个数组一一对应，如果java写就是枚举。

public class Test {
    public static void main(String[] args) {
        System.out.println("根据英文描述获取中文描述：" + ColorEnum.getDescriptionByCode(ColorEnum.YELLOW.getCode()));
        System.out.println("根据输入字符获取中文描述(有)：" + ColorEnum.getDescriptionByCode("RED"));
        System.out.println("根据输入字符获取中文描述(无)：" + ColorEnum.getDescriptionByCode("PURPLE"));
    }
}
 
enum ColorEnum {
    YELLOW("YELLOW", "黄色"),
    WHITE("WHITE", "白色"),
    GREEN("GREEN", "绿色"),
    BLUE("BLUE", "蓝色"),
    RED("RED", "红色");
 
    //枚举标识码（中文描述）
    private final String description;
 
    //这个必须定义，且成员变量的类型及个数必须对应于上边枚举的定义
    //枚举标识码（英文描述）
    private final String code;
 
    ColorEnum(String code, String description) {
        this.code = code;
        this.description = description;
    }
 
    public String getCode() {
        return code;
    }
 
    public String getDescription() {
        return description;
    }
 
    public static String getDescriptionByCode(String code) {
        for (ColorEnum value : ColorEnum.values()) {
            if (value.getCode().equals(code)) {
                return value.getDescription();
            }
        }
        return null;
    }
}
 
执行结果：
根据英文描述获取中文描述：黄色
根据输入字符获取中文描述(有)：红色
根据输入字符获取中文描述(无)：null

那么kotlin怎么写：

用data数据类+密封类

sealed class OrderStatus {
    abstract val orderId: String

    data class Pending(override val orderId: String) : OrderStatus()
    data class Shipped(override val orderId: String, val trackingNumber: String) : OrderStatus()
    data class Delivered(override val orderId: String, val deliveryDate: String) : OrderStatus()
    object Cancelled : OrderStatus()

    fun getDescription(): String {
        return when (this) {
            is Pending -> "Order $orderId is pending"
            is Shipped -> "Order $orderId has been shipped with tracking number $trackingNumber"
            is Delivered -> "Order $orderId has been delivered on $deliveryDate"
            Cancelled -> "Order $orderId has been cancelled"
        }
    }
}

fun main() {
    val pendingOrder = OrderStatus.Pending("12345")
    val shippedOrder = OrderStatus.Shipped("67890", "XYZ123")
    val deliveredOrder = OrderStatus.Delivered("23456", "2023-09-25")
    val cancelledOrder = OrderStatus.Cancelled

    println(pendingOrder.getDescription())
    println(shippedOrder.getDescription())
    println(deliveredOrder.getDescription())
    println(cancelledOrder.getDescription())
}

消失的旧时光-1943
关注
专栏目录
Kotlin密封类：sealed
weixin_41953808的博客
01-11 507
密封类：用来定义受限的类继承结构。 在when表达式中处理所有可能的子类，我们必须提供一个else分支来处理没有任何其他分支能匹配的情况： interface Expr class Num(val value:Int):Expr class Sum(val left:Expr,val right:Expr):Expr fun eval(e:Expr):Int = when(e){ is Num -> e.value is Sum -&g
moshi-sealed,通过moshi多态适配器序列化kotlin密封类的反射和代码生成实现。.zip
10-11
**密封类（Sealed Classes）**是Kotlin编程语言中的一种特性，用于限制类的继承。它们主要用于表示有限的、已知的子类型集合，这在处理枚举类的复杂替代品或者在编译时安全地处理异常时非常有用。在Java对象序列化或...
Kotlin 密封类
qq_37159335的博客
03-29 4213
在kotlin中被sealed关键字修饰的类就是密封类，当值只能从有限的集合(受限的层次结构)中包含一个类型时，将使用密封类。为了理解这个概念先举个栗子： class Expr class Const(val value: Int) : Expr class Sum(val left: Expr, val right: Expr) : Expr fun eval(e: Expr): Int = when (e) { is Const -> e.value
Kotlin 密封类与接口
cyclelucky的博客
12-27 838
密封类类似于枚举类：枚举类型的值集也受到限制，但每个枚举常量仅作为一个实例存在，而密封类的子类可以有多个实例，每个实例都有自己的状态。的类型，该类型在编译此类时是已知的；一旦编译了具有密封接口的模块，就不会出现新的实现。如果能够验证语句覆盖了所有情况，就不需要为该语句再添加一个。在定义密封类的模块和包之外，不能出现其他子类；的类和接口表示受限制的类层次结构，这些层次结构提供了。使用密封类的关键好处在于使用。
kotlin密封类
Jairus Tse的专栏
05-11 123
当一个值为有限几种的类型、而不能有任何其他类型时，可以使用密封类。密封类是枚举类的扩展，比枚举类更加灵活。 密封类比枚举类灵活的地方： 每个枚举常量只有一个实例（改动会影响到所有使用到的地方），而密封类的一个子类可以有多个实例。 每个枚举常量必须有相同的属性和函数，而密封类的每个子类都可以定义自己的属性和函数。 定义密封类： //密封类 sealed class MessageType //密封类的两个子类 class MessageSuccess(var msg:String): MessageTyp
Kotlin密封类sealed
赵彦军
09-26 3295
简介 密封类用来表示受限的类继承结构：当一个值为有限几种的类型, 而不能有任何其他类型时。 在某种意义上，他们是枚举类的扩展：枚举类型的值集合 也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。 声明一个密封类，使用 sealed 修饰类，密封类可以有子类。 sealed 不能修饰 interface ,`abstract classe(会报 warning,但是不会出现编译错误) 密封类与枚举类对比 ① 相同点 ( 类型限制 ) : 从类型种类角度对比 , 类与枚举类
kotlin密封类的使用
feuu的博客
08-17 677
编译器会检查有哪些子类,同时会强制性对每一个子类所对应的条件进行处理,意思是要对每一个子类进行处理,如果忘记处理会报错。运行结果只可能是Success和failure 但是如果没有else就无法运行通过,因为kotlin的语法检查功能。如果使用密封类,就可以解决这个问题。定义俩个类来实现Result接口。...
kotlin密封类sealed
flytosky21的博客
04-13 1853
kotlin密封类sealed
Kotlin密封类
weixin_40763897的博客
07-30 4488
Kotlin密封类 密封类被用于展示受限的类层次结构。当一个值可以有一个来自一个有限集合中的类型，但不能有任何其他类型。在某种程度上来说，它们是枚举类的扩展，一个枚举类型的值的集合也是受限的。但每一个枚举常量只作为一个单例存在，而密封类的子类可以有多个实例，这些实例都可以包含状态。 定义一个密封类，你只需将sealed修饰符放在类名之前。一个密封类可以有多个子类,但它们必须和密封类定义在同一个文件中。 sealed class Expr data class Const(val number: Double
Kotlin密封类的继承
移动端开发干货分享
02-03 636
Kotlin要求密封类的子类必须和密封类在一个文件中，这是为什么呢？ kotlin中禁止使用密封类直接创建对象，因此将其构造函数做成私有的。这样一来只有当子类是其内部类时才能访问到私有构造函数，从而实现继承，例如下面的代码是可以正常work的。 open class A private constructor(var name: String){ class B : A("B") ...
Kotlin之密封类
七夜聖君的博客
12-28 1008
Kotlin之密封类笔记
Kotlin 数据类与密封类
01-06
Kotlin 数据类与密封类 数据类 Kotlin 可以创建一个只包含数据的类，关键字为 data： data class User(val name: String, val age: Int) 编译器会自动的从主构造函数中根据所有声明的属性提取以下函数： equals() ...
kotlin 密封类
10-12
Kotlin 中的密封类是一种特殊的类，用于表示受限的类继承结构。它们可以看作是枚举类的扩展，枚举类只能有一个实例，而密封类可以有多个实例。密封类的主要作用是在使用 when 表达式时，限制条件分支的数量，使代码...
Compose Multiplatform+kotlin Multiplatfrom第三弹
j7a2son的博客
09-13 1031
上篇文章很多通用业务功能，这篇续着发布队列文件断点下载保存到本地。urlsavePathjob${GlobalCodeGlobalCodetaskurlGlobalCodetaskurlisCopytruetasktmpFile启动队列下载任务,整个队列下载框架处理的任务对象是DownloadTask类型，我们平时是在页面列表多选项构造出新的下载队列，用covert2TaskList()转换成框架处理的数据集。${bean!!
java和kotlin版本对照表
qq_43071699的博客
09-14 953
Java 和 Kotlin 是两种广泛使用的编程语言，特别是在 Android 开发领域。虽然它们有不同的语法和特性，但它们在很多方面是可以互操作的，尤其是在同一个项目中使用时。了解 Java 和 Kotlin 的版本对应关系可以帮助开发者更好地进行跨语言开发和维护。
Kotlin-Flow学习笔记
最新发布
逆流的鱼的专栏
09-17 127
Channel 和 Flow 都是数据流，Channel 是“热”的，Flow 则是“冷”的。这里的冷，代表着 Flow 不仅是“冷淡”的，而且还是“懒惰”的。 Flow 从 API 的角度分类，主要分为：构造器、中间操作符、终止操作符。今天这节课，我们将会从这几个角度来分析 Flow 的源码，来看看它的这几类 API 是如何实现的。 Flow 的功能看起来非常高大上，然而它的原理却非常的简单 // 代码段1 fun main() { val scope = CoroutineSco
Kotlin 极简小抄 P2（插值表达式、运算符、选择结构赋值）
weixin_52173250的博客
09-13 503
Kotlin 由 JetBrains 开发，是一种在 JVM（Java 虚拟机）上运行的静态类型编程语言
Kotlin 极简小抄 P1（变量与常量、基本数据类型、流程控制）
weixin_52173250的博客
09-12 755
Kotlin 由 JetBrains 开发，是一种在 JVM（Java 虚拟机）上运行的静态类型编程语言
java和kotlin 可以同时运行吗
qq_43071699的博客
09-14 1172
Java 和 Kotlin 可以在同一个项目中同时使用，并且可以无缝互操作。通过合理地组织项目结构、配置构建工具并遵循最佳实践，你可以充分利用两种语言的优势，提高开发效率和代码质量。无论你是从 Java 迁移到 Kotlin，还是在现有项目中引入 Kotlin，这种互操作性都为你提供了极大的灵活性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值