泛型

1.1 泛型概述

泛型:是一种未知的数据类型，当我们不知道使用什么数据类型的时候可以使用泛型

泛型也可以看出是一个变量用来接收数据类型

• E e: Element元素
• T t: Type类型

ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据,所以类型使用泛型

• E:末知的数据类型

• 创建集合对象,不使用泛型
  • 好处:集合不使用泛型,默认的类型就是object类型,可以存储任意类型的数据
  • 弊端：不安全,会引发异常

private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍历集合
        //获取迭代器
        Iterator it = list.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        //想要使用String类特有的方法, length获取字符串的长度;不能使用 多态object obj = "abc";
        //需要向下转型
        //会抛出cClassCastException类型转换异常,不能把Integer类型转换的String类型
        String s = (String)obj;
        System.out.println(s.length());
        }
    }

• 创建集合对象,使用泛型
  • 好处:
    1.避免了类型转换的麻烦，存储的是什么类型,职出的就是什么类型
    2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
  • 弊端:
    泛型是什么类型,只能存储什么类型的数据

private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1);  //add(java. lang. String)in Arraylist cannot be applied to (int)
        //使用迭代器遍历集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next+"->"+next.length());
        }
    }

1.2 定义和使用含有泛型的类

定义格式：

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

例如, API中的ArrayList集合:

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

好处：使用含有泛型的类，对象可以是任意数据类型，在对象创建时确定泛型的数据类型。

1.3 定义和使用含有泛型的方法

定义格式：

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

示例：

public class MyGenericMethod {
public <E> void show(E) {
System. out . println(e. getClass());
}
public <E> E show2(E e) {
return e; 
}
}

使用格式：调用方法时，确定泛型的类型。

1.4 定义和使用含有泛型的接口

定义格式：

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

例如：

public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}

1. 第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型

public interface Iterator<E> {
E next();
Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
public final class Scanner implements Iterator<string>{
public String next() {}
}

2. 第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
   就相当于定义了一一个含有泛型的类，创建对象的时候确定泛型的类型

public interface List<E>{
boolean add(E e);
E get(int index);
}
public class ArrayList<E> implements list<E>{
public boolean add(E e) {}
public E get(int index) {}

1.5 泛型通配符

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

通配符基本使用:

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

此时只能接受数据,不能往该集合中存储数据。

示例：

public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("123");
        list02.add("456");
        printArray(list01);
        printArray(list02);
        /*
            定义一个方法,能遍历所有类型的Arraylist集合
            这时候我们不知道Arraylist集合使用什么数据类型,可以泛型的通配符?来接收数据类型
            注意:
            **泛型没有继承概念的,Collection<Object> list = new ArrayList<String> ();这种是错误的.**
         */
    }
    public static void printArray(ArrayList<?> list){
        Iterator it = list.iterator();
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
}

通配符高级使用---受限泛型

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

泛型的上限:

●格式: 类型名称<? extends 类>对象名称
●意义: 只能接收该类型及其子类

泛型的下限:

●格式: 类型名称<?super类>对象名称
●意义: 只能接收该类型及其父类型