泛型

是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。

• 格式：

• <数据类型>

• 此处的数据类型只能是引用类型。

• 把运行时异常提前到编译时

   //jdk1.5新特性泛型
   List<String> list = new ArrayList<String>();
   //jdk1.7之后
   List<String> list1 = new ArrayList<>();
  

类的泛型

类的泛型是在对象创建的时候对泛型赋值的

public class test <T,E,...>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

泛型类的继承关系

方法的泛型

1.方法的泛型最好和类的泛型一致

public class MyClass <T>{
    public void show(T t) {         //使用了类中的泛型
        System.out.println(t);
    }
}
//---------------------
MyClass<String> mc = new MyClass<>();
mc.show("111");

2.不一致的写法

public class MyClass{
    public <T> void show(T t) {     //声明方法泛型<T>
        System.out.println(t);
    }
}
//---------------------
MyClass mc = new MyClass();         
mc.show("111");                     //在调用该方法时给泛型赋值
mc.show(100);
mc.show('a');

3.静态方法必须有自己的泛型static<T t>，因为类的泛型是在对象创建的时候被赋值的，而静态方法是在类加载的时候就执行了

接口的泛型

1. 实现的时候定义泛型

    public interface Inter<T> {
        void show(T t);
    }
    //--------------------------
    public class InterImpl implements Inter<String>{    //实现的时候定义
        @Override
        public void show(String t) {
            System.out.println(t);              
        }
    }
    //------------------------
    Inter<String> i = new InterImpl();
    i.show("as");
   

2. 实例化的时候定义泛型（*****推荐，Api都是这样写的哟）

    public interface Inter<T> {
        void show(T t);
    }
    //----------------------------
    public class InterImpl<T> implements Inter<T>{
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    //------------------------------
    public static void main(String[] args) {
        Inter<String> i = new InterImpl<>();    //创建对象时定义泛型1
        i.show("as");
    }
   

继承中的泛型

1. 父类是泛型类，子类没有指，默认是Object

    public abstract class Fu<T> {
        abstract  void say(T t);
    }
    class Zi extends Fu<Object>{
        @Override
        void say(Object t) {
            
        }
    }
   

2. 父子都没指定，父类有泛型方法

    public abstract class Fu {
        abstract <T> void say(T t);
    }
    class Zi extends Fu{
        @Override
        void say(Object t) {
            
        }
    }
   

3. 父子都是泛型类，子类的泛型不确定时

    public abstract class Fu<T> {
        abstract  void say(T t);
    }
    class Zi<T> extends Fu<T>{
        @Override
        void say(T t) {
            
        }
    }
   

4. 父子都是泛型类，子类的泛型确定时

    public abstract class Fu<T> {
        abstract  void say(T t);
    }
    class Zi extends Fu<Zi>{
        @Override
        void say(Zi t) {
        }
    }
   

泛型通配符

<?>

通配符

<? extends E>

向下限定，表示E及其子类

<? super E>

向上限定，表示E及其父类

//List<Number> list2 = new ArrayList<Object>();             //报错
List<Number> list = new ArrayList<Number>();
//List<Object> list3 = new ArrayList<Number>();             //报错

List<?> list4 = new ArrayList<Object>();
List<?> list5 = new ArrayList<Number>();
List<?> list6 = new ArrayList<Integer>();


//List<? extends Number> list7 = new ArrayList<Object>();   //  报错
List<? extends Number> list8 = new ArrayList<Number>();
List<? extends Number> list9 = new ArrayList<Integer>();


List<? super Number> list10 = new ArrayList<Object>();
List<? super Number> list11 = new ArrayList<Number>();
//List<? super Number> list12 = new ArrayList<Integer>();       //报错