【Android】Kotlin教程（6）

彭于晏6892024-10-28 6:06

文章目录

1.接口

Kotlin 的接口可以既包含抽象方法的声明也包含实现。与抽象类不同的是，接口无法保存状态。它可以有属性但必须声明为抽象或提供访问器实现。

kotlin 复制代码 
interface MyInterface {
    fun bar()
    fun foo() {
      // 可选的方法体
    }
}
kotlin 复制代码 
interface Moveable {
    var maxSpeed: Int
    var wheels: Int

    fun move(moveable: Moveable): String
}

class Car(
    private val name: String,
    override var wheels: Int = 4,
    override var maxSpeed: Int = 100
) : Moveable {

    override fun move(moveable: Moveable): String {
        return "${moveable.javaClass.simpleName} with name $name is moving"
    }

    override fun toString(): String {
        return "Car(name=$name, wheels=$wheels, maxSpeed=$maxSpeed)"
    }
}

fun main() {
    val car = Car("xiaomi")
    println(car.move(car))
}

2.抽象类

抽象类是一种不能被实例化的类，它主要用于定义一组通用的行为和属性，这些行为和属性可以被其子类继承。抽象类可以包含抽象方法（没有实现的方法）以及具体的实现方法。子类必须提供抽象方法的具体实现，除非子类本身也是抽象的。

kotlin 复制代码 
// 定义一个抽象类
abstract class Animals {
    // 抽象属性
    abstract val image: String

    // 抽象方法
    abstract fun makeSound()

    // 具体方法
    open fun breathe() {
        println("呼吸")
    }

    // 构造函数
    constructor(name: String) {
        println("动物的名字是 $name")
    }
}

// 实现抽象类
class Dog : Animals("狗") {
    override val image = "dog.jpg"

    override fun makeSound() {
        println("汪汪！")
    }
}

class Cat : Animals("猫") {
    override val image = "cat.jpg"

    override fun makeSound() {
        println("喵喵！")
    }
}

fun main() {
    val dog = Dog()
    dog.makeSound()  // 输出: 汪汪！
    dog.breathe()    // 输出: 呼吸

    val cat = Cat()
    cat.makeSound()  // 输出: 喵喵！
    cat.breathe()    // 输出: 呼吸
}

3.泛型类

泛型类的构造函数可以接受任何类型。

kotlin 复制代码 
class MagicBox<T>(val item: T) {
    private var subject : T = item

    fun open() : String {
        return "subject -- $subject."
    }
}


class Boy(val name : String, val age : Int)

class Tiger(val weight: Int)



fun main() {
    val  box1:MagicBox<Boy> = MagicBox(Boy("tony",10))
    val  box2:MagicBox<Tiger> = MagicBox(Tiger(100))
    println(box1.open()) // subject -- Boy@27716f4.
    println(box2.open()) // subject -- Boy@27716f4.
}

4.泛型函数

泛型参数也可以用于函数

kotlin 复制代码 
class MagicBox<T>(val item: T) {
    private var subject : T = item

    fun open() : String {
        return "subject -- $subject."
    }

    fun call() : T {
        return subject
    }
}


class Boy(val name : String, val age : Int)

class Tiger(val weight: Int)



fun main() {
    val  box1:MagicBox<Boy> = MagicBox(Boy("tony",10))
    val  box2:MagicBox<Tiger> = MagicBox(Tiger(100))
    println(box1.open()) // subject -- Boy@27716f4.
    println(box2.open()) // subject -- Boy@27716f4.
    println(box1.call()) // Boy@27716f4
    println(box2.call()) // Tiger@8efb846
}

5.多泛型参数

泛型函数或泛型类也可以有多个泛型参数。

定义多泛型参数的类

kotlin 复制代码 
class Pair<T, U> (val first: T, val second: U) {
    fun printPair() {
        println("First: $first, Second: $second")
    }
}

fun main() {
    val pair = Pair(1, "one")
    pair.printPair()  // 输出: First: 1, Second: one
}

定义多泛型参数的接口

kotlin 复制代码 
interface Container<K, V> {
    fun put(key: K, value: V)
    fun get(key: K): V?
}

class HashMapContainer<K, V> : Container<K, V> {
    private val map = mutableMapOf<K, V>()

    override fun put(key: K, value: V) {
        map[key] = value
    }

