泛型

泛型

​ 是一种未知的数据类型，当我们不知道要使用什么样的数据类型的时候，可以使用泛型。泛型我们也可以把它看作是一个变量，用来接受数据类型。

​ 可以在类或者方法当中预知的使用未知的数据类型

备注：一般在创建对象的时候，将未知的数据类型确定为具体的数据类型，

E e ：Element 元素

T t ：Type 类型

ArrayList在定义集合的时候，不知道在集合当中存储什么样的数据类型，所以类型为泛型

E ： 未知的数据类型

public class ArrayList<E>{
	public boolean add(E e) {}
	public E get(int index) {}
}
创建集合对象的时候，就一定会确定泛型的数据类型
ArrayList<String> list = new ArrayList<>();
会把数据类型作为参数进行传递,把String数据类型赋值给泛型E
public class ArrayList<String> {
    public boolean add(String e) {}
    public String get(int index) {}
}

创建对象的时候不使用泛型

​ 好处：可以存储任意数据类型的数据，默认的类型是Object

​ 弊端：不安全，伴随着引发异常

创建对象的时候使用泛型

好处：

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

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

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

泛型的定义与使用

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

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

定义和使用含有泛型的类

​ 定义格式：

修饰符 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
        gm.show(123);//VIP ---> Integer vip = 123
        gm.show02(3.14)//VIP ---> Double vip = 3.14
    } 
}

含有泛型的方法，在调用的时候确定泛型的数据类型

传递什么类型的参数，泛型就会解析为什么类型

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

定义格式：

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

例如：

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

使用格式：

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

   public class MyInterfaceImpl implements MyGenericeInterface<String>{
       @Override
       public void add(String e){
           //...
       }
       @Override
       public String get(){
           //....
       }
   }
   

备注：此时泛型【E的值】就是String类型

2. 始终不确定泛型的类型，知道创建对象的时候，确定泛型的类型
   例如：

   public class MyInterfaceImpl02<> Implements MyGenericInterface<>{
       @Override
       public void add(E e){
           //...
       }
       @Override
       public String get(E e){
           //....
       }
   }
   

   确定泛型：

   //使用泛型
   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>
    //此时换成泛型的通配符?就可以接受
    
    
}
public static void getElement(Collection<?> coll){
    //只能接受Integer类型的数据
    //此时?可以代表任意类型
}

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

当我们不知道Collection集合使用什么数据类型的时候,可以使用泛型的通配符?来接收未知的数据类型
此时只能接收数据,不能往该集合当中存储数据
如果显示的定义Object类型,程序是无法接受其他的数据类型,只能接收Object类型
泛型没有继承概念

使用方式:

​ 不能再创建对象的时候使用
​ 只能作为方法的参数
​ 如果使用泛型作为参数传递时,系统默认添加?
​ 添加?之后,系统会把集合当中的元素解析成Object类型,

泛型通配符的高级使用—>受限泛型(泛型的上限和下限)

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

泛型的上限

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

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

泛型的下限

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

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

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

示例：

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