Kotlin如何为同一数据结构的多类实现抽取通用服务函数？

基础准备：对齐所有List实现的公共抽象接口 #

所有你已经写好的MyArrayList、MyLinkedList、MyDoubleLinkedList，本来就严格遵循教授要求的形式化方法集合，首先把这些核心规范方法抽成公共泛型接口，放在lists包下，让三个实现类都显式实现这个接口——这是服务类能通用适配所有实现的核心前提：

// MyListSpec.kt，定义所有List实现必须遵守的形式化规范
interface MyListSpec<T> {
    // 仅保留教授要求的核心数据结构方法，无任何服务逻辑
    fun create()
    fun delete()
    fun head(): T?
    fun isEmpty(): Boolean
    fun isLast(): Boolean
    fun next(): T?
    fun previous(): T?
    fun insert(item: T, position: T?)
    fun write(item: T, position: T?)
    fun read(position: T?): T?
    fun remove(position: T?)
}

// 三个独立核心实现类，删除之前冗余的服务方法，仅保留核心逻辑
class MyArrayList<T> : MyListSpec<T> {
    // 原有的数组实现核心代码
}
class MyLinkedList<T> : MyListSpec<T> {
    // 原有的单链表实现核心代码
}
class MyDoubleLinkedList<T> : MyListSpec<T> {
    // 原有的双链表实现核心代码
}

独立服务类编写规则 #

把之前重复写在三个实现类里的printList、goToList、sortList、purgeList等通用服务逻辑，全部移动到独立的ListServices类中，类文件单独放在edu.uni.lists.services包下，所有服务方法仅接收MyListSpec<T>类型的实例作为入参，完全不关心传入的是哪种具体List实现：

// ListServices.kt，独立文件，和核心实现类完全解耦
class ListServices<T> {
    // 打印列表，逻辑和之前每个实现类里写的完全一致
    fun printList(target: MyListSpec<T>) {
        if (target.isEmpty()) {
            println("Empty List")
            return
        }
        print("[")
        var current = target.head()
        while (current != null) {
            print(current)
            if (!target.isLast()) print(", ")
            current = target.next()
        }
        println("]")
    }

    // 按索引跳转，逻辑和之前重复的代码完全一致
    fun goToList(target: MyListSpec<T>, position: Int): T? {
        var index = 0
        var current = target.head()
        while (index < position && !target.isLast()) {
            current = target.next()
            index++
        }
        return current
    }

    // 排序、去重方法同理，直接操作传入的target实例即可，无需重复编写
    fun sortList(target: MyListSpec<T>, whichSort: String, order: String) {
        // 原有的排序核心逻辑，仅依赖MyListSpec暴露的核心方法实现
    }

    fun purgeList(target: MyListSpec<T>) {
        // 原有的去重核心逻辑
    }
}

调用逻辑调整 #

原来直接从List实例调用服务方法的写法，改成通过服务实例调用，同时完全保留你之前可切换List实现的灵活性：

// 切换List实现仅需修改这行import的别名，后续逻辑完全不用改动
import edu.uni.lists.MyArrayList as MyList
import edu.uni.lists.services.ListServices

fun main() {
    val l1 = MyList<String>()
    // 全局初始化一次服务实例即可
    val listService = ListServices<String>()

    l1.create()
    if (l1.isEmpty()) {
        println("List is empty")
    }

    l1.insert("11", l1.head())
    l1.insert("10", l1.head())
    l1.insert("9", l1.head())
    l1.insert("8", l1.head())
    l1.insert("7", l1.head())
    l1.insert("69", l1.head())

    // 通过服务类调用通用方法
    listService.printList(l1)
}

可选优化：如果想保留l1.printList()的写法语义，可以在ListServices的同个文件里给MyListSpec<T>写扩展函数，完全不侵入核心实现类的代码：

fun <T> MyListSpec<T>.printList() {
    ListServices<T>().printList(this)
}

扩展函数本质是定义在独立文件中的静态方法，不会修改MyArrayList等核心实现类的内部代码，完全符合项目的形式化规范要求。

合规性对照 #

• 所有核心List实现类仅保留教授要求的形式化规范方法，无任何服务类冗余逻辑
• 所有重复的通用功能仅编写一次，放在独立的服务类文件中，可适配全部三种List实现
• 新增其他List实现时，只要类实现了MyListSpec接口，服务类的所有方法不需要任何修改即可直接使用

内容的提问来源于stack exchange，提问作者He11Eventh