泛型类，泛型接口，泛型方法，底层擦除机制，可变参数，限类型通配符，反编译xjad

public class test01 {
    //泛型可以用在方法接口类，泛型的类型只能是引用类型而不是基本类型
    public static void main(String[] args) {
        ArrayList<Object> ob = new ArrayList<>();
        //new 集合没有指定泛型 存放的类型是object,
        //集合的迭代器
        ArrayList strings = new ArrayList<>();
        strings.add("m1");
        strings.add("s1");
        strings.add("c1");
        strings.add(12);
        Iterator myiterator=strings.iterator();
        while(myiterator.hasNext())
        {
            //如果取出stirngs 的存放类型，会发现object类型
            //为了避免类型转换异常，要先对类型进行判断
            Object next = myiterator.next();//自动补全ctrl+aalt+v
            if (next instanceof String)//类型匹配instanceof
            {
                String str=(String)next;//强制转换
                System.out.println(str);
            }
            if(next instanceof Integer)
            {
                int a=(Integer) next;
                System.out.println(a);
            }
           // String str=(String)myiterator.next();//做个强转
            //String str=myiterator.next();//直接转会报错，因为存储的是object
           // System.out.println(myiterator.next());一般形式下这样遍历
           // System.out.println(str);//12会报错,因为Integer类型不能强转成Stirng
        }
    }
}

泛型类，泛型接口都是在类名，接口名后尖括号

泛型方法在返回类型前尖括号 public <T> T show(T t){}

--------------------------------------------------------------------------

泛型类，类中的成员属性T 类上定义的泛型类型相同

public class mayikt <T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}//泛型类，在类中定义的成员属性 T 和类上定义的泛型是同一个

这样，创建mayikt类的不同对象，每个对象使用的类型T是不一样的，每个对象的成员方法所用的泛型也是独特的

public class test02 {
    public static void main(String[] args) {
        mayikt<String> str=new mayikt<>();//str是mayikt类的一个对象，使用的泛型String
        str.setT("Q");
        System.out.println(str.getT());
        mayikt<Integer> interger=new mayikt<>();//integer是同一类的另一个对象，使用的泛型Integer
        interger.setT(12);
        System.out.println(interger.getT());
        mayikt ob=new mayikt<>();//有尖括号就算使用泛型，但没规定泛型种类默认Object，是所有引用类型的父类
        ob.setT("1122");
        ob.setT(1222);
    }
}

---------------------------------------------------------------------------------------------------------------------------------

泛型方法，可以用一个类型的同一个对象，但是 方法 的 参数的泛型 和 方法的泛型是一一对应的

public class meite {
    public <T> T show(T t)
    {
        return t;
    }
    //泛型方法，同一对象，传的参数泛型不同，可以用ctrl+alt+v自动补全来验证
}

public class test03 {
    public static void main(String[] args) {
        meite m=new meite();
        System.out.println(m.show("aaa"));//<String> String show(String str)
        System.out.println(m.show(12));
        /*
        快捷键ctrl+alt+v//自动识别返回类型integer,并用show接收
         */
        Integer show = m.show(13);
        Double show1 = m.show(12.3);

----------------------------------------------------------------------------------------------------------------

泛型接口

接口规定泛型，继承接口的类也会使用此泛型

 用到了两个泛型，show方法的泛型M 类的泛型T，方法返回值类型T

public interface Maiyiinterface <T>{
    T show(T t);
}



public class MaiyiIMPL<T> implements Maiyiinterface<T>{
    @Override
    public T show(T t) {
        return t;
    }
}



public class test03 {
    public static void main(String[] args) {
        //泛型接口
        MaiyiIMPL<String> stringMaiyiIMPL = new MaiyiIMPL<>();
        stringMaiyiIMPL.show("a");
         MaiyiIMPL<Integer> integerMaiyiIMPL = new MaiyiIMPL<>();
         integerMaiyiIMPL.show(12);}
}

-----------------------------------------------------------------------------------------------------------

可变参数 String...a，范型底层擦除机制

可变参数是基于数组实现的

package first.day01;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class test04 {
    public static void main(String[] args) {
        System.out.println(sum(1,1,1));
        //int...a 可变参数是基于数组实现a[0]=1,a[1]=1...
        //因为数组长度不能确定，所以有别的参数时把可变参数往往放最后
        sum2(0,1,1);
        Arrays.asList();//ctrl+shift+i 进入源码，发现用的就是可变参数，传入一些参数，返回一个集合
        List<String> strings = Arrays.asList("a", "x", "v");//List<xxx> xxx这样接住
        //但是使用arrays.aslist创建的集合是不能进行添加和删除的，因为创建完了·集合元素个数是不能改变的，不过可以进行修改
        strings.set(0,"m");//输出[m,x,v]
        System.out.println(strings);//直接把集合输出,不会输出地址
        ArrayList<String> strings1 = new ArrayList<>();
        List newlist=strings1;//不要用尖括号，即使是object类型也已经使用泛型了，不可以
        newlist.add(12);//泛型底层的擦除机制，把使用泛型的集合整个付给没使用泛型的集合，泛型就会被擦出，add时不会限制传递类型
        /*
        泛型是在编译阶段限制传递的类型 在运行阶段都是擦除
        底层·class文件 在运行时是 没有使用泛型的
        如何证明：run一下，在out文件夹里拖进xjad反编译发现没用泛型
         */
    }
    public static int sum(int ...a) {
        int s = 0;
        for (int i = 0; i < a.length; i++) {
            s = s + a[i];
        }
        return s;
    }
    public static void sum2(int b,int ...a)
    {
        System.out.println("不参与运算"+b);
        for(int i:a)//证实a是个数组形式存储的
        {
            System.out.println(i);
        }
    }
}

public class xjad {
    public static void main(String[] args) {
        ArrayList<String> sr=new ArrayList<>();
        List l=sr;
        l.add(12);//run后在out找到拖进xjad反编译发现源码根本没用到泛型，这时l的泛型类型object
    }
}

 ----------------------------------------------------------------------

类型通配符

 类型通配符不能add 因为还没限制操作的泛型类型，一般用于接收，剩下的操作用if条件句自己编

带通配符的可以get操作，得到的类型是object

public class test03 {
    public static void printlist(ArrayList<?> thelist)
    {
        Object o = thelist.get(0);
    }
    public static void main(String[] args) {
        ArrayList<String> str=new ArrayList<String>();
        ArrayList<Integer> integers = new ArrayList<>();
        printlist(str);

 alt+ctrl+shift+a 截长图

截图 alt+a

找构造器，getter等：alt+insert