Kotlin基础（六）：枚举类和扩展

已于 2023-07-19 23:27:35 修改
阅读量1.7k 收藏
点赞数
分类专栏： Kotlin 文章标签： kotlin 开发语言 android java
于 2023-07-17 21:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13027629517/article/details/131774865
版权

前言

本文主要讲解kotlin枚举类和扩展

Kotlin文章列表

Kotlin文章列表: 点击此处跳转查看

目录

在这里插入图片描述

1.1 枚举类

1.1.1 枚举类的基本用法

Kotlin中的枚举类（enum class）用于定义一组具有预定义值的常量。它们在许多情况下都很有用，例如表示一组相关的选项、状态或命名常量集合。下面是Kotlin枚举类的基本用法：

  1. 声明枚举类：

    enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

  2. 使用枚举值：

    val direction = Direction.NORTH
println(direction)  // 输出: NORTH

  3. 比较枚举值：

    val direction = Direction.NORTH
if (direction == Direction.NORTH) {
    println("向北")
}

  4. 遍历枚举值：

    for (enumValue in Direction.values()) {
    println(enumValue)
}

  5. 获取枚举值的名称：

    val direction = Direction.NORTH
println(direction.name)  // 输出: NORTH

  6. 获取枚举值的序号（从0开始）：

    val direction = Direction.NORTH
println(direction.ordinal)  // 输出: 0

  7. 使用枚举类的方法和属性：

    enum class Direction {
    NORTH {
        override fun printDescription() {
            println("这是北方")
        }
    },
    SOUTH {
        override fun printDescription() {
            println("这是南方")
        }
    },
    EAST {
        override fun printDescription() {
            println("这是东方")
        }
    },
    WEST {
        override fun printDescription() {
            println("这是西方")
        }
    };

    abstract fun printDescription()
}

val direction = Direction.NORTH
direction.printDescription()  // 输出: 这是北方

这些是Kotlin枚举类的基本用法。

1.1.2 为枚举值指定对应的数值

在Kotlin中，你可以为枚举值指定对应的数值。默认情况下，每个枚举值会自动分配一个从0开始递增的整数值作为其数值。然而，你也可以显式地为枚举值指定自定义的数值。下面是为枚举值指定数值的几种方式：

  1. 基本数值分配：

    enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

    在这种情况下，NORTH的数值为0，SOUTH的数值为1，以此类推。

  2. 自定义数值分配：

    enum class Direction(val degrees: Int) {
    NORTH(0), SOUTH(180), EAST(90), WEST(270)
}

    在这个例子中，每个枚举值都有一个degrees属性来存储对应的数值。NORTH的数值为0，SOUTH的数值为180，以此类推。

  3. 使用匿名类和属性来分配数值：

    enum class Direction {
    NORTH {
        override val degrees: Int = 0
    },
    SOUTH {
        override val degrees: Int = 180
    },
    EAST {
        override val degrees: Int = 90
    },
    WEST {
        override val degrees: Int = 270
    };

    abstract val degrees: Int
}

    在这个例子中，每个枚举值都通过匿名类来定义，并重写了degrees属性以指定数值。

你可以根据需要选择适合的方式来为枚举值指定数值。这样，你就可以在需要使用枚举值数值的地方访问这些数值。例如，对于第二个示例中的Direction枚举类，你可以通过direction.degrees来访问特定枚举值的数值。

1.1.3 枚举类的其他功能

除了基本用法外，Kotlin枚举类还提供了其他一些功能，使其更加灵活和强大。以下是一些Kotlin枚举类的其他功能：

  1. 声明方法：
    枚举类可以声明方法，可以在每个枚举值上调用这些方法。例如：

    enum class Direction {
    NORTH {
        override fun getOpposite(): Direction = SOUTH
    },
    SOUTH {
        override fun getOpposite(): Direction = NORTH
    },
    EAST {
        override fun getOpposite(): Direction = WEST
    },
    WEST {
        override fun getOpposite(): Direction = EAST
    };

    abstract fun getOpposite(): Direction
}

    每个枚举值都实现了getOpposite()方法，根据当前方向返回相反的方向。

  2. 实现接口：
    枚举类可以实现接口。这使得你可以为枚举类的每个枚举值提供不同的实现。例如：

    interface Printable {
    fun print()
}

