泛型基础及深入

泛型深入

泛型定义：

JDK5引入的特性，可以在编译阶段约束操作的数据类型，并进行检查

泛型格式：

<数据类型>

注意：泛型只能支持引用数据类型

优势：

统一数据类型；

把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来。

Java中的泛型是伪泛型：在编译阶段会检查是否符合要求的数据类型，但是在运行期间又是Object类型（泛型的擦除）

细节：

泛型中不能写基本数据类型；

指定泛型的具体类型之后，传递数据时，可以传入该类类型或者子类类型；

如果不写泛型，类型默认是Object；

泛型类：

使用场景：

当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

public class ArrayList<E>{

}

此处的E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型。

定义泛型类：

package com.lazyGirl.nenericsdemo;

import java.util.Arrays;

public class MyArrayList <E>{

    Object[] objs = new Object[10];

    int size = 0;

    public boolean add(E e){

        objs[size] = e;
        size += 1;
        return true;
    }

    public E get(int index){
        return (E )objs[index];
    }

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

测试：



public class GenericTest {
    public static void main(String[] args) {
        MyArrayList<String> mal = new MyArrayList<>();
        mal.add("A");
        mal.add("B");

        System.out.println(mal.get(0));
        System.out.println(mal.toString());

        MyArrayList<Integer> mal1 = new MyArrayList<>();
        mal1.add(1);
        mal1.add(2);
        mal1.add(3);

        System.out.println(mal1.get(0));
        System.out.println(mal1.toString());
    }
}

输出：

泛型方法：

方法中形参类型不确定时，可以使用类名后面定义的泛型<E>（所有方法都能使用）；也可以在方法声明上定义自己的泛型（只有本方法能用）

格式：

public <T> void show(T t){

}

此处T可以理解为变量，用来记录类型

package com.lazyGirl.nenericsdemo;

import java.util.ArrayList;

public class ListUtils {
    private ListUtils() {}

    public static<E> void addAll(ArrayList<E> list,E...e){
        for (E e1 : e) {
            list.add(e1);
        }
    }
}

测试：



import java.util.ArrayList;

public class ListUtilsTest {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<String>();
        ListUtils.addAll(list,"A","B","C","D");
        System.out.println(list);
    }
}

输出：

泛型接口：

格式：

public interface List<E>{

}

如何使用：

方式1：实现类给出具体类型

方式2：实现类延续泛型，创建对象时再确定

package com.lazyGirl.nenericsdemo;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList2 implements List<String> {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }
    //.....
}

泛型不具备继承性，但是数据具备继承性



import java.util.ArrayList;

public class GenericDemo2 {
    public static void main(String[] args) {

        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();

        method(list1);
        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());


    }

    public static void method(ArrayList<Ye> list){

    }
}

class Ye{}

class Fu extends Ye{}

class Zi extends Fu{}

或者：

import java.util.ArrayList;

public class GenericDemo3 {
    public static void main(String[] args) {

        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();

        method(list1);
        method(list2);
        method(list3);
    }

    public static<E> void method(ArrayList<E> list){

    }
}