isSuperclassOf 与is 与 ==的区别

|---------|------------------|------------------------------|------------------------------------------------------------|
| | is | == | isSuperclassOf(other: KClass<*>) |
| 作用对象 | 实例 vs 类型 | KClass 对象 | KClass 对象 |
| 语法： | obj is Type | A::class == B::class | Parent::class.isSuperclassOf(Child::class) |
| 作用 | 判断一个对象是否是某个类型 | 判断两个类是否完全一样（精确匹配）(不继承) | 判断一个类是否是另一个类的父类/父接口（支持继承）判断 Parent 是否是 Child 的父类/父接口。 |
| 是否支持继承 | ✅ 支持（多态） | ❌ 不支持 | ✅ 支持继承/实现关系 |
| | | | |

is

is：判断一个实例对象是否是某个类型

语法：
Kotlin 复制代码
obj is Type
判断 obj 对象实例 是否是 Type 类型（或其子类/实现类）。

是 Kotlin 的关键字，用于运行时类型检查。

支持多态（继承/实现）

is 是最常用的类型判断方式，适用于变量或参数的类型检查。

为什么不能用 `List::class is T::class`？

List::class is T::class

语法错误

is 是用于 对象实例的类型检查 ，而不是用于比较两个 KClass 对象。
Kotlin 复制代码
List::class is T::class // ❌ 编译错误！
List::class 和 T::class 都是 KClass<*> 类型的对象（元数据），不是普通对象实例。

is 关键字只能用于实例与类型之间的关系判断 ，不能用于两个 KClass 之间比较继承关系。

所以这行代码根本无法通过编译。
Kotlin 复制代码
val x: Any = "hello"
if (x is String) { ... } // ✅ 正确： x 是一个实例，检查它是否是 String 类型



 val list: List<String> = ArrayList<String>()
  println(list is List<*>)      // ✅ 正确：  list 实例 是 List 类型

 

Kotlin 复制代码

  val list: List<String> = ArrayList<String>()
        println(list is List<*>)      // true → list 实例 是 List 类型
        
        println(list is ArrayList<*>) // true → list 是 ArrayList 类型
        println(list is MutableList<*>)  // true → list 是 MutableList 类型
        // println(list is String)       // false → list 不是 String 类型


        val x: Any = "hello"
        println(x is String)// ✅ 正确：x 是一个实例，检查它是否是 String 类型

`==`：

语法：
Kotlin 复制代码
A::class == B::class
判断两个类是否完全一样(精确匹配）(不继承)。

不关心继承关系，只看是不是"同一个东西"。

== 不能用来判断"是否属于某个类型体系"，只能判断"是不是同一个类/类型"。

Kotlin 复制代码

  println(List::class == List::class)           // true → 同一个接口
        println(List::class == ArrayList::class)      // false → List ≠ ArrayList
        println(ArrayList::class == ArrayList::class) // true → 同一个类


        val obj: List<Int> = ArrayList<Int>()

       // 错误想法：想判断 obj 的类型是不是 List
        println(obj::class == List::class)     // false！因为 obj::class 是 ArrayList
        println(obj::class == ArrayList::class) // true

`isSuperclassOf(other: KClass<*>)`

语法:
Kotlin 复制代码
Parent::class.isSuperclassOf(Child::class)
判断 Parent 是否是 Child 的父类/父接口。

用于类元数据（KClass）之间的继承关系判断。

isSuperclassOf 更全面准确，因为它支持继承。

在 inline 函数中判断泛型 T 是否属于某类体系

Kotlin 复制代码

   println(List::class.isSuperclassOf(ArrayList::class))   // true ✅  ArrayList 是 List 的实现
        println(List::class.isSuperclassOf(MutableList::class)) // true ✅  MutableList 是 List 的子接口
        println(ArrayList::class.isSuperclassOf(List::class))   // false ❌
        println(String::class.isSuperclassOf(Int::class))       // false ❌

`List::class.isSuperclassOf(T::class)`

判断T 是否是 List 的子类或实现类

换句话说：T 是不是一种列表类型？比如 ArrayList、MutableList、MyCustomList 等。

isSuperclassOf 与 ==结合使用

Kotlin 复制代码

/*
*  判断T是什么类型
* 判断传入的参数value   是类型T
*
*
* T 是什么，value 就必须是什么   如果 T 是 List 子类，则 value 必然是 List 实例
* 所以 value.size 安全可用，无需 is List<*> 判断
* */

inline fun <reified T> checkAllType(value: T)  {
    println("类型T=${T::class.simpleName}   ")

    when  {
        T::class == String::class -> println("传入的参数$value ,是一个String类型 ")  // T 是 String，value 也必须是 String 类型
        T::class == Int::class -> println("传入的参数$value ,是一个Int类型 ")    //T 是 Int，value 也必须是 Int 类型
        T::class == User::class ->println("传入的参数$value ,是一个Use类型 ")
        //  在 inline 函数中判断 泛型 T 是否属于 List 的子类/实现类（推荐）
        List::class.isSuperclassOf(T::class)->{
              // 判断传入的参数value :T 必然是 List<*> 类型的实例 所以 value is List<*> 一定为 true
            if(value is List<*>){
                println("传入的参数$value  ,是一个List类型，大小为: ${(value as List<*>).size}")
            }else{
                println("类型是 List，但实际值不是 List 实例: $value")
            }
        }


        else -> println("未知类型: ${T::class.simpleName}")


    }

Kotlin 复制代码

  val myList:List<Int> =listOf(1,2)
          checkAllType<List<Int>>(myList)    // 传入的参数[1, 2]  ,是一个List类型，大小为: 2

         val myList2: MutableList<String> = mutableListOf("1","2")
        checkAllType<MutableList<String>>(myList2) //传入的参数[1, 2]  ,是一个List类型，大小为: 2

         checkAllType<String>("hello")   //传入的参数hello ,是一个String类型


        checkAllType<Int>(123) //传入的参数123 ,是一个Int类型


         val user = User("Alice", 30)

        checkAllType<User>(user) //传入的参数User(name=Alice, age=30) ,是一个Use类型

isSuperclassOf 与is 与 ==的区别

is

为什么不能用 List::class is T::class？

==：

isSuperclassOf(other: KClass<*>)

List::class.isSuperclassOf(T::class)

isSuperclassOf 与 ==结合使用

为什么不能用 `List::class is T::class`？

`==`：

`isSuperclassOf(other: KClass<*>)`

`List::class.isSuperclassOf(T::class)`