集合类中的数据类型
集合类中可以存储各种数据，数据一旦存入，其类型均会转化为Object类型。从集合类中取出数据时，一般均需要将Object类型转换回存入之前的实际类型
Vector v=new Vector(); v.add("张三"); //存入字符串 String name=(String)v.get(0); //强制类型转换，OK v.add(new Date()); //存入当前时间对象，OK // 由于Date类型不能转换为String，下面语句会在运行时发生错误，但这种错误在编译时不会被检查出来 String date=(String)v.get(1); //编译器不会发现这里有问题
强类型集合
传统的集合类的实例中可以存储任意类型数据，这种集合类称为弱类型集合类。JDK1.5以后，引入了强类型集合类：
-
强类型集合类中，只能存储指定类型的数据
-
在强类型集合类中取出数据时，无需进行类型转换处理，如果数据类型不配备，编译时会直接报错
-
强类型集合并没有引入新的类名，只需在定义原有集合对象时，用尖括号(<>)指明其存储的数据类型名称即可。
举个例子：
//下面的向量类的实例中只能存储字符串类型数据 Vector<String> v=new Vector<String>(); v.add("hello"); //加入的是字符串，OK String 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 bound ListGeneric<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; //ok f = 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; //ok f = f2; //ok f = 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 types found : 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); } }
原始类型和向后兼容
先看一个泛型类定义
public class GenericStack<E> { ArrayList<E> list = new ArrayList<E>(); public int getSize() { return list.size(); } public E peek() { return list.get(getSize() - 1); } public void push(E o) { list.add(o); } public E pop() { E o = list.get(getSize() - 1); list.remove(getSize() - 1); return o; } public boolean isEmpty() { return list.isEmpty(); } }
可以使用泛型类而无需指定具体类型：
GenericStack stack = new GenericStack(); //大体等价于于下面的语句 GenericStack<Object> stack = new GenericStack<Object>();
再看下面的一个例子：
class Max { public static Comparable max(Comparable o1, Comparable o2) { if(o1.compareTo(o2) > 0) return o1; return o2; } } public class javatest { public static void main(String args[]) { Max.max("welcome", 12); } }
得到一个运行错误：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
结论：原始类型是不安全的，尽量使用泛型类型
一个更好的编写max方法的方式是使用泛型：
class Max { public static <E extends Comparable<E>> E max(E o1, E o2) { if(o1.compareTo(o2) > 0) return o1; return o2; } }
再次调用上面的命令就会显示一个编译错误，由于max方法的两个参数必须是相同的类型
继承中的泛型
继承时如需保留父类泛型，需要在声明时加入父类泛型
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]泛型](https://ucc.alicdn.com/3mfxe2r26qbaq/developer-article1631767/20241030/17e695849c244f56b4c3cbc4e2bbb757.png?x-oss-process=image/resize,h_160,m_lfit)
