//泛型類
class Package<T>(t: T) {
    private val product: T = t
    //泛型函數(shù)
    fun openPackage(): T {
        return product
    }
    //多參數(shù)泛型函數(shù)
    fun <R> getProductName(block: (T) -> R): R {
        return block(product)
    }
}

fun main() {
    val pkg = Package(Phone("IPhone"))
    println(pkg.openPackage())
    println(pkg.getProductName {
        it.name
    })
    val pkg2 = Package(Fruit("Apple"))
    println(pkg2.openPackage())
    println(pkg2.getProductName {
        it.name
    })
}

open class Fruit(val name:String){
}
class Apple(name:String) : Fruit(name){
}
class Banana(name:String):Fruit(name){
}

class Package<T:Fruit>(t: T) {
    private val product: T = t
    fun openPackage(): T {
        return product
    }
    fun <R> getProductName(block: (T) -> R): R {
        return block(product)
    }
}
fun main() {
    //定義了泛型約束的類，只能放Fruit的子類
    val pkg = Package(Apple("apple"))
    val pkg2 = Package(Banana("banana"))
    //Phone類型是放不進(jìn)去的
    val pkg3 = Package(Phone("Iphone"))
}

public class Package<T extends Fruit> {
    public T t;
    public Package(T t) {
        this.t = t;
    }
    public T openPackage() {
        return t;
    }
}

class Package<T:Fruit>(list:List<T>) {
    var list = list
    fun get(index:Int):Fruit = list[index]
}

class Package<T : Fruit>(vararg items: T) {
    var itmes: Array<out T> = items
   operator fun get(index: Int): Fruit = itmes[index]
}

fun main() {
    val p = Package22(listOf(Apple("apple")))
    println(p.get(0))
    val p2 = Package(Apple("apple"))
    println(p2[0])
}