泛型

泛型

  • 1、 : T 占位符 表示 当前类是 泛型类
  • 2、放数据时 可以自动进行类型检查
  • 3、取数据时 可以自动进行类型转换
  • 4、泛型是在编译时期的一种机制 -》擦除机制 。 编译时 按照 Object 编译,不是替换成 Object
  • 5、泛型是有边界的
  • 不能 new 泛型类型的数组
  • 泛型类型的参数 不参与类型组成
  • 简单类型 不能 作为泛型类型的参数
class MyStack<T> {
    public T[] elem;
    public int top;

    public MyStack() {
        //this.elem = new T[10];//error 不能 new 泛型类型的数组
        this.elem = (T[]) new Object[10];
    }

    public void push(T val) {
        this.elem[this.top] = val;
        this.top++;
    }

    public T peek() {
        return this.elem[top-1];
    }
}

public class TestDemo2 {
    public static void main(String[] args) {
        MyStack<Integer> myStack = new MyStack<>();
        myStack.push(10);
        myStack.push(20);

        int ret = myStack.peek();
        System.out.println(ret);//20

        MyStack<String> myStack2 = new MyStack<>();
        myStack2.push("abcd");
        myStack2.push("efgh");

        String ret2 = myStack2.peek();
        System.out.println(ret2);//efgh
    }
}

泛型的边界

  • 如果没有给上界,被擦除为 Object,如果有上界,被擦除为上界

  • class Generic<T extends Comparable> 中

  •      <T extends Comparable<T>> 中 Comparable是上界
    
  •      T 一定是实现了 Comparable 接口的(T 一定是 Comparable的子类)
    
  •      T 被擦除为 Compareble
    
  • 泛型没有 下界

写一个泛型类,包含一个方法,该方法是找到数组当中的最大值

class Generic<T extends Comparable<T>> {
    public T maxNum(T[] array) {
        T maxNum = array[0];
        for (int i = 1; i < array.length; i++) {
            if (maxNum .compareTo(array[i]) < 0) {
                maxNum = array[i];
            }
        }
        return maxNum;
    }
}
  • 类型推导 -》 根据实参的类型推导出形参的类型
class Generic2 {
    public static <T extends Comparable<T>> T maxNum(T[] array) {
        T maxNum = array[0];
        for (int i = 1; i < array.length; i++) {
            if (maxNum .compareTo(array[i]) < 0) {
                maxNum = array[i];
            }
        }
        return maxNum;
    }
}

public class TestDemo3 {

    public static void main(String[] args) {
        Integer[] array = {12,3,4,5,1,15,20,8};
        System.out.println(Generic2.maxNum(array));
        String[] str = {"abc","defg","hij"};
        System.out.println(Generic2.maxNum(str));
    }

    public static void main1(String[] args) {
        Generic<Integer> generic = new Generic<>();
        Integer[] array = {12,3,4,5,1,15,20,8};
        System.out.println(generic.maxNum(array));
    }
}
  • 通配符 : 也是一种泛型
  • 通配符一般用于读取 add(?)
  • 泛型一般用于写入 add(T)
  • 通配符既有上界 ,也有下界
  • <? extends 上界> ? 一定是上界的子类
  • <? super 下界> ? 一定是下界的父类

泛型中的父子类型

  • Object 是 所有的 父类
  • 但 MyArrayList 不是 MyArrayList 的父类
  •      因为 泛型 中 <> 里的东西 不参与类型的组成
    
  • 需要通过 通配符 来确定父子类型
  •      MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
    
  •      MyArrayList<? extends Number> 是 MyArrayList<Integer> 的父类型
    
//一个通用方法,打印集合中所有元素
class GenerList {
    public static <T> void printList(ArrayList<T> list) {
        for (T ret:list) {
            System.out.print(ret + " ");
        }
        System.out.println();
    }

    //<?> : 通配符
    public static void printList2(ArrayList<?> list) {
        for (Object ret:list) {
            System.out.print(ret + " ");
        }
        System.out.println();
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        GenerList.printList(list);
        GenerList.printList2(list);
    }
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页