Kotlin入门潜修之类和对象篇—泛型及其原理

   public void test(){
        //使用Object的场景
        Map map = new HashMap();
        map.put("test", 1);
        Integer r = (Integer)map.get("test");//正确！get返回的Object类型可以转换为Integer。因为map中存放的实际类型就是Integer类型。
        String r1 = (String) map.get("test");//错误！运行时会报类型转换异常！因为map中存放的实际类型是Integer类型，而不是String。
        //使用泛型
        Map<String,Integer> map2 = new HashMap<String ,Integer>();
        map2.put("test", 1);
        Integer r3 = map2.get("test");//正确！不用考虑任何类型转换
        String r2 = map2.get("test");//编译不通过！因为map2的值只能是Integer，所以返回的是Integer，而不是String
    }

public class GenericClass<T> {//创建类GenericClass的时候，为其指定了类型参数T。
    void test(T t) {
    }
}

class GenericClass2 {
    <T> void test(T t) {//方法泛型化。声明方法的时候为其指定了类型参数T。
    }
}

        List<Integer> ints = new ArrayList<>();//正确，生成一个类型是Integer的集合
        List<Object> numbers = ints;//!!!错误，List<Integer>不是List<Object>的子类

    public static void main(String[] args) {
        List<Integer> ints = new ArrayList<>();
        List<Object> numbers = ints;//假如java允许这样赋值
        numbers.add("hello");//这句语法显然是成立的，字符串属于Object类型
        Integer i = (Integer) numbers.get(0);//!!!错误，这句代码运行的时候会抛ClassCastException异常
    }

        List<Integer> ints = new ArrayList<>();
        List<Object> numbers = new ArrayList<>();
        numbers.addAll(ints);//!!!正确！

interface IList<E> {//我们定义了一个泛型接口IList
    void addAll(IList<E> list);//我们定义了一个addAll发光法，用于添加list集合
}
//MyList提供IList的默认实现
class MyList<E> implements IList<E> {
    @Override
    public void addAll(IList<E> list) {
    }
}
public class Main {
    public static void main(String[] args) {
        IList<Integer> ints = new MyList<>();
        IList<Object> numbers = new MyList<>();
        numbers.addAll(ints);//!!!错误！
    }
}

boolean addAll(Collection<? extends E> c);

public class Main {
    static void test(List<?> list) {
        //在该方法中测试添加对象，实际上测试的是无界通配符作为类泛型参数的场景，因为list的类型是泛型List即List<?>
        list.add(null);//可以
        list.add(1);//无法添加int
        list.add(new Test2());//无法添加自定义Test2类型对象
        list.add("test");//无法添加字符串类型
    }

    static void test1(List<? extends Number> list) {
        //在该方法中测试添加对象，list.add实际上测试的是通配符作为类泛型参数的场景，因为list的类型是泛型List类即List<? extends Number>
        list.add(null);//可以
        list.add(1);//无法添加int
        list.add(new Test2());//无法添加自定义Test2类型对象
        list.add("test");//无法添加字符串类型
    }

    static void test2(List<? super Number> list) {
        //在该方法中测试添加对象，list.add实际上测试的是通配符作为类泛型参数的场景，因为list的类型是泛型List类即List<? super Number>
        list.add(null);//可以
        list.add(1);//可以
        list.add(new Test2());//错误
        list.add("test");//错误
    }
    public static void main(String[] args) {
        List list = new ArrayList();
        List<Integer> list2 = new ArrayList<>();
        List<Object> list3 = new ArrayList<>();
       //test方法的调用，实际上测试的是无界通配符作为方法形参类型一部分的场景
        test(list);//正确
        test(list2);//正确
        test(list3);//正确
        //test1方法的调用，实际上测试的是子类限定通配符通配符作为方法形参类型一部分的场景
        test1(list);//警告，没有进行类型检测。传入的是List，需要List<? extends Number>类型
        test1(list2);//正确
        test1(list3);//错误，需要List<? extends Number>类型，但传入的是List<Object>
       //test2方法的调用，实际上测试的是父类限定通配符通配符作为方法形参类型一部分的场景
        test2(list);//警告，没有进行类型检测，传入的是List，需要List<? super Number> list类型
        test2(list2);//编译错误，传入的List<String>，然而需要的是List<? super Number>
        test2(list3);//正确
    }
}

        List<? super Number> l = new ArrayList<>();
        l.add(1);//正确，Integer是Number的子类
        l.add(1.1);//正确，Double是Number的子类
        l.add(new Object());//错误，Object不是Number的子类

        List<? extends Number> l2 = new ArrayList<>();
        l2.add(1);//错误，子类限制通配符禁止写
        l2.add(new Object());//错误，子类限制通配符禁止写

//定义 一个泛型接口IList
interface IList<E> {
    E getE();//只有一个getE方法，返回了E类型
}
//定义了一个test方法，该方法接收元素是String类型的集合
void test(IList<String> strs) {
        IList<Object> objs = strs;//这里我们将String集合赋值于Object集合，这在java中显然是不允许的！
}

