详解Java泛型之入门泛型必懂的知识点

[[406054]]

泛型定义

泛型的英文是 generics，generic 的意思是通用,而翻译成中文，泛应该意为广泛，型是类型。所以泛型就是能广泛适用的类型。但泛型还有一种较为准确的说法就是为了参数化类型，或者说可以将类型当作参数传递给一个类或者是方法。我们通过两个实例对比来了解使用泛型和好处。

1.不使用泛型的实例

public class ValueDemo { 
  Object value; 
  public Object getValue() { 
      return value; 
  } 
  public void setValue(Object value) { 
      this.value = value; 
  } 
  public static void main(String[] args) { 
      // TODO Auto-generated method stub 
      ValueDemo demo = new ValueDemo(); 
      demo.setValue(888); 
      int value = (int) demo.getValue(); 
      demo.setValue("hello"); 
      String value1 = (String) demo.getValue(); 
      System.out.println(value); 
      System.out.println(value1);  
  } 
} 

2.使用泛型的实例

public class ValueDemoT { 
      T value; 
      public T getValue() { 
        return value; 
      } 
      public void setValue(T value) { 
        this.value = value; 
      } 
  public static void main(String[] args) { 
      // TODO Auto-generated method stub 
      ValueDemoT<Integer> demo = new ValueDemoT<Integer>(); 
      demo.setValue(888); 
      Integer value = demo.getValue(); 
      ValueDemoT demo1 = new ValueDemoT(); 
      demo1.setValue("hello"); 
      String value1 = demo1 .getValue(); 
      System.out.println(value); 
      System.out.println(value1);  
  } 
} 

通过上面的例子我们可以发现使用泛型的好处主要有三点：

相对于Object 代替一切类型这种方式，泛型不再需要对取出来的结果进行强制转换了!泛型使得数据的类型可以像参数一样由外部传递进来，实现类型参数化。

泛型参数一旦确定好，如果类型不匹配，编译器就不通过。如下图所示：

这是一种类型安全检测机制，一定程度上提高了软件的安全性防止出现低级的失误。

泛型提高了程序代码的可读性，不必要等到运行的时候才去强制转换，在定义或者实例化阶段，因为 ValueDemoT 这个类型显化的效果，程序员能够一目了然猜测出代码要操作的数据类型。

泛型类、泛型方法和泛型接口

泛型按照使用情况可以分为 3 种。

• 泛型类。
• 泛型方法。
• 泛型接口。

泛型类

public class Demo { 
        T field1; 
} 

实例化方法如下：

Demo  demo1=new Demo <>(); 
Demo <Integer> demo2 =new Demo<>(); 

泛型方法

泛型方法必须以进行声明，其中包括有参方法和无参方法，具体代码如下

public class Demo { 
 //无返回值的方法 
  public  void testMethod1(T t){ 
          //code 
} 
 //有返回值的方法 
 public   T testMethod2(T t){ 
return null; 
} 
} 

泛型接口

泛型接口与泛型类的定义及使用基本相同，代码如下：

public interface DemoT { 
    public T test(); 
} 

泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制。

— 泛型的参数使用extends关键字表示参数只能接受类class和其子类。这里的class是上限。

— 泛型的参数使用super关键字表示参数只能接受类class和其父类。这里的class是下限。

使用的代码如下：

public class Vehicle { 
  public void drive() {}; 
  public void brake() {}; 
} 
public class Car extends Vehicle { 
  public void drive() { 
      System.out.println("car的drive方法"); 
  }; 
  public void brake() { 
      System.out.println("car的brake方法"); 
  }; 
} 
public class Benz extends Car{ 
  public void drive() { 
      System.out.println("benz drive"); 
  }; 
} 

定义一个泛型方法

public class CarT { 
  public static void main(String[] args) { 
      getCar(new Benz()); 
      getCar(new Car()); 
      getCar(new Vehicle()); //IDE报错 
  } 
  public static  void getCar(T car) { 
      car.drive(); 
  } 

可以看到方法getCar(T car) 中的参数只能传入 Car类或者其子类的实例，而Car的父类Vehicle的实例则不能传入!super的使用跟extends类似，这里就不再详细讲解了

泛型的注意点

泛型方法中的泛型参数与类的泛型参数没有关联，代码如下：

public class Demo1 { 
  public  T testMethod1(T t){ 
        return t; 
  } 
  public static void main(String[] args) { 
      Demo1 demo=new Demo1 (); 
      Integer i=demo.testMethod1(new Integer(123)); 
      System.out.println(i); 
  } 
} 

可以看到Demo1和testMethod1(T t)可以赋值不同的类型，前者是String而后者是Integer。

出于规范的目的，泛型中的T 只是一种习惯性写法，我们可以把替换为其他标识，例如。常见的其他约定写法如下：

• T 代表一般的任何类。
• E 代表 Element 。
• K 代表 Key 。
• V 代表 Value，通常与 K 一起配合使用。

泛型可以有多个参数，我们以2个参数为例，代码如下：

public class ValueDemoT2 { 
      A value1; 
      B value2; 
      public  void setValue(A p_value1,B p_value2) { 
        value1 = p_value1; 
        value2 = p_value2; 
      } 
  public static void main(String[] args) { 
      ValueDemoT2<Integer,String> demo = new ValueDemoT2<Integer, String>(); 
      demo.setValue(123456,"hello"); 
      System.out.println(demo.value1); 
      System.out.println(demo.value2);  
  } 
} 

执行代码输出：

• 123456
• Hello

泛型类或者泛型方法中，不接受 8 种基本数据类型。例如下面代码则无法编译通过

List<int> li = new ArrayList<>();