泛型,即 "参数化类型",将类型参数化,可以用在类,接口,方法上。 与 Java 一样,Kotlin 也提供泛型,为类型安全提供保证,消除类型强转的烦恼。 声明一个泛型类: 创建类的实例时我们需要指定类型参数: 以下实例向泛型类 Box 传入整型数据和字符串: 输出结果为: 定义泛型类型变量,可以完            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2019-04-29 14:56:00
                            
                                237阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-10-11 10:42:00
                            
                                123阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
             基本使用。两个泛型类型处理class MagicBox<T>(item: T) {    private var subject: T = item    var available = false    //泛型作为返回类型参数    fun fetch(): T? {        //available 为空就返回空 不然就返回实例本身        return s            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-03-16 09:00:29
                            
                                79阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            一、泛型1.泛型类的创建与实例化kotlin中泛型类的创建与实例化与Java中相似:class A<T>(t:T){
    var value=t
}
fun main() {
    var a:A<Int> =A<Int>(11)
}Kotlin中存在类型推断,所以创建实例可以写成:var a=A(11)2.泛型约束我们可以使用泛型约束来设定一个给定参数            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-31 00:20:44
                            
                                89阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Kotlin 泛型也是 Kotlin 语言中较难理解的一个部分。Kotlin 泛型的本质也是参数化类型,并            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-06-19 11:33:02
                            
                                100阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            10.6 泛型的高级特性10.6.1 对泛型进行实化泛型实化是Kotlin中新引入的概念。首先我们需要了解一点,所有基于JVM的语言,如Java、Kotlin,它们的泛型功能都是通过类型擦除来实现的。这种机制使得我们不能使用a is T或者T::class.java这样的语法,因为T的实际类型在运行时已经被擦除了。然而不同的是,Kotlin提供了内联函数的概念,内联函数中的代码在编译的时候会自动被            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-12-17 16:34:32
                            
                                156阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            在学习 kotlin 泛型的时候,经常会遇到 in out 这两个词,一会用in 一会用out,为啥这里要用 out ?为啥哪里用 in ?啥什么用 out 啥时候用in ?对应上面问题以前我是晕乎乎的,不是很明白,于是打算写这篇文章梳理一下,搞清楚怎么回事。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-26 10:53:17
                            
                                185阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            class TypedClass<T>(parameter:T) {
    var value:T=parameter
}
fun main(args:Array<String>) {
    val t1=TypedClass<String>("Hello World")
    val t2=TypedClass<Int>(1231)
              
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-04-08 06:12:05
                            
                                86阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            冒号之后指定的类型就是泛型参数的上界,对于泛型参数T,只允许使用Comparable<T>的子类型            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-08-13 09:48:27
                            
                                322阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            文章目录类型参数区别泛型类和函数泛型类泛型函数类型参数约束类型参数非空、可空 类型参数泛型允许定义带类型形参的类型,当这种类型的实例被创建出来的时候,类型形参被替换成称为类型实参的具体类型实例// 源码listOf函数声明
fun <T> listOf(vararg elements: T): List<T>
val list=listOf("hello","world            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-09-17 19:29:31
                            
                                35阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            一、类型擦除kotlin的泛型规则原理上和java是一样的,不过kotlin在java的基础上对泛型扩展了一些新功能,其中就包括对类型擦除规则的处理。类型擦除: 泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,这个过程被称为类型擦除 意思就是说泛型类型T的真实类型编译器在编译阶段是知道的,一旦进入java虚拟机运行这个T的类型信息会被擦除,以集合类为例:val l1            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-18 09:32:18
                            
                                285阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            JVM 的泛型一般是通过类型擦除实现的,就是说泛型的类型实参在运行时不保留。 和 Java 一样,Kotlin 的泛型在运行时也被擦除了,但是 Kotlin 可以通过将函数声明为 inline 来解决这个问题。Kotlin 可以声明一个 inline 函数,使用实化 reified 使其类型实参不被擦除。类型检查与转换在运行时,List 的类型实参 String 被擦除了,只能知道它是一个 Lis            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-18 09:13:23
                            
                                352阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Kotlin 中也有泛型的概念,和 Java 中的类似,但又不尽相同,一起来认识 Kotlin 中的泛型吧。一、基本使用通常我们会在类、接口、方法中声明泛型:1、泛型类class Animal<T> {}2、泛型接口interface IAnimal<T> {}3、泛型方法fun <T> initAnimal(param: T) {}二、泛型约束泛型约束表示我们            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-12-20 09:26:33
                            
                                379阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            基本使用1.泛型接口interface Generator<T>{
    fun next():T
}
 val gen = object :Generator<Int>{
        override fun next(): Int {
            return 1
        }
    }
    println("result: ${gen.            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-08 09:47:03
                            
                                47阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            文章目录声明泛型函数声明泛型类型变型变的概念不变协变逆变小结声明处型变使用处型变星投影总结 声明泛型函数泛型允许你定义带类型形参的类型。当这种类型的实例被创建出来的时候,类型形参被替换成称为类型实参的具体类型。Kotlin中泛型的使用与声明和Java很相似,我们声明一个泛型函数,可以像下面这么写:fun <T> sayHello(item : T) {  //普通函数
    pri            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-21 22:20:19
                            
                                80阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Java 学习记录 第十六天由于本渣渣是前端转行Java,所以编辑器的选择就直接用 webstorm 同公司的 idea 接下来的知识梳理有一部分会借鉴大佬 廖雪峰的博客学习目标了解Java中对象的概念、掌握泛型学习内容类 与 对象(Object) 的关系Java 泛型的概念编写泛型方法泛型类与普通类的区别类型通配符擦拭法的理解Java 序列化对象Java 反序列化对象类 与 对象(Object)            
                
         
            
            
            
            一、泛型类、二、泛型参数、三、泛型函数、四、多泛型参数、五、泛型类型约束            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-01-28 06:21:12
                            
                                603阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1.泛型泛型允许我们不指定具体类型的情况下进行编程泛型的两种定义方式:泛型类,泛型方法//泛型类
class MyClass {fun method(param: T): T {
    return param
}}//泛型方法
fun  method(param: T): T {
return param
}
具体应用:fun  T.build(block:T.() ->Unit):T{            
                
         
            
            
            
            前言在Kotlin中使用泛型的方式跟Java大体类似,其中也有一些特性的差别。不论是Java中的泛型还是Kotlin中的泛型,总有些概念会让人产生困惑。接下来回结合Java的泛型来学习Kotlin的泛型。Kotlin中泛型的使用在泛型的使用中,最常用到的就是泛型函数以及泛型类。在介绍这两种方式的使用之前,先介绍一下泛型的类型参数。泛型类型参数泛型的类型参数就是在声明泛型时定义的类型形参,表明了在使            
                
         
            
            
            
            泛型就是 “抽象化类型”。就是类型不是一个定值 Int、String、Boolean啥的,而是一个变            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-07-15 12:03:30
                            
                                93阅读
                            
                                                                             
                 
                
                                
                    