java基础知识--泛型

泛型

1、什么是java泛型?有什么作用？

　　泛型概述

　　　　在Java中实现泛型机制的目标是为了可以把发现 bug 的时机提前到编程源码时，而不是运行时。如果在编译时就可以发现 bug ，就可以节省大量的调试Java程序的时间，

　　因为编译错误可以比较容易和比较快速地被发现和修复。而且，泛型仅仅只存在于编译时。

　　示例

　　可以假设泛型不存在　

class Room {

private Object object;

public void add(Object object) {
this.object = object;
}

public Object get() {
return object;
}
}

public class Main {
public static void main(String[] args) {
Room room = new Room();
room.add(60);
//room.add("60"); //this will cause a run-time error
Integer i = (Integer)room.get();
System.out.println(i);
}
}

　　在该示例中，Room 类的具有一个类型为 Objcet 的成员变量 object，因为其类型是Java中的超级父类，所以我们可以传递任何的对象给该类，比如 String、Integer 等等。

　　当我们往 Room 中添加一个 Integer 并转换的时候，该代码运行正确。但是，当我们往 Room 中添加一个 String 并转换的时候，该代码在编译时一切正常，在运行时就会抛出一个

　　如下所示的 ClassCastException：

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
at collection.Main.main(Main.java:21)

　　引入泛型

　　针对上述代码示例出现的问题，我们需要引入泛型机制来解决。如果加入泛型机制，上述代码片段将变成如下所示：

class Room {

private T t;

public void add(T t) {
this.t = t;
}

public T get() {
return t;
}
}

public class Main {
public static void main(String[] args) {
Room room = new Room();
room.add(60);

Integer i = room.get();
System.out.println(i);
}
}

　　如果无意间添加了 room.add(“编码”) 这条语句，一个编译错误就会被IDE检测并报错；

　　总结：　　　　

使用泛型的理由有三：

1. 1. 编译时的强类型检查
   2. 消除显示的类型强制转换
   3. 更好的代码复用性，比如实现泛型算法

Java中的泛型仅仅是一个编译时的概念，在运行时，所有的泛型信息都被消除了，这被称为泛型擦除。

 

 

2、泛型方法

　　可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。　　

　　定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

　　示例1：

　　演示了如何使用泛型方法打印不同字符串的元素：　

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "
双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "
字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

　　编译以上代码，运行结果如下所示：　　　

整型数组元素为:
1 2 3 4 5 

双精度型数组元素为:
1.1 2.2 3.3 4.4 

字符型数组元素为:
H E L L O 

　　示例2：

　　"extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d

",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f

",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s
","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

　　编译以上代码，运行结果如下所示：　　　　

3, 4 和 5 中最大的数为 5

6.6, 8.8 和 7.7 中最大的数为 8.8

pear, apple 和 orange 中最大的数为 pear

3、泛型类　　

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

　　示例：

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d

", integerBox.get());
    System.out.printf("字符串为 :%s
", stringBox.get());
  }
}

　　编译以上代码，运行结果如下所示：

整型值为 :10

字符串为 :菜鸟教程

4、类型通配符

　　　　1、类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。　　　

public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

　　输出结果为：

data :icon
data :18
data :314

　　解析： 因为getData()方法的参数是List类型的，所以name，age，number都可以作为这个方法的实参，这就是通配符的作用

　　　　2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。　

public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

　　输出结果：　

data :18
data :314　

解析： 在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错

3、类型通配符下限通过形如 List<? super Number>来定义，表示类型只能接受Number及其三层父类类型，如Objec类型的实例。

 

补充：

　　<? extends T>和<? super T>的区别

• <? extends T>表示该通配符所代表的类型是T类型的子类。
• <? super T>表示该通配符所代表的类型是T类型的父类。