    override fun get(key: K): V? {
        return map[key]
    }
}

fun main() {
    val container: Container<String, Int> = HashMapContainer()
    container.put("key1", 100)
    println(container.get("key1"))  // 输出: 100
}

多泛型参数的函数

kotlin 复制代码 
fun <T, U> combine(first: T, second: U): Pair<T, U> {
    return Pair(first, second)
}

fun main() {
    val result = combine(42, "answer")
    println(result)  // 输出: Pair(first=42, second=answer)
}

泛型约束：你可能希望对泛型参数进行一些限制，例如要求它们必须实现某个特定的接口。这可以通过类型约束来实现：

kotlin 复制代码 
fun <T : Comparable<T>> findMax(a: T, b: T): T {
    return if (a > b) a else b
}

fun main() {
    val maxInt = findMax(3, 5)
    println(maxInt)  // 输出: 5

    val maxString = findMax("apple", "banana")
    println(maxString)  // 输出: banana
}

在这个例子中，findMax 函数的类型参数 T 被限制为实现了 Comparable 接口的类型，这样就可以使用比较运算符。

6.out和int

out关键字用于实现协变（covariance），这允许你在泛型类型参数上定义一种更灵活的类型关系。协变主要用于处理只读操作，比如从集合中获取元素，而不涉及写入或修改这些元素的操作。

协变是指当一个类型 A 是类型 B 的子类型时，那么 List<A> 也可以被视为List<B>的子类型。这种关系使得我们可以使用更通用的类型来引用具体的子类型实例。

逆变是指当一个类型 A 是类型 B 的子类型时，那么 Consumer<A> 也可以被视为 Consumer<B> 的子类型。这种关系使得我们可以使用更通用的类型来引用具体的子类型实例，但方向是相反的。

  • 父类泛型对象可以赋值给子类泛型对象，用in
  • 子类泛型对象可以赋值给父类泛型对象，用out
kotlin 复制代码 
// out
interface Production<out T>{
    fun produce() : T
}

// in
interface Consumer<in T>{
    fun consume(t : T)
}

// 不变
interface ProductionConsumer<T> {
    fun product() : T
    fun consume(item : T)
}


open class Food


open class FastFood : Food()

class Burger : FastFood()

// 生产者
// 食品商店
class FoodStore : Production<Food>{
    override fun produce(): Food{
        println("Produce Food.")
        return Food()
    }
}

class FastFoodStore : Production<FastFood>{
    override fun produce(): FastFood{
        println("Produce FastFood.")
        return FastFood()
    }
}

class BurgerStore : Production<Burger>{
    override fun produce(): Burger{
        println("Produce Burger.")
        return Burger()
    }
}

class FoodConsumer : Consumer<Food>{
    override fun consume(item: Food) {
        println("Consume Food.")
    }
}

class FastFoodConsumer : Consumer<FastFood>{
    override fun consume(item: FastFood) {
        println("Consume FastFood.")
    }
}

class BurgerConsumer : Consumer<Burger>{
    override fun consume(item: Burger) {
        println("Consume Burger.")
    }
}
fun main() {
     val production1 : Production<Food> = FoodStore()
     val production2 : Production<Food> = FastFoodStore()
     val production3 : Production<Food> = BurgerStore()

    val consumer1 : Consumer<Food> = FoodConsumer()
    val consumer2 : Consumer<FastFood> = FoodConsumer()
    val consumer3 : Consumer<Burger> = FoodConsumer()
}

7.reified

reified 是一个关键字，用于使类型参数在运行时具体化。通常情况下，泛型的类型信息在编译后会被擦除（即类型擦除），这意味着你不能在运行时获取到具体的类型信息。然而，通过使用 reified 关键字，Kotlin 允许你在某些上下文中保留这些类型信息。

kotlin 复制代码 
// 定义一个泛型类 MagicBox2，泛型 T 必须是 Human 的子类
class MagicBox2<T : Human> {

    // 定义一个内联泛型方法 randomOrBackup，使用 reified 关键字使 T 类型在运行时可用
    inline fun <reified T> randomOrBackup(backup: () -> T): T {
        // 创建一个包含不同类型 Human 对象的列表
        val items = listOf(
            Man("C++", 40),
            Feman("Kotlin", 45)
        )

        // 随机打乱列表并取第一个元素
        val randomItem = items.shuffled().first()

        // 如果随机选中的元素是 T 类型，则返回该元素；否则调用备份函数返回一个默认值
        return if (randomItem is T) {
            randomItem
        } else {
            backup()
        }
    }
}