enum class Direction : Printable {
    NORTH {
        override fun print() {
            println("北方")
        }
    },
    SOUTH {
        override fun print() {
            println("南方")
        }
    },
    EAST {
        override fun print() {
            println("东方")
        }
    },
    WEST {
        override fun print() {
            println("西方")
        }
    };
}

    在这个例子中，Direction枚举类实现了Printable接口，并为每个枚举值提供了不同的print()方法实现。

  3. 通过字符串获取枚举值：
    你可以通过枚举值的字符串名称来获取对应的枚举值。使用valueOf()函数实现这一点。例如：

    val direction = Direction.valueOf("NORTH")
println(direction)  // 输出: NORTH

    这将返回枚举值NORTH。

  4. 定义扩展函数和属性：
    你可以为枚举类定义扩展函数和属性，为枚举值添加额外的功能。例如：

    enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun Direction.isVertical(): Boolean {
    return this == Direction.NORTH || this == Direction.SOUTH
}

val Direction.opposite: Direction
    get() = when (this) {
        Direction.NORTH -> Direction.SOUTH
        Direction.SOUTH -> Direction.NORTH
        Direction.EAST -> Direction.WEST
        Direction.WEST -> Direction.EAST
    }

    在这个例子中，isVertical()是一个扩展函数，用于判断枚举值是否为垂直方向。opposite是一个扩展属性，根据当前方向返回相反的方向。

这些是Kotlin枚举类的一些其他功能，它们使得枚举类更加灵活和可扩展。

1.2 扩展

1.2.1 扩展原生API

Kotlin提供了扩展函数和扩展属性的功能，使你能够扩展原生的API类，包括标准库和其他类库中的类。这使你能够在不修改原始类代码的情况下为这些类添加新的功能。下面是如何在Kotlin中扩展原生API的几种方法：

  1. 扩展函数：
    你可以为任何类定义扩展函数。要定义一个扩展函数，你需要在函数名前面加上接收者类型并使用点符号。例如，以下是为字符串类型扩展一个reverse()函数：

    fun String.reverse(): String {
    return this.reversed()
}

    使用示例：

    val reversedString = "Hello, World!".reverse()
println(reversedString)  // 输出: "!dlroW ,olleH"

    在这个例子中，我们扩展了String类，添加了一个reverse()函数，以反转字符串的顺序。

  2. 扩展属性：
    与扩展函数类似，你还可以为类定义扩展属性。要定义一个扩展属性，你可以使用get()和（可选）set()函数。以下是为Int类型扩展一个isEven属性：

    val Int.isEven: Boolean
    get() = this % 2 == 0

    使用示例：

    val number = 6
println(number.isEven)  // 输出: true

    在这个例子中，我们扩展了Int类，添加了一个isEven属性，用于判断一个整数是否为偶数。

  3. 扩展标准库：
    Kotlin的标准库提供了许多常见类型的扩展函数和属性，使你能够以更简洁的方式处理数据。例如，标准库中的List类提供了许多方便的扩展函数，如filter()、map()和reduce()等，用于对列表进行操作和转换。

    val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
val doubledNumbers = numbers.map { it * 2 }
val sum = numbers.reduce { acc, value -> acc + value }

    在这个例子中，我们使用了filter()函数筛选出偶数，使用map()函数将每个数字乘以2，使用reduce()函数计算数字的总和。

扩展原生API使你能够根据自己的需求为现有类添加新的功能，提高代码的可读性和可维护性。请注意，扩展函数和属性仅在调用它们的作用域内可见，并且它们不能访问类的私有或受保护成员。

