第九章 泛型和枚举-泛型

第九章 泛型和枚举

一、Java泛型 Generics

1、引入泛型

​ 如根据以前面向对象的知识，我们构建了一个超级数组，但是我们之前构建的那个超级数组只能存放int，不能存放其它数据，如果要存放其它数据我们只能更改源代码，将超级数组内的数组类型修改，这样直接修改我们的代码是极其不理智的一件事情。

超级数组原代码：

public class SuperArray{
    private String name;
    /**
     * 维护一个数组
     */
    private int[] superArray;

    /**
     * 该常量表示数组的默认长度
     */
    private static final Integer DEFAULT_LENGTH = 10;

    /**
     * 该常量表示数组的扩容的阈值
     */
    private static final Double LOAD_NUM = 0.75;

    /**
     * 表示当前数组已占容量
     */
    private Integer currentIndex;

    /**
     * 表示数组总容量
     */
    private Integer capacity;

    public SuperArray() {
        this(DEFAULT_LENGTH);
    }

    public SuperArray(Integer capacity) {
        superArray = new int[capacity];
        this.capacity = capacity;
        currentIndex = -1;
    }

    public void judgeAround(int index){
        if (index < 0 || index > currentIndex)
        {
            throw new RuntimeException("数组索引越界");
        }
    }
    /**
     * 该方法用于检查数组是否需要扩容
     * @return
     */
    public Boolean check(){
        if (currentIndex + 1 >= (Integer) capacity*LOAD_NUM){
            return false;
        }
        return true;
    }

    /**
     * 该方法用于数组的扩容
     */
    public void resize(){
        int oldLen = this.capacity;
        int newLen = this.capacity + this.capacity >> 1;
        int[] tmp = new int[newLen];
        for (int i = 0; i < size(); i++) {
            tmp[i] = superArray[i];
        }
        superArray = tmp;
        tmp = null;
    }

    /**
     * 该方法用于判断数组是否为空
     * @return
     */
    public Boolean isNull(){
        if (superArray == null){
            return false;
        }
        return true;
    }

    public void addToHeader(int data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }

        for (int i = currentIndex; i > 0; i--) {
            superArray[i+1] = superArray[i];
        }
    }

    public void addToTail(int data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }
        superArray[++currentIndex] = data;
    }


    public int get(int index) {
        judgeAround(index);
        return (int)superArray[index];
    }

    public void set(int index, int data) {
        judgeAround(index);
        superArray[index] = data;
    }
    
    public void remove(int index) {
        judgeAround(index);
        for (int i = index; i < size(); i++) {
            superArray[i] = superArray[i+1];
        }
        currentIndex--;
    }
    
    public int size() {
        return currentIndex + 1;
    }

    @Override
    public String toString() {
        final StringBuilder sp = new StringBuilder();
        sp.append("[");
        for (int i = 0; i < size(); i++) {
            sp.append(superArray[i]);
            if ((i + 1) <= size() - 1){
                sp.append(",");
            }
        }
        sp.append("]");
        return sp.toString();
    }
}

由上述问题，我们可以进行改进一下，让我们的超级数组类可以存放任意数据类型的数组。

第一种解决方案：

​ 将内部的int数组，换成Object类型数组，使用引用数据类型替代基础数据类型。因为Object是所有类的超类，所以任何子类都可以传递进去，我们的代码可以简化如下：

public class SuperArray{
    private String name;
    /**
     * 维护一个数组
     */
    private Object[] superArray;

    /**
     * 该常量表示数组的默认长度
     */
    private static final Integer DEFAULT_LENGTH = 10;

    /**
     * 该常量表示数组的扩容的阈值
     */
    private static final Double LOAD_NUM = 0.75;

    /**
     * 表示当前数组已占容量
     */
    private Integer currentIndex;

    /**
     * 表示数组总容量
     */
    private Integer capacity;

    public SuperArray() {
        this(DEFAULT_LENGTH);
    }

    public SuperArray(Integer capacity) {
        superArray = new Object[capacity];
        this.capacity = capacity;
        currentIndex = -1;
    }

