Java 范型

- 日理万妓 2022-05-23 06:18 128阅读 0赞

# 简介 #

范型（generic）可以参数化类型，这个能力使我们可以定义带范型类型的类或方法，随后编译器会用具体的类型来替换它。

pulic class demo<T> {
      ...
    }

这里的<T>表示形式范型类型，随后可以用一个实际具体类型来替换它。替换范型类型称为范型实例化，一般用E或T表示范型类型。一个好处就是在编译时即可检查到错误，而不是运行时检查错误

没有范型时（运行时报错）：

Comparable c = new Date();
    System.out.println(c.compareTo("red"));

有范型时（编译时即检查出错误）：

Comparable<Date> c = new Date();
    System.out.println(c.compareTo("red"));

# 定义范型类和接口 #

public class GenericStack<T> {
    
     private ArrayList<T> list = new ArrayList<T>();
      
      public int getSize() {
        return list.size();
      }
      
      //提取最上面内容
      public T peek() {
        return list.get(getSize()-1);
      }
      
      //弹栈
      public T pop() {
        T o = list.get(getSize() - 1);
        list.remove(getSize() - 1);
        return o;
      }
      
      //入栈
      public void push(T o) {
        list.add(o);
      }
      
      @Override
      public String toString() {
        return "stack: " + list.toString();
      }
    }

可以为类或者接口定义范型，当使用类创建对象，或者使用类或者接口来声明引用变量时，必须指定具体的类型。

# 范型方法    #

可以为静态方法定义范型类型，下面清单中定义一个范型方法print：

public class GenericMain {
      public static <T> void print(T[] list) {
        for(int i = 0; i < list.length; i++)
          System.out.print(list[i] + " ");
      }
      public static void main(String[] args) {
        Integer[] integers = {1,2,3,4,5};
        String[] string = {"java","scala","groovy"};
        GenericMain.<Integer>print(integers);
        GenericMain.<String>print(string);
      }
    }

注意为了声明方法，将范型类型<T>置于方法头中关键字static之后

public static <T> void print(T[] list)

为了调用范型方法，需要将实际类型放在尖括号内作为方法名的前缀

GenericMain.<Integer>print(integers);

小结，为了定义一个类为范型类型，需要将**范型类型放在类名后面**，例如GenericStack<T>，为了定义一个方法为范型类型，需要将**范型类型放在方法返回类型前面**，例如<T> void max (T o1, T o2),    <T> T getObj (T t)

# 通配范型    #

可以使用非受限通配、受限通配或者下限通配来对一个范型类型指定范围

首先看一个例子，创建一个整型对象栈，然后用max方法找到最大值

public class GenericMax {
      public static void main(String[] args) {
        GenericStack<Integer> stack = new GenericStack<Integer>();
        stack.push(new Integer(2));
        stack.push(new Integer(1));
        stack.push(new Integer(3));
        System.out.println(max(stack));
      }
      public static double max(GenericStack<Number> param) {
        double max = param.pop().doubleValue();
        while(param.getSize() != 0) {
          double value = param.pop().doubleValue();
          max= (value > max) ? value : max;
        }
        return max;
      }
    }

此时会编译错误，提示类型 GenericMax 中的方法 max（GenericStack<Number>）对于参数（GenericStack<Integer>）不适用，尽管Integer是Number的子类，但是GenericStack<Integer>并不是GenericStack<Number>的子类型，为了避免这个问题，通配范型有三种形式----?、? extend T 或者 ？super T，其中T是范型类型。

第一种形式 ？成为非受限通配。

第二种形式 ？extend T 称为受限通配，表示T或者T的一个字类型。

第三种形式 ？super T 称为下限通配，表示T或者T的一个父类型。

所以将上面的max方法修改后即可

public class GenericMax {
      public static void main(String[] args) {
        GenericStack<Integer> stack = new GenericStack<Integer>();
        stack.push(new Integer(2));
        stack.push(new Integer(1));
        stack.push(new Integer(3));
        System.out.println("The max number is: " + max(stack));
      }
      public static double max(GenericStack<? extends Number> param) {
        double max = param.pop().doubleValue();
        while(param.getSize() != 0) {
          double value = param.pop().doubleValue();
          max= (value > max) ? value : max;
        }
        return max;
      }
    }

参考资料：《Java语言程序设计》