1.2.2 扩展自定义类

在Kotlin中，你不仅可以扩展原生的API类，还可以扩展自定义的类。这使你能够为自己的类添加新的功能或方法，以满足特定的需求。下面是如何在Kotlin中扩展自定义类的几种方法：

  1. 扩展函数：
    你可以为自定义的类定义扩展函数，以添加新的功能。要定义一个扩展函数，你需要在函数名前面加上接收者类型并使用点符号。例如，假设你有一个名为Person的自定义类，你可以为它添加一个greet()函数：

    class Person(val name: String)

fun Person.greet() {
    println("Hello, $name!")
}

    使用示例：

    val person = Person("John")
person.greet()  // 输出: "Hello, John!"

    在这个例子中，我们为Person类添加了一个greet()函数，以便在实例上调用该函数时打印出问候语。

  2. 扩展属性：
    与扩展函数类似，你还可以为自定义的类定义扩展属性。要定义一个扩展属性，你可以使用get()和（可选）set()函数。以下是为Person类扩展一个age属性：

    class Person(val name: String)

val Person.age: Int
    get() = 30

    使用示例：

    val person = Person("John")
println(person.age)  // 输出: 30

    在这个例子中，我们为Person类添加了一个age属性，始终返回30。

  3. 扩展其他自定义类：
    你可以为任何自定义类定义扩展函数和属性，无论它们是你自己编写的类还是来自其他类库。只需按照相同的语法和规则创建扩展函数和属性即可。例如：

    class Rectangle(val width: Int, val height: Int)

fun Rectangle.isSquare(): Boolean {
    return width == height
}

    使用示例：

    val rectangle = Rectangle(5, 5)
println(rectangle.isSquare())  // 输出: true

    在这个例子中，我们为Rectangle类添加了一个isSquare()函数，用于判断矩形是否为正方形。

扩展自定义类使你能够在不修改原始类代码的情况下为它们添加新的功能。这样可以提高代码的可读性、可维护性和灵活性。扩展函数和属性仅在调用它们的作用域内可见，并且它们不能访问类的私有或受保护成员。

1.2.3 成员函数冲突的解决方案

在Kotlin中，当你扩展的类和目标类具有相同名称的成员函数时，会发生函数冲突。这种情况下，编译器无法确定应该使用哪个函数。为了解决这个问题，你可以采取以下两种解决方案：

  1. 显式指定调用的函数：
    当发生函数冲突时，你可以使用类名作为限定符，显式指定调用哪个类的函数。例如，假设你有一个名为String的扩展函数toUpperCase()，但是String类本身也有一个toUpperCase()函数，你可以使用类名来调用扩展函数：

    fun String.toUpperCase(): String {
    return "Extension function"
}

fun main() {
    val str = "Hello"
    println(str.toUpperCase())         // 调用目标类的函数
    println(str.String.toUpperCase())  // 调用扩展函数
}

    在这个例子中，我们通过使用类名String作为限定符，显式调用了扩展函数toUpperCase()和目标类的函数toUpperCase()。

  2. 使用@JvmName注解：
    另一种解决函数冲突的方法是使用@JvmName注解为扩展函数指定一个不同的Java虚拟机名称。这样可以避免函数名称冲突。例如：

    @file:JvmName("StringUtil")

package com.example.utils

fun String.toUpperCase(): String {
    return "Extension function"
}

    在这个例子中，我们使用@JvmName注解将扩展函数toUpperCase()的Java虚拟机名称设置为StringUtil.toUpperCase()，避免了与目标类的函数冲突。

    注意：@JvmName注解应该放在扩展函数所在的文件的顶部。

通过显式指定调用的函数或使用@JvmName注解，你可以解决函数冲突问题，并确保在扩展类和目标类具有相同名称的成员函数时，能够正确地调用所需的函数。

​

