Kotlin学习笔记之泛型一

package com.example.firstkotlin.koltin

import kotlin.concurrent.fixedRateTimer

/**
 * 项目名称 firstKotlin
 * 创建时间 1/3/22 9:15 PM
 *
 * 泛型
 **/
class Genreric {
}


fun main(){
    genericClass()
}

// 泛型类 on 1/3/22 9:24 PM

• 泛型是对类型的抽象
• 泛型的两大好处 1、代码抽象。2、类型安全检查

class Fruit<T>{
    // 限定属性为T类型 on 1/3/22 9:31 PM
    var item:T? = null

    // 限定函数的入参为T on 1/3/22 9:30 PM
    fun price(t:T){
        println(t.toString())
    }
    // 限定函数的返回值为T类型 on 1/3/22 9:31 PM
    fun buy():T{
        return item!!
    }

    // 定义一个泛型方法 on 1/3/22 9:35 PM
    fun <R> weight(r:R):String{
        return "${r}斤"
    }

    //另外一种泛型方法 on 1/3/22 9:39 PM
    fun <MUCH> weight1(much: MUCH):T{
        return item!!
    }
}

// 泛型的约束，将T约束为Orange 的子类或者Orange类型 on 1/3/22 9:43 PM
class Fruit1<T:Orange>(val t:T){
    override fun toString(): String {
        return t.toString()
    }
}

// 苹果 on 1/3/22 9:40 PM
class Apple(){
    override fun toString(): String {
        return "我是一只苹果"
    }
}

// 橘子 on 1/3/22 9:40 PM
open class Orange(){
    override fun toString(): String {
        return "我是一只橘子"
    }
}


// 丑橘 on 1/3/22 9:41 PM
class UglyOrange():Orange(){
    override fun toString(): String {
        return "我是一只丑橘"
    }
}

// 泛型类 on 1/3/22 9:15 PM
fun genericClass(){
    val fruit = Fruit<Apple>()
    fruit.item = Apple()
    println(fruit)
    fruit.price(fruit.item!!)


    val fruit1 = Fruit<Orange>()
    fruit1.item = Orange()
    println(fruit1)
    fruit1.price(fruit1.item!!)
    
    // 泛型中的类型检查 on 1/3/22 9:26 PM
//    fruit.price(Orange()) // 这样是不合法的，因为在fruit中限定了T为Apple on 1/3/22 9:26 PM


    // 泛型方法的调用方式 on 1/3/22 9:37 PM
    fruit.weight(1) // 传入int类型 on 1/3/22 9:37 PM
    fruit.weight(2.0F) // 传入float类型 on 1/3/22 9:37 PM
    fruit.weight(3.5) // 传入double类型 on 1/3/22 9:37 PM
    /**
     * 需要注意泛型方法的定义方式，是在方法名称前面添加<T> T可为其他字符
     * 以上的weight和weight1都是泛型方法的定义
     */


    /**
     * 泛型的约束，在将类型抽象时，可将泛型约束为某一个对象的子类以及其自身
     */
    val fruit11 = Fruit1<Orange>(Orange())
    fruit11.toString()
    val fruit111 = Fruit1<UglyOrange>(UglyOrange())
    fruit111.toString()
    // 以下是不合法的调用方式 on 1/3/22 9:46 PM
    val fruit1111 = Fruit1<Apple>(Apple())
    /**
     * 该语句会出现一下的错误
     * Type argument is not within its bounds.
     * Expected:Orange
     * Found: Apple
     * 可以看到，需要的是一个Orange对象，但是传入的是一个Apple对象。
     */

}