泛型

泛型概述：

泛型：可以在类或者方法当中预支的使用未知的数据类型。

备注：一般在创建对象的时候，将未知的数据类型确定为具体的数据类型，当没有指定泛型时，默认类型为Object类型。

使用泛型的好处：

• 避免了类型转换的麻烦，存储的是什么样的数据类型，取出的就是什么样的数据类型

• 把运行期异常(代码运行之后会抛出的异常)提升到编译期阶段(写代码的时候就会报错)

备注：泛型它其实也是数据类型的一部分，一般我们将类名和泛型合并一起看做数据类型。

泛型的定义与使用

泛型，用来灵活的将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

因为我们的集合框架体系中，大量的使用了泛型。

定义和使用含有泛型的类

定义格式：

修饰符   class 类名<代表泛型的变量> {
    
}

例如：

public class ArrayList<E> {
    public boolean add(E e){}
    public E get(int index){}
    //....
}

备注：定义的时候使用未知的泛型的变量，使用的时候(创建对象)确定的泛型的的具体类型。

定义并使用含有泛型的方法

定义格式：

修饰符  <代表泛型的变量>  返回值类型  方法名(泛型参数) {}

例如：

public class GenericMethod {
    // 定义带有泛型的方法
    public <VIP> void show (VIP vip) {
        System.out.println(vip);
    }
    // 定义一个含有泛型的返回值
    public <VIP> VIP show02(VIP vip) {
        //.....
        return vip;
    } 
}
// 定义测试类
public class TestGenericMethod {
    public static void main(String[] args){
        // 创建对象
        GenericMethod gm = new GenericMethod();
        // 调用带有泛型的方法
        gm.show("abc");// VIP vip 参数 ---》形参   String str  str="abc"
        gm.show(123);// VIP--->Integer  vip = 123
        gm.show2(3.14);// VIP --->Double vip=3.14
    }
}

定义并使用含有泛型的接口

定义格式：

修饰符  interface  接口名<代表泛型的变量> {}

 例如：

public interface Collection<E> {
    public void add(E e);
    public Iterator<E> iterator();
}
// 自定义一个泛型的接口
public interface MyGenericInterface<T> {
    public abstract void add(E e);
    public abstract E get();
    //....
}

使用格式：

定义实现类时可以确定泛型的类型

2.备注：此时泛型【T的值】就是String类型始终不确定泛型的类型，直到创建对象的时候，确定泛型的类型

例如：

public class MyInterfaceImpl02<T> implements MyGenericInterface<T> {
    @Override
    public void add(T t) {
        //....
    }
    @Override
    public T get(){
        //......
    }
}

确定泛型

/*
    使用泛型
 */
public class Demo04Generic {
    public static void main(String[] args) {
       MyInterface<String>  my =  new MyInterfaceImpl<String>();
        my.add("abc");
        
    } 
}

泛型的通配符

当使用泛型类或者泛型接口，传递的数据中，泛型的类型不确定，可以通过通配符<?>表示。一旦程序当中使用泛型的通配符后，只能使用Object类中的共性的方法，集合中元素自身方法无法使用。

通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用?,?代表未知的通配符。

此时只能接收数据，不能往该集合当中存储数据。

代码示例：

public static void main(String[] args) {
    // 可以存储整数的集合
    Collection<Integer> list01 = new ArrayList<Integer>();
    // 此时list01可以存储整数的数据
    // 展示list01集合当中的数据
    getElement(list01);
    // 可以存储String字符串的集合
    Collection<String> list02 = new ArrayList<String>();
    // 此时list02可以存储字符串的数据
    getElement(list02)//   Collection<Object>  ×  不可以
    // 此时如果换成泛型通配符? 就可以接收
    getElement(list02);// 可以        
}
// 可以接收任意的数据类型
public static void getElement(Collection<?> coll){
    // 只能接收Integer类型的数据
    // 此时? 可以代表任意类型
}

备注：泛型不存在继承关系 Collection<Object> list = new ArrayList<String>(); 这是一种错误写法。

通配符的高级用法-----受限泛型

之前设置泛型的时候，实际上是可以任意设置的。只要是类就可以的，但是在Java的泛型当中还可以指定一个的泛型的上限和下限

泛型的上限：

• 格式：类型名称 <? extends 类名> 对象名称

• 意义：只能接收该类型及其子类

泛型的下限

• 格式：类型名称 <? super 类名> 对象名

• 意义：只能接收该类类型及其父类类型

比如说：已知的顶级父类Object，String类，Number类，Integer类 ，其中Number类是Integer的父类

示例代码：

public static void main(String[] args) {
    // 初始化三个集合
    Collection<Integer> list01 = new ArrayList<Integer>();
    Collection<String>  list02 = new ArrayList<Integer>();
    Collection<Number>  list03 = new ArrayList<Integer>();
    Collection<Object>  list04 = new ArrayList<Integer>();
     
    
}
// 定义方法  此时可以接收任意的数据类型
public static void getElement(Collection<?> coll) {//.....}
 // 定义方法，此时我只让该方法接收数字类型 Number类型或者Number的子类
pubic static void getElement(Collection<? extends Number> coll){//...}    
// 定义方法，此时我只让接收Number类型及其以上的类型
public static void getElement(Collection<? super Number> coll) {//....}