首页 > 代码库 > java学习笔记10--泛型总结
java学习笔记10--泛型总结
java学习笔记系列:
java学习笔记9--内部类总结
java学习笔记8--接口总结
java学习笔记7--抽象类与抽象方法
java学习笔记6--类的继承、Object类
java学习笔记5--类的方法
java学习笔记4--对象的初始化与回收
java学习笔记3--类与对象的基础
java学习笔记2--数据类型、数组
java学习笔记1--开发环境平台总结
本文地址：http://www.cnblogs.com/archimedes/p/java-study-note10.html，转载请注明源地址。
集合类中的数据类型
集合类中可以存储各种数据，数据一旦存入，其类型均会转化为Object类型。从集合类中取出数据时，一般均需要将Object类型转换回存入之前的实际类型
Vector v=new Vector();v.add("张三"); //存入字符串String name=(String)v.get(0); //强制类型转换，OKv.add(new Date()); //存入当前时间对象，OK // 由于Date类型不能转换为String，下面语句会在运行时发生错误，但这种错误在编译时不会被检查出来String date=(String)v.get(1); //编译器不会发现这里有问题
强类型集合
传统的集合类的实例中可以存储任意类型数据，这种集合类称为弱类型集合类。JDK1.5以后，引入了强类型集合类：
强类型集合类中，只能存储指定类型的数据
在强类型集合类中取出数据时，无需进行类型转换处理，如果数据类型不配备，编译时会直接报错
强类型集合并没有引入新的类名，只需在定义原有集合对象时，用尖括号(<>)指明其存储的数据类型名称即可。
举个例子：
//下面的向量类的实例中只能存储字符串类型数据Vector<String> v=new Vector<String>(); v.add("hello"); //加入的是字符串，OKString name=v.get(0); //取出时，无需做类型转换,如果想在这种强类型集合中加入日期数据，在编译时就会报告错误v.add(new Date()); //编译器会直接报告类型不匹配错误
泛型类
定义泛型(Generics)类
强类型集合采用了JDK1.5引入的泛型语法。泛型相当于类中一种特殊的类型，这种类型的特点是在实例化该类时可指定为某个具体的实际类型。
声明包含泛型的类的格式如下：
[访问修饰符] class 类名<泛型1,泛型2,…> { 泛型1 泛型成员1; 泛型2 泛型成员2; //.... }
声明中的泛型1、泛型2等等泛型符号可以是任意合法的Java标识符。
泛型类的声明示例
//此处声明了一个包含泛型T的泛型类,T代表所有可能的类型，而T的实际类型在Generic类实例化时指定。class Generic<T> { private T f; //f为泛型成员 public void setF(T f) {//setF方法的参数类型为泛型T this.f = f; } public T getF() {//getF方法的返回类型为泛型T return f; }}
泛型类的实例化
创建泛型类的实例时，可以使用一对尖括号指定泛型的真正类型
public class test { public static void main(String args[ ]) { //f1中的泛型T在此指定为Boolean类型 Generic<Boolean> f1 = new Generic<Boolean>(); //f2中的泛型T在此指定为Integer类型 Generic<Integer> f2 = new Generic<Integer>(); //f1的setF方法只能接受Boolean类型的数据 f1.setF(new Boolean(true)); Boolean b = f1.getF(); System.out.println(b); //f2的setF方法只能接受Integer类型的数据 f2.setF(new Integer(10)); Integer i = f2.getF(); System.out.println(i); }}
实例化时的泛型的默认类型
泛型类实例化时，并不一定要指明泛型对应的实际类型，此时会使用Object作为泛型的默认类型
Generic f3 = new Generic();f3.setF(new Boolean(false));
编译时编译器会发出警告：
Note: Generic.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
建立类型为泛型类的数组
如果要建立泛型类的数组，需要注意new关键字后面不要加入泛型的实际类型名，如下所示：
Generic<String>[] gs; //声明泛型类的数组//先对泛型数组进行初始化gs = new Generic[5]; //不要写成new Generic<String>[5]//再分别为每一个数组元素进行初始化gs[0] = new Generic<String>();//为第一个数组元素赋值//....
包含多个泛型的类定义示例
包含有两个泛型定义的类声明和实例化：
class Generic2<T1, T2> { private T1 f1; private T2 f2; //...}//给出泛型T1， T2的实际类型Generic<Integer, Boolean> f = new Generic<Integer, Boolean>();//没有给出泛型T1， T2的实际类型Generic f1 = new Generic(); //T1， T2将默认为是Object类型
泛型成员的使用
在泛型类中的泛型成员不能直接实例化，其实例必须要通过方法的参数传递给泛型成员：
class Generic<T> { private T[] array; //此处不能用new T[]实例化array public void setArray(T[] array) { this.array = array; } public T[] getArray() { return array; }}
测试程序：
public class test { public static void main(String args[ ]) { String[] strs = {"red", "black", "green"}; Generic<String> f = new Generic<String>(); //向泛型成员array传递实际的字符串数组 f.setArray(strs); //读取泛型成员array的值，将其赋给字符串数组变量strs strs = f.getArray(); }}
泛型成员的可用方法
由于泛型类型只有在类实例化后才能确定，类中的泛型成员只能使用Object类型中的方法：
class Generic<T>{ T f; void setF(T f){ this.f = f; } //.... void doSome(){ //getClass和toString都是Object中的方法 System.out.println(f.getClass().getName()); System.out.println(f.toString()); }}
测试程序：
public class javatest { public static void main(String args[ ]) { String strs = "hello"; Generic<String> f = new Generic<String>(); f.setF(strs); f.doSome(); }}
限制泛型上限类型
extends关键字用来指定泛型的上限，在实例化泛型类时，为该泛型指定的实际类型必须是指定类的子类或指定接口的子接口
import java.util.List;public class ListGeneric<T extends List> { private T list; public void setList(T list) { this.list = list; } public T getList() { return list; }}
在限定泛型的类型时，无论要限定的是接口或是类，都要使用extends关键词
测试例子：
ListGeneric<Vector> f1 = new ListGeneric<Vector>();ListGeneric<ArrayList> f2 = new ListGeneric<ArrayList>();
如果不是List的类型，编译时就会发生错误：
ListGeneric<HashMap> f3 = new ListGeneric<HashMap>();type parameter java.util.HashMap is not within its boundListGeneric<HashMap> f3 = new ListGeneric<HashMap>();
默认的泛型限制类型
定义泛型类别时，如果只写以下代码：
class Generic<T> { //...}
相当于下面的定义方式:
class Generic<T> extends Object { //...}
限定泛型上限后的成员可用方法:
class ListGeneric<T extends List>{ private T list; public void setList(T list) { this.list = list; } public void doSome() { //ad、get方法都是List接口中定义的方法 list.add(new Integer(0)); System.out.println(list.get(0)); }}
Object是所有类的父类，因此，所有的类型的实例都可赋值给声明为Object类型的变量
Boolean f1 = new Boolean(true);Integer f2 = new Integer(1);Object f = f1; //okf = f2; //ok
在实例化泛型类时，将泛型指定为Object类型却不存在着和其他类型之间的兼容性：
Generic<Boolean> f1 = new Generic<Boolean>();Generic<Integer> f2 = new Generic<Integer>();Generic<Object> f=f1; //f1和f类型并不兼容,发生编译错误f=f2; //f2和f类型同样不兼容，也会发生编译错误
泛型通配字符（Wildcard）
泛型类实例之间的不兼容性会带来使用的不便。使用泛型通配符(?)声明泛型类的变量可以解决这个问题
Generic<Boolean> f1 = new Generic<Boolean>();Generic<Integer> f2 = new Generic<Integer>();Generic<Object> f3 = new Generic<Object>();Generic<?> f;f = f1; //okf = f2; //okf = f3; //ok
通配符也可以用于方法的参数类型的声明，表示该参数可接受对应泛型类型的任意实例。
以下类定义中的printCollection方法可以打印任意强类型集合中的内容
class test { //Collection<?>可以匹配任意强类型的集合 static void printCollection(Collection<?> c) { for(Object o : c) System.out.println(o); }}
和限制泛型的上限相似，同样可以使用extends关键字限定通配符匹配类型的上限：
Generic<? extends List> f = null;f = new Generic<ArrayList>(); //ok//...f = new Generic<Vector>(); //ok//...//以下语句会发生编译错误，因为HashMap没有实现List接口f = new Generic<HashMap>();incompatible typesfound : Generic<java.util.HashMap>required: Generic<? extends java.util.List>f = new Generic<HashMap>();
限定通配符匹配类型的下限
还可以使用super关键词将通配符匹配类型限定为某个类型及其父类型:
//将f限定为只能代表采用java.sql.Date的父类实例化的Generic<? super java.sql.Date> f = null;f = new Generic<java.sql.Date>(); //ok //OK，java.util.Date是java.sql.Date的父类f = new Generic<java.util.Date>(); //错误，因为String不是java.sql.Date的父类f = new Generic<String>();
泛型方法
不仅类可以声明泛型，类中的方法也可以声明仅用于自身的泛型，这种方法叫做泛型方法。其定义格式为：
访问修饰符 <泛型列表> 返回类型 方法名(参数列表){
实现代码
}
其中泛型列表为用逗号分隔的合法Java标识符。
在泛型列表中声明的泛型，可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明。类中其他方法不能使用当前方法声明的泛型。使用泛型方法可以解决上述的泛型通配符造成的问题
泛型方法声明示例:
class cc{ /* 方法fun声明了一个泛型T，该方法将任意类型的数组a中的所有 元素复制到相应的强类型集合c当中而不会导致编译错误。 此处的泛型声明T仅作用于fun方法的声明部分和实现代码部分。 */ public static <T> void fun(T[] a, Collection<T> c){ for(T o : a) c.add(o); //不会出现类似通配符的编译错误 }}
调用泛型方法和调用普通方法没有任何不同，只需要传递含有具体类型的实参即可：
泛型方法的调用示例：
//对cc中定义的泛型方法fun进行调用测试public class javatest { public static void main(String args[ ]) { String[] sa = new String[100]; Collection<String> cs = new Vector<String>(); Collection<Object> co = new Vector<Object>(); cc.fun(sa, cs); //fun中的泛型T此时匹配类型String cc.fun(sa, co); //fun中的泛型T此时匹配类型Object }}
限定泛型方法中泛型类型
泛型方法中的声明的泛型，同样可以使用extends关键字限定其类型的下限：
class cc{ //限定aToC方法中的泛型T必须是实现了序列化接口的类型 public static <T extends java.io.Serializable> void fun(T[] a,Collection<T> c){ for(T o : a) c.add(o); }}
继承中的泛型
继承时如需保留父类泛型，需要在声明时加入父类泛型
class subGeneric<T1, T2, T3> extends Generic<T1, T2> { private T3 f3; public void setF3(T3 f3) { this.f3 = f3; } public T3 getF3() { return f3; }}
如果不保留父类中的泛型声明，则继承下来的T1与T2自动变为Object类型。建议父类中的泛型声明在子类中都要保留
继承时指定父类的泛型类型
public class SubGeneric<T3> extends Generic<String, Object> { private T3 f3; public void setF3(T3 f3) { this.f3 = f3; } public T3 getF3() { return f3; }}
泛型接口
接口也可包含泛型的声明:
interface I<T1, T2> { T1 getT1(); T2 getT2(); //...}
实现泛型接口时，类在定义时可以不声明泛型接口中的泛型，此时接口中的泛型也会自动变为Object类型：
class IC implements I { public Object getT1() { } public Object getT2() { } //...}
泛型接口的实现
class IC<T1, T2> implements I<T1, T2> { public T1 getT1() { } public T2 getT2() { } //...}I<String, Integer> i = new IC<String, Integer>();
实现泛型接口时指定泛型类型
在实现泛型接口时，也可直接指定接口中的泛型的实际类型：
interface I<T1, T2> { T1 getT1(); T2 getT2(); //...}//实现接口I时，直接指定泛型T1、T2的类型class IC implements I<String, Integer> { //由于指定接口I中T1类型为String，getT1返回类型必须为String public String getT1() { } //由于指定接口I中T2类型为Integer，getT2返回类型必须为Integer public Integer getT2() { } //...}
泛型和枚举
由于枚举类型不能直接实例化，所以枚举的定义中不能含有泛型的声明，但枚举中可包含泛型方法的定义。
public enum TrafficLight{ Red,Amber,Green; private int duration; public static <T> void avgDuration(Collection<T> carType){ //.... } //....}
java学习笔记10--泛型总结