适用于多种数据类型执行相同的代码
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;}
复制代码
如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个 add 方法；通过泛型，我们可以复用为一个方法：
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();}
复制代码
泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）看下这个例子：
List list = new ArrayList();list.add("xxString");list.add(100d);list.add(new Person());
复制代码
我们在使用上述 list 中，list 中的元素都是 Object 类型（无法约束其中的类型），所以在取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现 java.lang.ClassCastException 异常。
引入泛型，它将提供类型的约束，提供编译前的检查：
List<String> list = new ArrayList<String>();
// list中只能放String, 不能放其它类型的元素
复制代码
// list 中只能放 String, 不能放其它类型的元素泛型类如何定义使用？从一个简单的泛型类看起：
class Point<T>{ // 此处可以随便写标识符号，T是type的简称 private T var ; // var的类型由T指定，即：由外部指定 public T getVar(){ // 返回值的类型由外部决定 return var ; } public void setVar(T var){ // 设置的类型也由外部决定 this.var = var ; } } public class GenericsDemo06{ public static void main(String args[]){ Point<String> p = new Point<String>() ; // 里面的var类型为String类型 p.setVar("it") ; // 设置字符串 System.out.println(p.getVar().length()) ; // 取得字符串的长度 } }
复制代码
多元泛型
class Notepad<K,V>{ // 此处指定了两个泛型类型 private K key ; // 此变量的类型由外部决定 private V value ; // 此变量的类型由外部决定 public K getKey(){ return this.key ; } public V getValue(){ return this.value ; } public void setKey(K key){ this.key = key ; } public void setValue(V value){ this.value = value ; } } public class GenericsDemo09{ public static void main(String args[]){ Notepad<String,Integer> t = null ; // 定义两个泛型类型的对象 t = new Notepad<String,Integer>() ; // 里面的key为String，value为Integer t.setKey("汤姆") ; // 设置第一个内容 t.setValue(20) ; // 设置第二个内容 System.out.print("姓名；" + t.getKey()) ; // 取得信息 System.out.print("，年龄；" + t.getValue()) ; // 取得信息 } }
复制代码
泛型接口如何定义使用？简单的泛型接口
interface Info<T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型 } class InfoImpl<T> implements Info<T>{ // 定义泛型接口的子类 private T var ; // 定义属性 public InfoImpl(T var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } } public class GenericsDemo24{ public static void main(String arsg[]){ Info<String> i = null; // 声明接口对象 i = new InfoImpl<String>("汤姆") ; // 通过子类实例化对象 System.out.println("内容：" + i.getVar()) ; } }
复制代码
泛型方法如何定义使用？
泛型方法，是在调用方法的时候指明泛型的具体类型。
定义泛型方法语法格式
调用泛型方法语法格式
说明一下，定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型 T，然后才可以用泛型 T 作为方法的返回值。
Class<T>的作用就是指明泛型的具体类型，而 Class<T>类型的变量 c，可以用来创建泛型类的对象。
为什么要用变量 c 来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去 new 一个对象，但可以利用变量 c 的 newInstance 方法去创建对象，也就是利用反射创建对象。
泛型方法要求的参数是 Class<T>类型，而 Class.forName()方法的返回值也是 Class<T>，因此可以用 Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的 Class<T>就是何种类型。在本例中，forName()方法中传入的是 User 类的完整路径，因此返回的是 Class<User>类型的对象，因此调用泛型方法时，变量 c 的类型就是 Class<User>，因此泛型方法中的泛型 T 就被指明为 User，因此变量 obj 的类型为 User。
当然，泛型方法不是仅仅可以有一个参数 Class<T>，可以根据需要添加其他参数。
为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新 new 一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。
泛型的上限和下限？在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
上限
class Info<T extends Number>{ // 此处泛型只能是数字类型 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 demo1{ public static void main(String args[]){ Info<Integer> i1 = new Info<Integer>() ; // 声明Integer的泛型对象 }}
复制代码
下限
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 GenericsDemo21{ public static void main(String args[]){ Info<String> i1 = new Info<String>() ; // 声明String的泛型对象 Info<Object> i2 = new Info<Object>() ; // 声明Object的泛型对象 i1.setVar("hello") ; i2.setVar(new Object()) ; fun(i1) ; fun(i2) ; } public static void fun(Info<? super String> temp){ // 只能接收String或Object类型的泛型，String类的父类只有Object类 System.out.print(temp + ", ") ; }}
复制代码
如何理解 Java 中的泛型是伪泛型？
泛型中类型擦除 Java 泛型这个特性是从 JDK 1.5 才开始加入的，因此为了兼容之前的版本，Java 泛型的实现采取了“伪泛型”的策略，即 Java 在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。
如若转载，请注明出处：开源字节 https://sourcebyte.cn/article/119.html
评论