    public void judgeAround(int index){
        if (index < 0 || index > currentIndex)
        {
            throw new RuntimeException("数组索引越界");
        }
    }
    /**
     * 该方法用于检查数组是否需要扩容
     * @return
     */
    public Boolean check(){
        if (currentIndex + 1 >= (Integer) capacity*LOAD_NUM){
            return false;
        }
        return true;
    }

    /**
     * 该方法用于数组的扩容
     */
    public void resize(){
        int oldLen = this.capacity;
        int newLen = this.capacity + this.capacity >> 1;
        Object[] tmp = new Object[newLen];
        for (int i = 0; i < size(); i++) {
            tmp[i] = superArray[i];
        }
        superArray = tmp;
        tmp = null;
    }

    /**
     * 该方法用于判断数组是否为空
     * @return
     */
    public Boolean isNull(){
        if (superArray == null){
            return false;
        }
        return true;
    }

    public void addToHeader(Object data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }

        for (int i = currentIndex; i > 0; i--) {
            superArray[i+1] = superArray[i];
        }
    }

    public void addToTail(Object data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }
        superArray[++currentIndex] = data;
    }


    public int get(int index) {
        judgeAround(index);
        return (int)superArray[index];
    }

    public void set(int index, Object data) {
        judgeAround(index);
        superArray[index] = data;
    }

    public void remove(int index) {
        judgeAround(index);
        for (int i = index; i < size(); i++) {
            superArray[i] = superArray[i+1];
        }
        currentIndex--;
    }

    public int size() {
        return currentIndex + 1;
    }

    @Override
    public String toString() {
        final StringBuilder sp = new StringBuilder();
        sp.append("[");
        for (int i = 0; i < size(); i++) {
            sp.append(superArray[i]);
            if ((i + 1) <= size() - 1){
                sp.append(",");
            }
        }
        sp.append("]");
        return sp.toString();
    }
}

但是这样又引发了另一个问题，那就是我们的超级数组里面，每new一个超级数组，这个超级数组什么数据都能往里面塞，里面可以存int，可以存double，可以存我们自己定义的类，一个数组里面的数据的类型可以是任意类型，但是这样就和我们数组的概念相驳了。

1. 我们规定传入的对象只要是Object子类就行，那就意味着，所有的对象都可以往篮子里扔，可以扔水 果，也可以扔炸弹，数据类型不能很好的统一。

2. 从超级数组中获取数据后必须强转才能使用，这是不是意味着，极有可能发生ClassCastException。

3. SuperArray superArray = new SuperArray();
   superArray.add(new Date());
   superArray.add(new Dog());
   (Dog)superArray.get(0);
   

那怎么解决这个问题呢？ 我们的目标是：

1. 能够规定传入的数据类型必须是我们要求的。
2. 从数组中获取的数据必须是确定的类型。

【泛型】就能够很好的解决这个问题。

public interface Super<T> {
    /**
     * 该方法用于头插法
     * @param data 待插入数据
     */
    void addToHeader(T data);

    /**
     * 该方法用于尾插法
     * @param data 待插入数据
     */
    void addToTail(T data);

    /**
     * 该方法用于根据索引，返回元素
     * @param index
     * @return
     */
    T get(int index);

    /**
     * 该方法用于修改元素
     * @param index
     * @param t
     */
    void set(int index,T t);

    /**
     * 该方法用于根据索引，删除元素
     * @param index
     */
    void remove(int index);

    /**
     * 该方法获取数组当前已占容量
     * @return 返回实际已占容量
     */
    int size();
}

public class SuperArray<T> implements Super<T>{
    private String name;
    /**
     * 维护一个数组
     */
    private Object[] superArray;

    /**
     * 该常量表示数组的默认长度
     */
    private static final Integer DEFAULT_LENGTH = 10;

    /**
     * 该常量表示数组的扩容的阈值
     */
    private static final Double LOAD_NUM = 0.75;

    /**
     * 表示当前数组已占容量
     */
    private Integer currentIndex;

    /**
     * 表示数组总容量
     */
    private Integer capacity;

    public SuperArray() {
        this(DEFAULT_LENGTH);
    }

    public SuperArray(Integer capacity) {
        superArray = new Object[capacity];
        this.capacity = capacity;
        currentIndex = -1;
    }