void test(IList<String> strs) {
        IList<? extends Object> objs = strs;//正确，这里采用了子类限制通配符写法
}

interface IList<out E> {//注意这里使用out修饰，这就是声明处变量
    fun getE(): E//注意这个接口只有get方法返回了E，没有其他任何写入的方法。所以我们使用out修饰了IList接口
}
fun test(strs: IList<String>) {
    val objs: IList<Any> = strs//正确！
}

//这里定义另一个普通的泛型接口
interface Comparable<T> {
    operator fun compareTo(other: T): Int
}
//test测试方法
fun test(x: Comparable<Number>) {
    val y: Comparable<Double> = x//错误！这里想要进行写操作，kotlin是不允许的!!!
}

那么如何解决呢？使用我们的in修饰符即可：
interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}
//test测试方法
fun test(x: Comparable<Number>) {
    val y: Comparable<Double> = x//正确！in修饰符允许我们写
}

//这里定义了一个数组copy的方法
fun copy(from: Array<Any>, to: Array<Any>) {
//假设这里我们就是正常完成了from元素copy到to元素中
//这显然是合情合理的
}
fun test(){
    val ints: Array<Int> = arrayOf(1, 2, 3)
    val any = Array<Any>(3) { "" }
    copy(ints, any)//!!!错误，需要Array<Any>类型，但是传入的是Array<Int>类型
}

fun copy(from: Array<out Any>, to: Array<Any>) {//这里将from声明为了<out Any>泛型，表示不可写，只可读。
}
fun test(){
    val ints: Array<Int> = arrayOf(1, 2, 3)
    val any = Array<Any>(3) { "" }
    copy(ints, any)//正确，编译器已经知道from只可读不可写，所以允许我们这么传入。
}

//from使用了in修饰，表示可写，类似于java中的<? super T>
//接收String及其超类。
fun copy(from: Array<in String>, to: Array<Any>) {
}

fun test(){
    val strs: Array<CharSequence> = arrayOf("1")
    val any = Array<Any>(3) { "" }
    copy(strs, any)//正确，CharSequence是String的超类，符合<in String>的限制
}

class GenericClass<in T, out E>(t: T, val e: E) {
    fun set(t: T) {
        println(t)
    }

    fun get(): E {
        return e
    }
}
//测试方法，详见注释
    fun test() {
        val g1: GenericClass<*, String> = GenericClass(1, "hello")//*代替了in修饰的类型，表示In Nothing
        val g2: GenericClass<Number, *> = GenericClass(1, "hello")//*代替了out修饰的类型，表示out Any?
        val g3: GenericClass<*, *> = GenericClass(1, "hello")

        g1.set(1)//错误。由于*代替了in修饰的类型，表示in Nothing，故没有办法写
        val result: String = g1.get()//正确，该方法实际返回String类型

        g2.set(1)//正确，in修饰的类型，可以传入其子类型，这里为Int，继承与Number
        g2.set(Any())//错误，in修饰的类型，无法传入其超类类型，Any是Number的超类
        val result2: Any? = g2.get()//由于*代替了out修饰的类型，表示out Any?可以读出String的任意父类。换句话说，这个方法本身返回了Any？

        g3.set(1)//同g1，不能写
        val result3: Any? = g3.get()//同g2
    }

class GenericClass<in T, out E> {
    fun m1(t: T) {//可以在泛型类中定义方法，只需要方法的入参泛型化即可。
        println(t)
    }
}

class GenericTest {
    companion object {
        fun <T> m1(t: T) {//在普通类中定义方法，除泛型化入参之外，还应该在方法名前增加<T>修饰。
        }
        @JvmStatic fun main(args: Array<String>) {
            m1(1)//调用方法
            m1<Int>(1)//可以显示指定泛型类型，但是没有必要，直接m1(1)即可。
        }
    }
}

    companion object {
        fun <T : Comparable<T>> sort(list: List<T>) {//sort方法，入参只能是Comparable<T>子类
        }

        @JvmStatic
        fun main(args: Array<String>) {
            sort(listOf(1, 2, 3)) // 正确，Int是Comparable<Int>的子类
            sort(listOf(HashMap<Int, String>())) // !!!错误，HashMap<Int, String> 不是Comparable<HashMap<Int, String>>的子类
        }
    }

fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
                where T : CharSequence,//T必须是CharSequence类型的子类型或者CharSequence类型
                      T : Comparable<T> {//同时T必须是Comparable<T>类型的子类型或者Comparable<T>类型
            return list.filter { it > threshold }.map { it.toString() }
        }

fun <T : Comparable<T>> sort(list: List<T>) {
            if(list is List<String>){//错误，在运行时泛型信息已经被擦除（list的类型在运行时都是List<*>），无法使用is进行类型判断
            }
        }