1.概述
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。
下面是一个不使用泛型的例子。
public class GenericDemo01 {
public static void main(String[] args) {
Generic g = new Generic();
g.setInfo(100);
String info = (String)g.getInfo();
System.out.println(info);
}
}
class Generic {
private Object info;
public Object getInfo() {
return info;
}
public void setInfo(Object info) {
this.info = info;
}
}2.泛型方法
格式：
访问权限 class 类名称<泛型,泛型...>{
属性
方法
}
对象的创建
类名称<具体类型> 对象名称 = new 类名称<具体类型>();
例子：
public class GenericDemo01 {
public static void main(String[] args) {
Generic<String> gen = new Generic<String>();
gen.setInfo("泛型例子");
String info = gen.getInfo();
System.out.println(info);
Generic<Integer> gener = new Generic<Integer>();
gener.setInfo(100);
System.out.println(gener.getInfo());
}
}
class Generic<T> {
private T info;
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
}
3.构造方法中使用泛型
构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定，而又需要通过构造方法设置属性内容的时候，那么构造方法的定义与之前并无不同，不需要像声明类那样指定泛型。
例子：
public class GenericDemo02 {
public static void main(String[] args) {
Cons<String> con = new Cons<String>("构造方法中使用泛型");
System.out.println(con.getValue());
}
}
class Cons<T>{
private T value;
public Cons(T value){
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}4.设置多个泛型
设置多个泛型直接在<>中添加多个泛型就可以了。如<K,T>
例子：
public class GenericDemo03 {
public static void main(String[] args) {
Gen<String,Integer> gen = new Gen<String,Integer>();
gen.setKey("age");
gen.setValue(100);
System.out.println(gen.getKey());
System.out.println(gen.getValue());
}
}
class Gen<K,T>{
private K key;
private T value;
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}5.通配符的使用
Generic<Integer>与Generic<Number>实际上是相同的一种基本类型。那么问题来了，在使用Generic<Number>作为形参的方法中，能否使用Generic<Integer>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Integer>是否可以看成具有父子关系的泛型类型呢？
public class GenericDemo05 {
public static void main(String[] args) {
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKey(gInteger);//编译报错
}
public static void showKey(Generic<Number> obj){
System.out.println(obj.getKey());
}
}
class Generic<T>{
private T key;
public Generic(T key){
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic<Integer>类型的类，这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。
只需要将showKey方法按如下修改
public static void showKey(Generic<?> obj){
System.out.println(obj.getKey());
}
6.泛型接口
在JDK1.5之后，不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上<T>格式：
interface 接口名称<泛型标识>{}
例子：
public class GenericDemo05 {
public static void main(String[] args) {
Gin<String> g = new Gin<String>("泛型接口");
g.say();
}
}
interface GenInter<T>{
public void say();
}
class Gin<T> implements GenInter<T>{
private String info;
public Gin(String info){
this.info = info;
}
@Override
public void say() {
System.out.println(info);
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
7.泛型方法
在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。泛型类，是在实例化类的时候指明泛型的具体类型。
泛型方法，是在调用方法的时候指明泛型的具体类型 。
1.泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据类型。
2.格式：
访问权限<泛型标识> 泛型标识 方法名称（[泛型标识 参数名称]）
public class GenericDemo06 {
public static void main(String[] args) {
Gener gen = new Gener();
String str = gen.tell("泛型方法");
System.out.println(str);
}
}
class Gener{
public <T> T tell(T t){
return t;
}
}8.泛型上下边界
在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
为泛型添加上边界，即传入的类型实参必须是指定类型的子类型，使用extends关键字。
为泛型添加下边界，即传入的类型实参必须是指定类型或指定类型的父类型，使用super关键字。
泛型上边界例子：
public class GenericDemo07 {
public static void main(String[] args) {
Generics<String> generic1 = new Generics<String>("11111");
Generics<Integer> generic2 = new Generics<Integer>(2222);
Generics<Float> generic3 = new Generics<Float>(2.4f);
Generics<Double> generic4 = new Generics<Double>(2.56);
showKeyValue1(generic1);//编译报错
showKeyValue(generic2);
showKeyValue(generic3);
showKeyValue(generic4);
}
public static void showKeyValue(Generics<? extends Number> obj){
System.out.println(obj.getKey());
}
}
泛型下边界例子：
public class GenericDemo07 {
public static void main(String[] args) {
Generics<Integer> generic2 = new Generics<Integer>(2222);
showKeyValue(generic2);
Generics<Number> generic3 = new Generics<Number>(333);
showKeyValue(generic3);
}
public static void showKeyValue(Generics<? super Integer> obj){
System.out.println(obj.getKey());
}
}
再来一个泛型方法的例子
在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
public <T extends Number> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}9.泛型数组
不能创建一个确切的泛型类型的数组
也就是说下面这条语句不支持
List<String>[] ls = new ArrayList<String>[10];
下面使用一个例子来说明这个问题：
List<String>[] lsa = new List<String>[10]; // Not really allowed.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;
String s = lsa[1].get(0);而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。
数组的类型不可以是类型变量，除非是采用通配符的方式
下面采用通配符的方式是被允许的，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。
List<?>[] lsa = new List<?>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;
Integer i = (Integer) lsa[1].get(0);
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
