Java泛型常见面试题(面试必问)

 List list = new ArrayList();//默认类型是Object
        list.add("A123");
        list.add("B234");
        list.add("C345");
        System.out.println(list);

        for(int i=0;i<list.size();i++){
            //若要将list中的元素赋给String变量，需要进行类型转换，不然会报Incompatible types错误，显示list.get(i)返回的是Object
            String str =  (String) list.get(i);
            System.out.println(str);
        }
​   
        list.add(123);//因为类型是Object，我们可以把Integer类型或者其他数据类型的元素也加入list之中
        System.out.println(list.get(3));
​
        for(int i=0;i<list.size();i++){
            //String str =  (String) list.get(i);//但是在这里会报错java.lang.ClassCastException，我们不能直接将Integer类型的数据转换成String
            System.out.println(list.get(i).getClass());
        }

List<String> strlist = new ArrayList<String>();
        List<Integer> intlist = new ArrayList<Integer>();
​
        strlist.add("A");
        strlist.add("B");
        //strlist.add(123);//编译时报错
​
        for(String str:strlist){
            System.out.println(str);
            //A
            //B
        }
​//加入Java开发交流君样：756584822一起吹水聊天
        System.out.println(strlist.getClass());//class java.util.ArrayList
        System.out.println(intlist.getClass());//class java.util.ArrayList
        System.out.println(strlist.getClass()==intlist.getClass());//true

 //类型被擦除了，保留的是类型的上限，String的上限就是Object
        List list = strlist;
​
        List<String> stringList2 = list;
        List<Integer> intList2 = list;//你也可以把它赋给Integer类型的集合，但是当你把这个集合当成Integer的集合操作的时候，依旧会抛出ClassCastException异常
​
        for (Integer i:intList2){//java.lang.ClassCastException
            System.out.println(i);
        }

class Myset<T>{
    private T value;
    //public static T sval;//cannot be referenced from a static context
    public static int sval2;
​//加入Java开发交流君样：756584822一起吹水聊天
    public Myset(){
​
    }
​
    public Myset(T val){
        this.value = val;
    }
​
    public void setValue(T value) {
        this.value = value;
    }
​
    public T getValue() {
        return value;
    }
​
   
}
       Myset<String> myset = new Myset<>();
       myset.setValue("12345");
       System.out.println(myset.getValue());//12345
​
       myset = new Myset<>("23");
​//加入Java开发交流君样：756584822一起吹水聊天
       System.out.println(myset.getClass());//class liwx.learning.Myset

 public static  <T> void PrintArray(T [] arr){
        System.out.print("[");
        for(T t:arr){
            System.out.print(t+",");
        }
        System.out.println("]");
    }
Integer[]  a = {1,2,3,4,5,6,7};
PrintArray(a);//[1,2,3,4,5,6,7,]

//子类不明确泛型类的参数变量，子类也是泛型类
class MyChiSet1<T> extends Myset<T>{
    public MyChiSet1(){
​
    }
    public MyChiSet1(T val){
        super(val);
    }
​//加入Java开发交流君样：756584822一起吹水聊天
}
//子类明确泛型类的参数变量，子类不是泛型类
class MyChiSet2 extends Myset<String>{
    public MyChiSet2(){
​
    }
    public MyChiSet2(String val){
        super(val);
    }
}

//虽然Object是所有类的基类,但是List<Object>在逻辑上与List<Integer>等并没有继承关系，这个方法只能传入List<Object>类型的数据 
   public static void showOList(List<Object> list){
        System.out.println(list.size());
    }
    //同理，这个方法只能传入List<Number>类型的数据，并不能传入List<Integer>
    public static void showList(List<Number> list){
        System.out.println(list.size());
    }//加入Java开发交流君样：756584822一起吹水聊天
    //使用通配符,List<?>在逻辑上是所有List<Number>,List<Integer>,List<String>……的父类，可以传递所有List类型的数据，但是不能在List<?>类型的数据进行于具体类型相关的操作，如add
    public static void showList2(List<?> list){
        System.out.println("<?>");
        System.out.println(list.size());
    }
    //设置通配符上限，可以传入List<Number及Number的子类>
    public static void showNumList(List<? extends Number> list){
        System.out.println(list.size());
    }
   //设置通配符上限,List<? super Number>只可以传入List<Number及其父类>
    public static boolean Compare(List<? super Number> list1,List<? super Integer> list2){
        return list1.size()>list2.size();
    }

　List<Integer> Intgetlist = new ArrayList<>();
        List<Number> Numberlist = new ArrayList<>();
        //虽然Number是Integet的父类,但是传入List，它们逻辑上没有了继承关系
        System.out.println(Intgetlist.getClass()==Numberlist.getClass());//true
​//加入Java开发交流君样：756584822一起吹水聊天
        //showList(java.util.List<java.lang.Number>)
        //List<Integer>和List<Number>逻辑上无继承关系，所以无法调用
        //showList(Intgetlist);//showList(java.util.List<java.lang.Number>)in FXtest cannot be applied to(java.util.List<java.lang.Integer>)
        showList(Numberlist);
​
       //public static void showList2(List<?> list)
        //通配符List<?>在逻辑上是所有List<具体参数类型>的父类，方法可以传入其子类类型的数据
        showList2(Intgetlist);
        showList2(Numberlist);
​
        // public static void showNumList(List<? extends Number> list)
        //当设定了通配符上限，只能传入List<Number及其子类>的数据
        List<String> Stringlist = new ArrayList<>();
        showNumList(Intgetlist);
        showNumList(Numberlist);//加入Java开发交流君样：756584822一起吹水聊天
        //showNumList(Stringlist);//showNumList(java.util.List<? extends java.lang.Number>)in FXtest cannot be applied to(java.util.List<java.lang.String>)
​
​
        //public static boolean Compare(List<? super Number> list1,List<? super Integer> list2)
        //当设定了通配符下限，List<? super Number>只能传入List<Number及其父类>的数据，不能传入子类Integer的List，
        // 而List<? super Integer>则可以传入其父类Number的List
        //Compare(Intgetlist,Numberlist);
        Compare(Numberlist,Intgetlist);