Java基础-泛型类、泛型方法、泛型接口

泛型的简单使用

集合中存储数据，使用到的泛型

// 如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
// 此时可以往集合添加任意的数据类型。
// 带来一个坏处:我们在获取数据的时候，无法使用他的特有行为。
// 此时推出了泛型，可以在添加数据的时候就把类型进行统一.
// 而且我们在获取数据的时候，也省的强转了，非常的方便,
ArrayList<String> strings = new ArrayList<>();

strings.add("nxj");
//strings.add(123);

Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()){
    String next = iterator.next();
    System.out.println(next.length());
    System.out.println(next);
}

深入研究泛型

Java中泛型其实是伪泛型；
例如：在编译阶段，泛型类Box会被实例化为Box和Box。编译器会根据需要插入类型转换代码来保证类型安全。
然而，在运行时，所有的泛型类型参数T都会被擦除，stringBox和integerBox实际上是相同的类型Box。因此，存放在盒子中的数据在运行时都被当作Object类型处理。
最后会多做一步强转，通过类型转换为泛型类型，这样可以确保获取到正确的数据类型。

写基本数据类型无法转为Object类型

泛型类

示例代码

/**
 * 不确定类型，那么这个类就可以定义为泛型类
 * @param <E>
 */
class MyArrayList<E>{
    Object[] obj = new Object[10];
    int size;

    // E:表示不确定的类型，该类型在类名后面已经定义过了
    // e:形参的名字，变量名
    public boolean add(E e){
        obj[size] = e;
        size++;
        return true;
    }
    // 最后要做一次强转，将Object类型转换为泛型类型
    public E get(int index){
        return (E)obj[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(obj);
    }
}

// 对于这种类，在创建引用类型时必须指定类型
MyArrayList<String> stringMyArrayList = new MyArrayList<String>();
stringMyArrayList.add("a");
stringMyArrayList.add("b");
stringMyArrayList.add("c");
System.out.println(stringMyArrayList);

结果

泛型方法

当一个类中只有一个方法的类型不确定，就不用把泛型加在类上面，而是写在方法上

所以这时有两个方案，当方法中形参类型不确定时：

1. 使用类名后面定义的泛型
2. 在方法上申明自己要用的泛型

示例代码：

public class ListUtil {
    private ListUtil(){}

    /**
     * 参数是集合以及添加的元素
     * @param list
     * @param e1
     * @param e2
     * @param e3
     * @param <E>
     */
    public static <E> void addAll(ArrayList<E> list, E e1, E e2, E e3){
        list.add(e1);
        list.add(e2);
        list.add(e3);
    }

	// 第一个参数是一个类型为ArrayList<E>的列表，第二个参数是一个可变参数，可以传入任意数量的E类型的元素。
    public static <E> void addAll2(ArrayList<E> list, E...e){
        for (E element: e) {
            list.add(element);
        }
    }
}

需要注意的是，可变参数必须是方法参数列表的最后一个参数，而且每个方法只能有一个可变参数

public class demo3 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        ListUtil.addAll(strings, "a", "b", "c");
        System.out.println(strings);

        ArrayList<Integer> integer = new ArrayList<>();
        ListUtil.addAll(integer, 1, 2, 3);
        System.out.println(integer);

        ArrayList<Integer> integer2 = new ArrayList<>();
        ListUtil.addAll2(integer2, 1, 2, 3, 4, 5);
        System.out.println(integer2);
    }
}

泛型接口

public class demo4 {
    public static void main(String[] args) {
        // 泛型接口的两种使用方法:
        // 1. 实现类给出具体的方法
        // 2. 实现类延续泛型，创建实现类对象时再确定类型

        // 第一种
        MyArrayList2 strings = new MyArrayList2();
        // 第二种
        MyArrayList3<String> strings1 = new MyArrayList3<>();
    }
}
class MyArrayList2 implements List<String> {
	// 实现方法省略
}

class MyArrayList3<E> implements List<E> {
	// 实现方法省略
}