1.2.4 扩展属性

在Kotlin中，你可以通过扩展属性为类添加新的属性。扩展属性允许你为现有类添加新的属性，而无需修改其源代码。以下是如何在Kotlin中扩展属性的示例：

// 假设有一个名为Person的类
class Person(val name: String)

// 为Person类添加一个扩展属性age
val Person.age: Int
    get() = 30

fun main() {
    val person = Person("John")
    println(person.age)  // 输出: 30
}

在上述示例中，我们为Person类添加了一个扩展属性age。扩展属性的定义类似于扩展函数，但是在这种情况下，我们只需要定义get()函数来获取属性的值。

请注意以下事项：

  • 扩展属性不能有初始值，因为它们没有与之关联的字段。因此，你需要提供一个get()函数来计算属性的值。
  • 扩展属性不支持set()函数，因此它们是只读的。

与扩展函数一样，扩展属性仅在调用它们的作用域内可见，并且它们不能访问类的私有或受保护成员。

通过使用扩展属性，你可以方便地为现有类添加新的属性，从而提供更灵活的数据操作和访问方式。

1.2.5 扩展伴随对象（CompanionObject）

在Kotlin中，你可以使用扩展函数和扩展属性来扩展伴随对象（companion object）。伴随对象是与类关联的单例对象，它可以包含类级别的函数和属性。以下是如何扩展伴随对象的示例：

class MyClass {
    companion object {
        fun greet() {
            println("Hello from companion object!")
        }
    }
}

// 扩展伴随对象的函数
fun MyClass.Companion.sayHello() {
    println("Hello from extension function of companion object!")
}

fun main() {
    MyClass.greet()      // 调用伴随对象的函数
    MyClass.sayHello()   // 调用扩展函数
}

在上述示例中，我们有一个包含伴随对象的MyClass类。我们可以通过直接使用类名调用伴随对象的函数greet()。

然后，我们使用扩展函数的语法来为伴随对象添加新的函数sayHello()。这样，我们可以使用伴随对象的函数和扩展函数来进行调用。

请注意以下事项：

  • 扩展伴随对象的函数或属性的定义需要使用Companion关键字作为限定符。
  • 扩展伴随对象的函数和属性可以与伴随对象内部定义的函数和属性共存，它们在调用时使用相同的语法。

通过扩展伴随对象，你可以为伴随对象添加新的功能，而无需修改原始类的源代码。这使得你可以更灵活地扩展伴随对象并为其添加额外的行为。

1.2.6 扩展的范围

在Kotlin中，扩展的范围（可见性）是受限的，扩展函数和属性只在特定的作用域内可见。以下是关于Kotlin扩展范围的几点要注意的事项：

  1. 扩展函数和属性的作用域：
    • 在顶层：你可以在文件的顶层定义扩展函数和属性，它们将在整个文件中可见。
    • 在类内部：你可以在类内部定义扩展函数和属性，它们将在类的范围内可见。
  2. 可见性限制：
    • 扩展函数和属性不能访问类的私有或受保护成员。它们只能访问类中的公共成员。
    • 扩展函数和属性不会继承给子类。只有在扩展函数或属性定义所在的作用域内才可见，无法通过继承传递给子类。
  3. 导入扩展：
    • 要使用扩展函数和属性，你需要在使用它们的文件中导入它们所在的包或文件。
    • 如果扩展函数或属性在同一个包内，你不需要导入，可以直接使用。
    • 如果扩展函数或属性在不同的包内，你需要使用import关键字导入它们。

例如，假设有以下代码：

package com.example.utils

fun String.reverse(): String {
    return this.reversed()
}

class MyClass {
    fun doSomething() {
        val str = "Hello"
        println(str.reverse())
    }
}

fun main() {
    val str = "World"
    println(str.reverse())
}

在这个例子中，reverse()扩展函数位于com.example.utils包中。在main()函数中，我们需要导入reverse()函数所在的包才能使用它。而在MyClass类的doSomething()函数中，由于在同一个包内，所以无需导入即可使用。

