1、介绍
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
好处
- 提高代码的重用性；
- 防止类型转换异常，提高代码的安全性；
2、泛型方法
可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。
下面是定义泛型方法的规则：
所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 < E >）。
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。
java 中泛型标记符：
- E - Element (在集合中使用，因为集合中存放的是元素)
- T - Type（Java 类）
- K - Key（键）
- V - Value（值）
- N - Number（数值类型）
- ？ - 表示不确定的 java 类型
实例：使用泛型方法打印不同类型的数组元素
public class Main
{
public static void main(String[] args) {
//只能使用引用类型
Integer arr1[]={1,2,3,4,5,6};
Double arr2[]={1.2,2.3,4.5};
Character arr3[]={'a','i','y','p'};
String arr4[]={"ddkdgh","hello","world"};
printArr(arr1);
printArr(arr2);
printArr(arr3);
printArr(arr4);
}
public static <E> void printArr(E[] arr)
{
for(E i:arr)
{
System.out.printf("%s ",i);
}
System.out.println();
}
}1 2 3 4 5 6
1.2 2.3 4.5
a i y p
ddkdgh hello world一个普通类里面可以有泛型方法
public class InterfaceTest
{
public static void main(String[] args)
{
TestA test = new TestA();
// 传入不同类型的数据
test.show("java");
test.show(123);
test.show(456.233);
}
}
class TestA
{
public <T> T show(T t)
{
System.out.println(t);
return t;
}
}3、泛型类
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
实例:定义一个泛型类
class Box<T>
{
private T x;
public void add(T x)
{
this.x=x;
}
public T get()
{
return x;
}
}
public class Main
{
public static void main(String[] args)
{
Box<Integer> b1=new Box<Integer>();
Box<String> b2=new Box<String>();
b1.add(new Integer(10));
b2.add(new String("hello"));
System.out.println(b1.get());
System.out.println(b2.get());
}
}10
hello4、类型通配符
1、类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List,List 等所有 List<具体类型实参> 的父类。
import java.util.*;
public class Main
{
public static void main(String[] args)
{
List<Integer> l1=new ArrayList<Integer>();
List<String> l2=new ArrayList<String>();
l1.add(2);
l2.add("hello");
getData(l1);
getData(l2);
}
public static void getData(List<?> list)
{
System.out.println(list.get(0));
}
}2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。
import java.util.*;
public class Main
{
public static void main(String[] args)
{
List<Integer> l1=new ArrayList<Integer>();
List<String> l2=new ArrayList<String>();
l1.add(2);
l2.add("hello");
getData(l1);
//getData(l2);//出错
}
//限制了类型
public static void getData(List<? extends Number> list)
{
System.out.println(list.get(0));
}
}3、类型通配符下限通过形如 List<? super Number> 来定义，表示类型只能接受 Number 及其上层父类类型，如 Object 类型的实例。
5、泛型接口
定义泛型接口
package com.java.main;
public interface MyInterface<T>
{
T show(T t);
}实现泛型接口
package com.java.main;
public class InterfaceTest
{
public static void main(String[] args)
{
// 方式1
ImpTest t1 = new ImpTest();
t1.show("你好，Java");
// 2、方式2
ImpTest1<String> t2 = new ImpTest1<String>();
t2.show("你好c++");
}
}
// 1、实现泛型接口，实现类里面直接给定类型参数
class ImpTest implements MyInterface<String>
{
public String show(String s)
{
System.out.println(s);
return s;
}
}
//2、实现泛型接口，实现类不直接给定类型参数，而是保持为泛型
class ImpTest1<T> implements MyInterface<T>
{
public T show(T t)
{
System.out.println(t);
return t;
}
}6、一些例子
package com.java.main;
public class GenericTest
{
public static void main(String[] args)
{
// 创建泛型类对象
Generic<String> test = new Generic<String>();
// 2、调用泛型类的方法
test.t = "你好";
System.out.println(test.getT());
test.print("java");
Generic<Integer> test1 = new Generic<Integer>();
test1.t=1234;
System.out.println(test1.getT());
test1.print(123456);
}
}
class Generic<T>
{
// 1、泛型作为变量类型
T t;
// 2、泛型作为参数类型
public void print(T t)
{
System.out.println(t);
}
// 3、泛型作为函数返回值类型
public T getT()
{
return t;
}
}
