泛型的作用（泛型）

什么是泛型

泛型             ，即 “参数化类型 
  
  
  
  
  
 ” 
  
  
  
  
  
 。一提到参数
 
  
 
  
 
  
 
  
 
  
 
  
，最熟悉的就是定义方法时有形参











，然后调用此方法时传递实参 
  
  
  
  
  
  。那么参数化类型怎么理解呢？

顾名思义  
  
  
  
  
  
 ，就是通过泛型指定的不同类型来控制形参限制

 


 


 


 


 


 

。在泛型使用过程中 
  
  
  
  
  
 ，操作的数据类型被指定为一个参数


 


 


 


 


 


 
，这种参数类型可以用在类             、接口和方法中 
 
 
 
 
 
，分别被称为泛型类
 
  
 
  
 
  
 
  
 
  
 
  
、泛型接口











、泛型方法 
 
 
 
 
 
。

常见的泛型变量

E：元素（Element）  
   
   
   
   
   
  ，多用于 java 集合框架

K：关键字（Key）

N：数字（Number）

T：类型（Type）

V：值（Value）

为什么用泛型

提高可读性

使 ClassCastException 这种错误在编译期就检测出来

适用于多种数据类型执行相同的代码（代码复用）

举个例子：

public class Add { //普通方法实现 private static int add(int a, int b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } private static float add(float a, float b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } private static double add(double a, double b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } // 泛型方法实现 private static <T extends Number> double add(T a, T b) { System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue())); return a.doubleValue() + b.doubleValue(); } public static void main(String[] args) { Add.add(1, 2); Add.add(1f, 2f); Add.add(1d, 2d); System.out.println("--------------------------"); // 以下三个都是调用泛型方法 // 此时其实是用一个泛型方法就实现了上面三个重载方法的功能 
   
   
   
   
   
   。 Add.add(Integer.valueOf(1), Integer.valueOf(2)); Add.add(Float.valueOf(1), Float.valueOf(2)); Add.add(Double.valueOf(1), Double.valueOf(2)); } }

泛型的使用方法

泛型类

由我们指定想要传入泛型类中的类型

 

 

 

 

 

 
，把泛型定义在类上
 

 

 

 

 

 
，用户使用该类的时候             ，才把类型明确下来
 

 
 

 
 

 
 

 
 

 
 

 
，比如：定义一个万能的实体数据暂存工具类
 

 

 

 

 

 
。

泛型类在初始化时就把类型确定了

package com.nasus.generic.how; public class EntityTool<T> { private T entity; public T getEntity() { return entity; } public void setEntity(T entity) { this.entity = entity; } public static void main(String[] args) { // 创建对象并指定元素类型 EntityTool<String> stringTool = new EntityTool<>(); stringTool.setEntity("一个优秀的废人"); String s = stringTool.getEntity(); System.out.println(s); // 创建对象并指定元素类型 EntityTool<Integer> integerTool = new EntityTool<>(); // 此时











，如果这里传入的还是 String 类型                   ，那就会在编译期报错 integerTool.setEntity(10); int i = integerTool.getEntity(); System.out.println(i); } }

泛型方法

泛型方法在调用时才确定最终类型

若有返回值
 
 
 
 
 
 
 
 
 
 
 
 
，返回值不需要强转 package com.nasus.generic.how; public class Show { public static <T> T show(T t) { System.out.println(t); return t; } public static void main(String[] args) { // 返回值不用强转

















，传进去是什么             ，返回就是什么 String s = show("一个优秀的废人"); int num1 = show(666); double num2 = show(666.666); System.out.println("------------------------"); System.out.println(s); System.out.println(num1); System.out.println(num2); } }

泛型接口

当实现类不明确泛型接口的类型参数变量时
 
  
 
  
 
  
 
  
 
  
 
  
，实现类也必须定义类型参数变量 public interface Show<T> { void show(T t); } public class ShowImpl<T> implements Show<T>{ @Override public void show(T t) { System.out.println(t); } public static void main(String[] args) { ShowImpl<String> stringShow = new ShowImpl<>(); stringShow.show("一个优秀的废人"); } } 明确泛型接口的类型参数变量 public class ShowImpl2 implements Show<String>{ @Override public void show(String s) { System.out.println("一个优秀的废人"); } }

限定泛型类型变量

限定泛型类型上限

指定了泛型类的父类声明类

在类中使用：

类名 <泛型标识 extends 类>{} // 用在类上 public class Show<T extends Number> { private T show(T t){ System.out.println(t); return t; } public static void main(String[] args) { // 初始化时指定类型 Show<Integer> show = new Show<>(); show.show(6666666); // 报错











，该类只接受继承于 Number 的泛型参数 // Show<String> stringShow = new Show<>(); } }

在方法中使用

定义对象：类名 <泛型标识 extends 类> 对象名称 public class Info<T> { // 定义泛型变量 private T var; public void setVar(T var) { this.var = var; } public T getVar() { return this.var; } public String toString() { return this.var.toString(); } } public class ShowInfo { // 用在方法上  
  
  
  
  
  
 ，只能接收 Number 及其子类 public static void showInfo(Info<? extends Number> t) { System.out.print(t); } public static void main(String args[]) { Info<Integer> i1 = new Info<>(); Info<Float> i2 = new Info<>(); i1.setVar(666666666); i2.setVar(666666.66f); showInfo(i1); showInfo(i2); } } 限定泛型类型下限

定义对象：类名 <泛型标识 extends 类> 对象名称

与指定上限相反 
  
  
  
  
  
 ，指定下限定很简单


 


 


 


 


 


 
，就是相当于指定了泛型类的子类
 

 

 

 

 

 

。

public class ShowInfo { // 只接受 String 的父类 public static void showInfo(Info<? super String> t) { System.out.println(t); } public static void main(String args[]) { Info<String> stringInfo = new Info<>(); Info<Object> objectInfo = new Info<>(); stringInfo.setVar("一个优秀的废人"); objectInfo.setVar(new Object()); showInfo(stringInfo); showInfo(objectInfo); } } 通配符类型 <? extends Parent> 指定了泛型类型的上限 <? super Child> 指定了泛型类型的下届 <?> 指定了没有限制的泛型类型

泛型的使用规范

1  
  
  
  
  
  
 、不能实例化泛型类

2 
  
  
  
  
  
 、静态变量或方法不能引用泛型类型变量 
 
 
 
 
 
，但是静态泛型方法是可以的

3


 


 


 


 


 


 
、基本类型无法作为泛型类型

4 
 
 
 
 
 
、无法使用 instanceof 关键字或 == 判断泛型类的类型

5  
   
   
   
   
   
  、泛型类的原生类型与所传递的泛型无关  
   
   
   
   
   
  ，无论传递什么类型

 

 

 

 

 

 
，原生类是一样的

6

 

 

 

 

 

 
、泛型数组可以声明但无法实例化

7
 

 

 

 

 

 
、泛型类不能继承 Exception 或者 Throwable

8             、不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出