总结起来，扩展函数和属性的范围是局限于定义它们的作用域内。你需要正确导入扩展函数和属性所在的包或文件，才能在其他地方使用它们。另外，扩展函数和属性无法访问类的私有或受保护成员。

1.2.7 在类中使用扩展

在Kotlin中，你可以在类内部使用扩展函数和扩展属性。这样做可以为类添加额外的功能，而无需修改类的源代码。以下是如何在类中使用扩展的示例：

class MyClass {
    private val data: MutableList<String> = mutableListOf()

    fun addData(item: String) {
        data.add(item)
    }

    fun displayData() {
        println("Data: $data")
    }

    // 在类内部定义扩展函数
    fun MyClass.processData() {
        data.forEach {
            println("Processing: $it")
        }
    }

    // 在类内部定义扩展属性
    val MyClass.totalDataSize: Int
        get() = data.size
}

fun main() {
    val myObj = MyClass()
    myObj.addData("Item 1")
    myObj.addData("Item 2")
    myObj.addData("Item 3")

    myObj.displayData()              // 输出: Data: [Item 1, Item 2, Item 3]
    myObj.processData()              // 输出: Processing: Item 1, Processing: Item 2, Processing: Item 3
    println(myObj.totalDataSize)     // 输出: 3
}

在上述示例中，我们在MyClass类内部定义了一个扩展函数processData()和一个扩展属性totalDataSize。这些扩展函数和属性可以直接在类的实例上使用。

请注意以下事项：

  • 在类内部定义的扩展函数和属性可以直接访问类的私有成员。
  • 在类内部定义的扩展函数和属性只在类的实例上可见，不能在类的伴随对象或其他作用域中访问。

通过在类内部使用扩展函数和属性，你可以为类添加特定的功能，与类的其他成员一起工作，并直接在类的实例上使用它们。这样可以提高代码的可读性和可维护性，并使类的功能更加灵活。

1.2.8 调用特定类的成员函数

在Kotlin中，你可以使用限定符（qualifier）来调用特定类的成员函数。通过限定符，你可以明确指定调用哪个类的成员函数，尤其在存在函数名称冲突或多个类具有相同函数名时很有用。以下是几种使用限定符调用特定类成员函数的方法：

  1. 使用类名作为限定符：

    class MyClass {
    fun myFunction() {
        println("Hello from MyClass")
    }
}

fun main() {
    val obj = MyClass()
    obj.myFunction()     // 调用MyClass的myFunction函数
}

    在这个例子中，我们通过创建MyClass的实例obj来调用它的成员函数myFunction()。通过实例对象限定符，我们明确地指定了调用的是MyClass的成员函数。

  2. 使用扩展函数：

    class MyClass {
    fun myFunction() {
        println("Hello from MyClass")
    }
}

fun MyClass.anotherFunction() {
    println("Hello from extension function")
}

fun main() {
    val obj = MyClass()
    obj.myFunction()         // 调用MyClass的myFunction函数
    obj.anotherFunction()    // 调用MyClass的扩展函数
}

    在这个例子中，我们在MyClass类外部定义了一个扩展函数anotherFunction()。通过在实例对象上调用该扩展函数，我们仍然是明确指定了要调用的是MyClass的函数。

使用限定符的好处是可以避免函数名称冲突，并确保在存在多个类具有相同函数名的情况下，调用的是正确的类的函数。

需要注意的是，限定符只能用于调用类的成员函数，无法用于调用类的扩展函数。扩展函数的调用需要使用扩展函数的定义作用域来限定，而不是使用限定符。

1.2.9 扩展成员的继承

在Kotlin中，扩展函数和属性是静态解析的，它们不会被子类继承。这意味着在子类中定义相同名称的函数或属性不会覆盖或继承父类的扩展函数或属性。相反，子类会拥有自己独立的同名成员函数或属性。

