泛型(目标是类型安全性,主要用于集合):参数化类型:
泛型通配符:
例:
如果我们想参数化方法的参数和返回值的类型,这就引出了泛型方法的声明,声明一个泛型方法的方式如下:// 注意是把参数和返回值的类型参数化
<T> T passThrough(T obj) {
return obj;
}
这个方法限制传入的参数的类型与返回的参数类型将一致,可以看到,在方法签名前加上<T>即可。我们可以这样调用这个方法:
String s1 = "Hello";
String s2 = this.<String>passThrough(s1);
这样的调用是不是比较奇怪?幸好提供了类型推断,根据参数的类型来自动判断方法的类型(比如返回值类型),因此可以直接调用:
String s1 = "Hello";
String s2 = this.passThrough(s1);
如果方法有两个类型变量,类型推断将怎么处理呢?比如:
<T> T passThrough(T obj1,T obj2) {
return (T)(obj1.toString()+obj2.toString());
}
然后我们传入两个参数,一个String,一个int,那么返回什么呢?
String s1="test";
String s3=this.passThrough(s1, 1); //编译出错
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestDemo {
public static void main(String[] args) {
testList();
testGenList();
}
public static void testList(){
List list = new ArrayList();
list.add("麻省理功");
list.add("扑林四吨");
list.add("哈佛");
for(Iterator iter = list.iterator();iter.hasNext();){
String s = (String) iter.next();
System.out.println(s);
}
}
public static void testGenList(){
List <String> list = new ArrayList<String>();
list.add("清华");
list.add("北大");
list.add("南开");
for(String s:list){
System.out.println(s);
}
}
}
泛型通配符:
import java.util.ArrayList;
import java.util.List;
public class TestDemo {
public static void main(String[] args) {
List<Number> list2 = new ArrayList<Number>();
list2.add(new Integer(1)); // new Integer(1) 被类型转化为Number
list2.add(new Long(655));
list2.add(new Double(26.54));
list2.add(25.5);
prt1(list2);
prt2(list2);
List<Integer> list3 = new ArrayList<Integer>();
list3.add(new Integer(1));
list3.add(9); // 9被转化为integer类型
//prt1(list3);
prt2(list3);
}
private static void prt1(List<Number> list){ //方法的参数的泛型
for(Number n:list){
System.out.println(n);
}
}
private static void prt2(List<? extends Number> list){ //传过来的类型是继承于Number的类型就可以
for(Number n: list){
System.out.println(n);
}
}
}
例:
class Gen<T>{
T ob;
Gen(T o){
ob = o;
}
T getOb(){
return ob;
}
void showType(){
System.out.println("type of T is "+ob.getClass().getName());
}
}
public class TestDemo {
public static void main(String[] args) {
Gen<Integer> iOb;
iOb = new Gen<Integer>(33);
iOb.showType();
int v = iOb.getOb();
System.out.println("value: "+ v);
System.out.println("===================");
Gen<String> strOb = new Gen<String>("Generices Test");
strOb.showType();
String str = strOb.getOb();
System.out.println("value: "+str);
}
}
如果我们想参数化方法的参数和返回值的类型,这就引出了泛型方法的声明,声明一个泛型方法的方式如下:// 注意是把参数和返回值的类型参数化
<T> T passThrough(T obj) {
return obj;
}
这个方法限制传入的参数的类型与返回的参数类型将一致,可以看到,在方法签名前加上<T>即可。我们可以这样调用这个方法:
String s1 = "Hello";
String s2 = this.<String>passThrough(s1);
这样的调用是不是比较奇怪?幸好提供了类型推断,根据参数的类型来自动判断方法的类型(比如返回值类型),因此可以直接调用:
String s1 = "Hello";
String s2 = this.passThrough(s1);
如果方法有两个类型变量,类型推断将怎么处理呢?比如:
<T> T passThrough(T obj1,T obj2) {
return (T)(obj1.toString()+obj2.toString());
}
然后我们传入两个参数,一个String,一个int,那么返回什么呢?
String s1="test";
String s3=this.passThrough(s1, 1); //编译出错