// 定义一个开放类 Human，包含一个年龄属性
open class Human(val age: Int)

// 定义一个 Man 类，继承自 Human，包含一个姓名属性
class Man(val name: String, age: Int) : Human(age)

// 定义一个 Feman 类，继承自 Human，包含一个姓名属性
class Feman(val name: String, age: Int) : Human(age)

fun main() {
    // 创建一个 MagicBox2 实例，指定泛型为 Man
    val magicBox = MagicBox2<Man>()

    // 调用 randomOrBackup 方法，如果随机选中的不是 Man 类型，则返回一个 Feman 对象作为备份
    val man = magicBox.randomOrBackup {
        Feman("Java", 35)
    }

    // 打印结果，输出选中的对象的姓名
    println(man.name)
}

8.定义扩展函数

扩展函数允许你为现有的类添加新的功能，而无需修改该类的源代码。这使得你可以向库中的类或第三方库中的类添加自定义方法，从而增强其功能。扩展函数在使用时看起来就像它们是原始类的一部分一样。

定义扩展函数：要定义一个扩展函数，你需要在函数名前面指定接收者类型（即你要扩展的类），并在接收者类型和函数名之间使用点号 .。接收者类型的实例将作为隐式的第一个参数传递给扩展函数。

String 类添加一个扩展函数来检查字符串是否是回文：

kotlin 复制代码 
fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}


fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // "this"对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}


fun main() {
    val str = "madam"
    println(str.isPalindrome())  // 输出: true

    val list = mutableListOf(1, 2)
    list.swap(0, 1)
    println(list)  // 输出: [2, 1]
}

9.扩展属性

除了扩展函数，Kotlin 还支持扩展属性。扩展属性与扩展函数类似，但用于定义新的属性。

kotlin 复制代码 
// 示例
val String.firstChar: Char?
    get() = if (this.isEmpty()) null else this[0]

fun main() {
    val str = "hello"
    println(str.firstChar)  // 输出: h
}

10.泛型扩展函数

kotlin 复制代码 
class Box<T>(val item: T)

// 为 Box<T> 添加一个扩展函数
fun <T> Box<T>.printItem() {
    println("The item in the box is: $item")
}

fun main() {
    val intBox = Box(42)
    intBox.printItem()  // 输出: The item in the box is: 42

    val stringBox = Box("Hello, World!")
    stringBox.printItem()  // 输出: The item in the box is: Hello, World!
}
相关推荐
酒鬼猿11 分钟前
C++初阶(七)--类和对象(4)
开发语言·c++
你不讲 wood16 分钟前
预览 PDF 文档
开发语言·前端·javascript·pdf·html·node·文件预览
蜡笔小新星22 分钟前
PyTorch的基础教程
开发语言·人工智能·pytorch·经验分享·python·深度学习·学习
gorgor在码农23 分钟前
Lua 从基础入门到精通（非常详细）
开发语言·lua
houyawei_NO129 分钟前
QT相机连接与拍照
开发语言·qt
Yaml434 分钟前
Spring Boot整合EasyExcel：实现大规模数据的并行导出与压缩下载
java·开发语言·spring boot
无敌最俊朗@37 分钟前
unity3d————三角函数练习题
开发语言·学习·unity·c#·游戏引擎
编程修仙39 分钟前
Java三大特性之继承
java·开发语言
bitenum1 小时前
qsort函数的学习与使用
c语言·开发语言·学习·算法·visualstudio·1024程序员节
架构师ZYL1 小时前
python之数据结构与算法（数据结构篇）-- 元组
开发语言·javascript·python·信息可视化·数据结构与算法
热门推荐
01前端vue3实现本地及在线文件预览（含pdf/txt/mp3/mp4/docx/xlsx/pptx）02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)04Windows10安装PCL1.14.0及点云配准05制冷毛细管的计算方法介绍06RAG 实践- Ollama+RagFlow 部署本地知识库07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Coze扣子平台完整体验和实践（附国内和国际版对比）09苍穹外卖面试总结10ECharts 地图实战分析：实现一个完整的地图下钻功能