让我们看一个示例来说明这一点：

open class Parent

fun Parent.printMessage() {
    println("Hello from Parent")
}

class Child : Parent()

fun Child.printMessage() {
    println("Hello from Child")
}

fun main() {
    val parent: Parent = Child()
    parent.printMessage()  // 输出: Hello from Parent
}

在这个例子中，我们有一个Parent类和一个Child类，Child类继承自Parent类。我们在Parent类中定义了一个扩展函数printMessage()，然后在Child类中定义了一个同名的函数。

当我们通过Child类的实例来调用printMessage()函数时，实际上调用的是Parent类的扩展函数。这是因为扩展函数是静态解析的，它们的调用在编译时就确定了，而不是在运行时根据实际对象的类型进行动态分派。

因此，子类无法继承或覆盖父类的扩展函数或属性。扩展函数和属性仅在定义它们的作用域内可见，并且它们不能通过继承传递给子类。

​

LZacking.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
kotlin-video-tutorial:Kotlin视频教程
04-28
Kotlin基础视频教程（第一版） 从5月份开始制作这个视频，历时两个多月，终于在网易云课堂与大家见面了... 视频特色 在前期课程中，使用普通编辑器进行编码，治疗你的IDE依赖症 所有课程均使用live coding的方式授课，保持与你的频率一致 每节课程课后都准备了相应的习题供大家巩固练习 课程覆盖面广，线下效果持续跟踪 项目实战部分是一个非常有意思的小项目，使用控制台完成类QQ聊天室功能（支持文字消息、文件发送、文件下载等功能） 课程目录 Kotlin基础环境配置、变量与空值安全 一等公民函数基础语法 高阶函数、lambda表达式与匿名函数 面向对象知识点（类、接口、继承、扩展等） Kotlin语言中多样的class类型、对象以及枚举 强大的集合与控制流处理 操作符重载 更安全的泛型处理 代理模式及其应用 协程简介 析构、注解与异常处理 Kotlin与Java互通的那些事儿 控制台版
Kotlin 枚举类 enum
热门推荐
本人很懒
09-10 1万+
枚举类就是一组命名的常数，是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内. 在使用中一般常用的
dart_meta_types:用于定义dart的密封类，数据类和枚举类的代码生成解决方案
04-25
dart_meta_types 用于定义dart的密封类，数据类和枚举类的代码生成解决方案。 。 op 尝试使dart与kotlin支持的数据类型保持一致。 提供了用于定义dart中的代数数据类型的方法。 定义用于生成第三方混合的模式和API，以为生成的模型提供其他功能。 例如meta_types_json。 支持将数据类明确定义为抽象，接口，可扩展和/或最终。 生成器可以对dart-lang本身不强制执行的这些概念强制执行严格的实践。 提供表示数据模型中不可为null和可为null的类型的方法。 提供使用模型进行元编程的方法，而无需使用dart：mirrors。 如何使用meta_types 使用meta_types包中的注释定义模型定义。 将meta_types_generator和build_runner添加到您的dev_dependencies 通过运行pub
Kotlin 中文文档.pdf
03-11
准备开始 基本语法 习惯用语 编码风格 基础 基本类型 包 控制流 返回与跳转 Introduction 5 类和对象 类和继承　 属性和字段　 接口 可见性修饰词 扩展 数据对象 泛型 嵌套类 枚举类 对象表达式和声明 代理模式 代理属性 函数和lambda表达式 函数 高阶函数和lambda表达式 内联函数 其它 多重申明 Ranges 类型检查和自动转换 This表达式 等式 运算符重载 空安全 异常 注解 反射 动态类型 参考 API 语法 互用性 Introduction 6 与 java 交互 工具 Kotlin代码文档 使用Maven 使用Ant 使用Griffon 使用Gradle　 FAQ 与java对比 与Scala对比 Introduction 7 基本语法 常用术语 编码风格 1.1中的新特性
JavaKotlinBasic:Java和Kotlin基础研究
04-11
＃Kotlin基础研究 介绍 Kotlin语 开发环境 基本 变量和数据类型- 功能- 运算运算 IF语句 - 中断，继续，返回 面向对象编程- 对象编程 继承- 模块- 访问 物业- 物业 LateInitialize 覆盖- 覆盖 任何-任何 这个和超级-ThisAndSuper 抽象类 接口- 接口 同伴 数据类-数据类 通用-通用 嵌套类 处理null-Null 铸造- 铸造 强制转换为null稳定性-NullSafeTypeCasting 枚举 密封等级-密封等级 反思- 反思 运算符重载- 运算符重载 函数式编程- 函数式编程 匿名函数-AnonymousFunction 内联函数-InlineFunction 扩展功能-ExtensionFunction 缀功能- InfixFunction 高阶函数-HighOrderFunction 基于阵列
Kotlin枚举
伯特立的专栏
11-25 2542
enum class
【Kotlin】Kotlin enum 枚举类 ( 常用用法 | 初始化成员变量 | 实现抽象方法 | 实现接口 | 获取名称和位置索引 | 调用枚举常量方法 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
03-23 7326
I . 枚举类常用用法 II . 枚举类初始化 III. 枚举类匿名类 IV . 枚举类实现接口 V . 获取枚举常量名称和位置索引 VI . 获取枚举常量的成员变量 VII . 调用枚举常量的方法 VIII . Kotlin 枚举完整代码示例
Kotlin中enum枚举的使用
peter12757的专栏
10-31 2549
Kotlin中枚举的一些用法和猜想
Kotlin之枚举类
七夜聖君的博客
12-18 1092
kotlin之枚举笔记
Kotlin专题「十七」：枚举类（enum class）
https://juejin.cn/user/1654096907477549/posts
10-13 2603
前言：前行的路，不怕万人阻挡，只怕自己投降，人生的帆，不怕狂风巨浪，只怕自己没胆量。 一、概述 枚举类最基本的用法是实现类型安全的。枚举类使用 enum 关键字修饰： enum class Direction {//使用 enum 关键字修饰，在类头 class 前 NORTH, SOUTH, WEST, EAST } 每一个枚举常数都是一个对象，枚举常量用逗号分隔。 fun test() { Direction.NORTH Directi..
Kotlin语言文档 中文高清免费版
05-22
Kotlin语言文档 中文高清免费版 概述 4 使 Kotlin 进 服务器端开发 4 使 Kotlin 进 Android 开发 5 Kotlin JavaScript 概述 6 Kotlin 1.1 的新特性 7 开始 15 基本语法 15 习惯 法 20 编码规范 24 基础 26 基本类型 26 包 31 控制流 33 返回和跳转 36 类和对象 38 类和继承 38 属性和字段 42 接 45 可 性修饰符 47 扩展 49 数据类 53 密封类 54 泛型 55 嵌套类 60 枚举类 61 对象表达式和对象声明 63 委托 66 委托属性 67 函数和 Lambda 表达式 72 函数 72 阶函数和 lambda 表达式 77 内联函数 81 协程 84 其他 88 解构声明 88 集合 90 区间 91 2 类型的检查与转换 93 This 表达式 95 相等性 96 操作符符重载 97 空安全 100 异常 102 注解 104 反射 108 类型安全的构建器 111 参考 117 Grammar 117 Notation 117 Semicolons 117 Syntax 117 Lexical structure 125 兼容性 126 Java 互操作 129 在 Kotlin 中调 Java 代码 129 Java 中调 Kotlin 136 JavaScript 142 动态类型 142 Kotlin 中调 JavaScript 144 JavaScript 中调 Kotlin 147 JavaScript 模块 149 JavaScript 反射 152 具 153 编写 Kotlin 代码 档 153 使 Kotlin 注解处理 具 156 使 Gradle 158 使 Maven 163 使 Ant 168 Kotlin 与 OSGi 171 编译器插件 172 常 问题 176 FAQ 176 与 Java 语 较 179 与 Scala 较【官 已删除】 180
Kotlin——中级篇（五）：枚举类（Enum）、接口类（Interface）详解
weixin_30699463的博客
10-29 345
在上一章节中，详细的类(class)做了一个实例讲解，提到了类(class)的实例化、构造函数、声明、实现方式、和Java中类的区别等。但是对于Kotlin中的类的使用还远远不止那些。并且在上文中提到了关于类的类别。故而这篇文章就详细说一说Kotlin中的枚举类（Enum）、接口类（Interface）的使用。 如果还对Kotlin中的类还没有一个清晰的概念及认识的朋友请阅读我的上一篇博文： K...
kotlin 中 枚举使用 Enum，满满干货
最新发布
m0_57473261的博客
04-01 754
开发是面向对象。我们找工作应该更多是面向面试。哪怕进大厂真的只是去宁螺丝，但你要进去得先学会面试的时候造飞机不是么？作者13年java转Android开发，在小厂待过，也去过华为，OPPO等，去年四月份进了阿里一直到现在。等大厂待过也面试过很多人。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含。
Kotlin 枚举类
shengyin714959的博客
07-30 51
枚举类最基本的用法是实现一个类型安全的枚举。枚举常量用逗号分隔,每个枚举常量都是一个对象。
Kotlin 9. Kotlin Class：数据类（data class），枚举类（Enum Class），密封类（Sealed Class）
破浪会有时的博客
10-23 2118
在这篇博客中，我们将详细介绍 Kotlin 各种类，包括类的构造函数，数据类（data class），枚举类（Enum Class），密封类（Sealed Class）。
Kotlin基础——枚举、When、in、for
松仔Log的博客
10-28 878
这也是Kotlin唯一必须使用分号的地方。
Kotlin类与对象(十一）：枚举类
m0_47308415的博客
07-29 159
枚举类的最基本的用法是实现类型安全的枚举： 每个枚举常量都是一个对象。枚举常量用逗号分隔。因为每一个枚举都是枚举类的实例，所以他们可以是这样初始化过的： 2、匿名类 枚举常量还可以声明其带有相应方法以及覆盖了基类方法的匿名类。 如果枚举类定义任何成员，那么使用分号将成员定义中的枚举常量定义分隔开。枚举条目不能包含内部类以外的嵌套类型（已在 Kotlin 1.2 中弃用）一个枚举类可以实现接口（但不能从类继承），可以为所有条目提供统一的接口成员实现，也可以在相应匿名类中为每个条目提供各自的实现。只需将接口添加
Kotlin(九)之枚举
jannal专栏
10-22 530
文章目录定义方法与属性 定义 Kotlin使用enum class定义枚举类。枚举类是一种特殊的类，可以有自己的属性、方法、可以实现一个或多个接口，也可以定义构造器 使用enum定义的枚举类默认继承kotlin.Enum类，所以枚举类不能显示继承其他父类。kotlin.Enum实现了kotlin.Comparable接口 使用enum定义的非抽象的枚举类不能使用open修饰，因此枚...
22：kotlin 类和对象 -- 枚举类（Enum classes）
qq_40104261的博客
12-05 542
枚举类最基本的用例是实现类型安全的枚举每个枚举常量都是一个对象。枚举常量以逗号分隔。由于每个枚举都是枚举类的一个实例，因此可以将其初始化为。
Kotlin Android Extensions：Kotlin Android扩展插件
05-21
Kotlin Android扩展插件是Kotlin官方提供的一个插件，用于简化Android开发中的View绑定和布局文件引用。通过使用该插件，我们可以在Kotlin代码中直接访问布局文件中的View，而无需手动findViewById()方法来查找View...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值