    public void judgeAround(int index){
        if (index < 0 || index > currentIndex)
        {
            throw new RuntimeException("数组索引越界");
        }
    }
    /**
     * 该方法用于检查数组是否需要扩容
     * @return
     */
    public Boolean check(){
        if (currentIndex + 1 >= (Integer) capacity*LOAD_NUM){
            return false;
        }
        return true;
    }

    /**
     * 该方法用于数组的扩容
     */
    public void resize(){
        Integer oldLen = this.capacity;
        Integer newLen = this.capacity + this.capacity >> 1;
        Object[] tmp = new Object[newLen];
        for (int i = 0; i < size(); i++) {
            tmp[i] = superArray[i];
        }
        superArray = tmp;
        tmp = null;
    }

    /**
     * 该方法用于判断数组是否为空
     * @return
     */
    public Boolean isNull(){
        if (superArray == null){
            return false;
        }
        return true;
    }

    @Override
    public void addToHeader(T data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }

        for (int i = currentIndex; i > 0; i--) {
            superArray[i+1] = superArray[i];
        }
    }

    @Override
    public void addToTail(T data) {
        if (!isNull()){
            return;
        }
        if (!check()){
            resize();
        }
        superArray[++currentIndex] = data;
    }


    @Override
    public T get(int index) {
        judgeAround(index);
        return (T)superArray[index];
    }

    @Override
    public void set(int index, T data) {
        judgeAround(index);
        superArray[index] = data;
    }

    @Override
    public void remove(int index) {
        judgeAround(index);
        for (int i = index; i < size(); i++) {
            superArray[i] = superArray[i+1];
        }
        currentIndex--;
    }

    @Override
    public int size() {
        return currentIndex + 1;
    }

    @Override
    public String toString() {
        final StringBuilder sp = new StringBuilder();
        sp.append("[");
        for (int i = 0; i < size(); i++) {
            sp.append(superArray[i]);
            if ((i + 1) <= size() - 1){
                sp.append(",");
            }
        }
        sp.append("]");
        return sp.toString();
    }
}

public class DoubleSuperArray extends SuperArray<Double>{
    public DoubleSuperArray() {
        super();
    }

    public DoubleSuperArray(Integer capacity) {
        super(capacity);
    }

    @Override
    public void judgeAround(int index) {
        super.judgeAround(index);
    }

    @Override
    public Boolean check() {
        return super.check();
    }

    @Override
    public void resize() {
        super.resize();
    }

    @Override
    public Boolean isNull() {
        return super.isNull();
    }

    @Override
    public void addToHeader(Double data) {
        super.addToHeader(data);
    }

    @Override
    public void addToTail(Double data) {
        super.addToTail(data);
    }

    @Override
    public Double get(int index) {
        return super.get(index);
    }

    @Override
    public void set(int index, Double data) {
        super.set(index, data);
    }

    @Override
    public void remove(int index) {
        super.remove(index);
    }

    @Override
    public int size() {
        return super.size();
    }

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

这样我们每次只需定义一个类继承自SuperArray即可，重写父类的方法，在继承声明泛型的具体类型，如下，如果我们的DoubleSuperArray，存放的不是Double类型的数据，那就直接报错了。

2、泛型的定义

什么是泛型？ 泛型就是能够帮助我们把【类型明确】的工作推迟到创建对象或调用方法的时候。

意思就是：我定义类的时候不用管到底是什么类型，new这个对象或者调用这个对象的方法时才确定具体的类型。

泛型主要实现在类、方法上->泛型类、泛型方法

（1）泛型类

public class SuperArray<T> implements Super<T>

（2）泛型方法

public <T> T add(T data)

（3）泛型通配符

1.无界

就是和我们上述解决方法的第一种办法一样，可以传入任意的数据类型，没有边界

2.上界

我们可以使用SuperArray superArray 的形式来约定传入参数B的上界，意思，就是传入的参数只能是B或者B的子类。

3.下界

我们可以使用SuperArray superArray 的形式来约定传入参数B的下界，意思，就是传入的参数只能是B或者B的超类。

（4）泛型擦除

泛型擦除就是我们的代码在编译时，所有的泛型信息都会被擦掉，Java的泛型基本上都是在编译器这个层次 上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，替换成Object这个过程成为类型擦除。也就是说我们有一个泛型SuperArray、SuperArray，编译后变成了SuperArray