全面总结Java泛型
2016-09-20 16:39
288 查看
本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。
AD:51CTO 网+ 第十二期沙龙:大话数据之美_如何用数据驱动用户体验
虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋,所以才想到要创建一个新的语言,不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用,但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结:
普通泛型
----------------------------------------------------------
通配符
受限泛型
----------------------------------------------------------
Java泛型无法向上转型
Java泛型接口
----------------------------------------------------------
Java泛型方法
通过泛型方法返回泛型类型实例
使用泛型统一传入的参数类型
Java泛型数组
Java泛型的嵌套设置
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型.
1、Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样,方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的,这样写class Java_Generics<K,V>,这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子:
//code list 1
import Java.util.Hashtable;
class TestGen0<K,V>{
public Hashtable<K,V> h=new Hashtable<K,V>();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0<String,String> t=new TestGen0<String,String>();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正确输出:value
这只是个例子(Java中集合框架都泛型化了,这里费了2遍事.),不过看看是不是创建一个用类型作为参数的类,参数是K,V,传入的“值”是String类型。这个类他没有特定的待处理型别,以前我们定义好了一个类,在输入输入参数有所固定,是什么型别的有要求,但是现在编写程序,完全可以不制定参数的类型,具体用的时候来确定,增加了程序的通用性,像是一个模板。
呵呵,类似C++的模板(类似)。
1.1. 泛型通配符
下面我们先看看这些程序:
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看这个方法有没有异议,这个方法会通过编译的,假如你传入String,就是这样List<String>。
接着我们调用它,问题就出现了,我们将一个List<String>当作List传给了方法,JVM会给我们一个警告,说这个破坏了类型安全,因为从List中返回的都是Object类型的,而让我们再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List<String> l) {
for (Object o : l)
System.out.println(o);
}
因为这里的List<String>不是List<Object>的子类,不是String与Object的关系,就是说List<String>不隶属于list<Object>,他们不是继承关系,所以是不行的,这里的extends是表示限制的。
类型通配符是很神奇的,List<?>这个你能为他做什么呢?怎么都是“?”,它似乎不确定,他总不能返回一个?作为类型的数据吧,是啊他是不会返回一个“?”来问程序员的?JVM会做简单的思考的,看看代码吧,更直观些。
//code list 4
List<String> l1 = new ArrayList<String>();
li.add(“String”);
List<?> l2 = l1;
System.out.println(l1.get(0));
这段代码没问题的,l1.get(0)将返回一个Object。
1.2. 编写泛型类要注意:
1) 在定义一个泛型类的时候,在 “<>”之间定义形式类型参数,例如:“class TestGen<K,V>”,其中“K” , “V”不代表值,而是表示类型。
2) 实例化泛型对象的时候,一定要在类名后面指定类型参数的值(类型),一共要有两次书写。例如:
TestGen<String,String> t=new TestGen<String,String>();
3) 泛型中<K extends Object>,extends并不代表继承,它是类型范围限制。
2、泛型与数据类型转换
2.1. 消除类型转换
上面的例子大家看到什么了,数据类型转换的代码不见了。在以前我们经常要书写以下代码,如:
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
这个我们做了类型转换,是不是感觉很烦的,并且强制类型转换会带来潜在的危险,系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做,如:
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable<String,Integer> h = new Hashtable<String,Integer> ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了,类型转换的过程交给编译器来处理,是不是很方便,而且很安全。上面是String映射到String,也可以将Integer映射为String,只要写成HashTable<Integer,String> h=new
HashTable<Integer,String>();h.get(new Integer(0))返回value。果然很方便。
2.2 自动解包装与自动包装的功能
从上面有没有看到有点别扭啊,h.get(new Integer(123))这里的new Integer(123);好烦的,在JDK5.0之前我们只能忍着了,现在这种问题已经解决了,请看下面这个方法。我们传入一个int这一基本型别,然后再将i的值直接添加到List中,其实List是不能储存基本型别的,List中应该存储对象,这里编译器将int包装成Integer,然后添加到List中去。接着我们用List.get(0);来检索数据,并返回对象再将对象解包装成int。恩,JDK5.0给我们带来更多方便与安全。
//Code list 7
public void autoBoxingUnboxing(int i) {
ArrayList<Integer> L= new ArrayList<Integer>();
L.add(i);
int a = L.get(0);
System.out.println("The value of i is " + a);
}
2.3 限制泛型中类型参数的范围
也许你已经发现在code list 1中的TestGen<K,V>这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围,怎么做呢?看看如下的代码:
//Code list 8
class TestGen2<K extents String,V extends Number>
{
private V v=null;
private K k=null;
public void setV(V v){
this.v=v;
}
public V getV(){
return this.v;
}
public void setK(K k){
this.k=k;
}
public V getK(){
return this.k;
}
public static void main(String[] args)
{
TestGen2<String,Integer> t2=new TestGen2<String,Integer>();
t2.setK(new String("String"));
t2.setV(new Integer(123));
System.out.println(t2.getK());
System.out.println(t2.getV());
}
}
上边K的范围是<=String ,V的范围是<=Number,注意是“<=”,对于K可以是String的,V当然也可以是Number,也可以是Integer,Float,Double,Byte等。看看下图也许能直观些请看上图A是上图类中的基类,A1,A2分别是A的子类,A2有2个子类分别是A2_1,A2_2。
然后我们定义一个受限的泛型类class MyGen<E extends A2>,这个泛型的范围就是上图中兰色部分。
这个是单一的限制,你也可以对型别多重限制,如下:
class C<T extends Comparable<? super T> & Serializable>
我们来分析以下这句,T extends Comparable这个是对上限的限制,Comparable< super T>这个是下限的限制,Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
2.4. 多态方法
//Code list 9
class TestGen {
<T extends Object> public static List<T> make(T first) {
return new List<T>(first);
}
}
AD:51CTO 网+ 第十二期沙龙:大话数据之美_如何用数据驱动用户体验
虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋,所以才想到要创建一个新的语言,不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用,但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结:
普通泛型
class Point< T>{ // 此处可以随便写标识符号,T是type的简称 private T var ; // var的类型由T指定,即:由外部指定 public T getVar(){ // 返回值的类型由外部决定 return var ; } public void setVar(T var){ // 设置的类型也由外部决定 this.var = var ; } }; public class GenericsDemo06{ public static void main(String args[]){ Point< String> p = new Point< String>() ; // 里面的var类型为String类型 p.setVar("it") ; // 设置字符串 System.out.println(p.getVar().length()) ; // 取得字符串的长度 } };
----------------------------------------------------------
class Notepad< K,V>{ // 此处指定了两个泛型类型 private K key ; // 此变量的类型由外部决定 private V value ; // 此变量的类型由外部决定 public K getKey(){ return this.key ; } public V getValue(){ return this.value ; } public void setKey(K key){ this.key = key ; } public void setValue(V value){ this.value = value ; } }; public class GenericsDemo09{ public static void main(String args[]){ Notepad< String,Integer> t = null ; // 定义两个泛型类型的对象 t = new Notepad< String,Integer>() ; // 里面的key为String,value为Integer t.setKey("汤姆") ; // 设置第一个内容 t.setValue(20) ; // 设置第二个内容 System.out.print("姓名;" + t.getKey()) ; // 取得信息 System.out.print(",年龄;" + t.getValue()) ; // 取得信息 } };
通配符
class Info< T>{ private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } }; public class GenericsDemo14{ public static void main(String args[]){ Info< String> i = new Info< String>() ; // 使用String为泛型类型 i.setVar("it") ; // 设置内容 fun(i) ; } public static void fun(Info< ?> temp){ // 可以接收任意的泛型对象 System.out.println("内容:" + temp) ; } };
受限泛型
class Info< T>{ private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } }; public class GenericsDemo17{ public static void main(String args[]){ Info< Integer> i1 = new Info< Integer>() ; // 声明Integer的泛型对象 Info< Float> i2 = new Info< Float>() ; // 声明Float的泛型对象 i1.setVar(30) ; // 设置整数,自动装箱 i2.setVar(30.1f) ; // 设置小数,自动装箱 fun(i1) ; fun(i2) ; } public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类 System.out.print(temp + "、") ; } };
----------------------------------------------------------
class Info< T>{ private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } }; public class GenericsDemo21{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; // 声明String的泛型对象 Info< Object> i2 = new Info< Object>() ; // 声明Object的泛型对象 i1.setVar("hello") ; i2.setVar(new Object()) ; fun(i1) ; fun(i2) ; } public static void fun(Info< ? super String> temp){ // 只能接收String或Object类型的泛型 System.out.print(temp + "、") ; } };
Java泛型无法向上转型
class Info< T>{ private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } }; public class GenericsDemo23{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; // 泛型类型为String Info< Object> i2 = null ; i2 = i1 ; //这句会出错 incompatible types } };
Java泛型接口
interface Info< T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImpl< T> implements Info< T>{ // 定义泛型接口的子类 private T var ; // 定义属性 public InfoImpl(T var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } }; public class GenericsDemo24{ public static void main(String arsg[]){ Info< String> i = null; // 声明接口对象 i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象 System.out.println("内容:" + i.getVar()) ; } };
----------------------------------------------------------
interface Info< T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImpl implements Info< String>{ // 定义泛型接口的子类 private String var ; // 定义属性 public InfoImpl(String var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(String var){ this.var = var ; } public String getVar(){ return this.var ; } }; public class GenericsDemo25{ public static void main(String arsg[]){ Info i = null; // 声明接口对象 i = new InfoImpl("汤姆") ; // 通过子类实例化对象 System.out.println("内容:" + i.getVar()) ; } };
Java泛型方法
class Demo{ public < T> T fun(T t){ // 可以接收任意类型的数据 return t ; // 直接把参数返回 } }; public class GenericsDemo26{ public static void main(String args[]){ Demo d = new Demo() ; // 实例化Demo对象 String str = d.fun("汤姆") ; // 传递字符串 int i = d.fun(30) ; // 传递数字,自动装箱 System.out.println(str) ; // 输出内容 System.out.println(i) ; // 输出内容 } };
通过泛型方法返回泛型类型实例
class Info< T extends Number>{ // 指定上限,只能是数字类型 private T var ; // 此类型由外部决定 public T getVar(){ return this.var ; } public void setVar(T var){ this.var = var ; } public String toString(){ // 覆写Object类中的toString()方法 return this.var.toString() ; } }; public class GenericsDemo27{ public static void main(String args[]){ Info< Integer> i = fun(30) ; System.out.println(i.getVar()) ; } public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定 Info< T> temp = new Info< T>() ; // 根据传入的数据类型实例化Info temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中 return temp ; // 返回实例化对象 } };
使用泛型统一传入的参数类型
class Info< T>{ // 指定上限,只能是数字类型 private T var ; // 此类型由外部决定 public T getVar(){ return this.var ; } public void setVar(T var){ this.var = var ; } public String toString(){ // 覆写Object类中的toString()方法 return this.var.toString() ; } }; public class GenericsDemo28{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; Info< String> i2 = new Info< String>() ; i1.setVar("HELLO") ; // 设置内容 i2.setVar("汤姆") ; // 设置内容 add(i1,i2) ; } public static < T> void add(Info< T> i1,Info< T> i2){ System.out.println(i1.getVar() + " " + i2.getVar()) ; } };
Java泛型数组
public class GenericsDemo30{ public static void main(String args[]){ Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组 fun2(i) ; } public static < T> T[] fun1(T...arg){ // 接收可变参数 return arg ; // 返回泛型数组 } public static < T> void fun2(T param[]){ // 输出 System.out.print("接收泛型数组:") ; for(T t:param){ System.out.print(t + "、") ; } } };
Java泛型的嵌套设置
class Info< T,V>{ // 接收两个泛型类型 private T var ; private V value ; public Info(T var,V value){ this.setVar(var) ; this.setValue(value) ; } public void setVar(T var){ this.var = var ; } public void setValue(V value){ this.value = value ; } public T getVar(){ return this.var ; } public V getValue(){ return this.value ; } }; class Demo< S>{ private S info ; public Demo(S info){ this.setInfo(info) ; } public void setInfo(S info){ this.info = info ; } public S getInfo(){ return this.info ; } }; public class GenericsDemo31{ public static void main(String args[]){ Demo< Info< String,Integer>> d = null ; // 将Info作为Demo的泛型类型 Info< String,Integer> i = null ; // Info指定两个泛型类型 i = new Info< String,Integer>("汤姆",30) ; // 实例化Info对象 d = new Demo< Info< String,Integer>>(i) ; // 在Demo类中设置Info类的对象 System.out.println("内容一:" + d.getInfo().getVar()) ; System.out.println("内容二:" + d.getInfo().getValue()) ; } };
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型.
1、Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样,方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的,这样写class Java_Generics<K,V>,这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子:
//code list 1
import Java.util.Hashtable;
class TestGen0<K,V>{
public Hashtable<K,V> h=new Hashtable<K,V>();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0<String,String> t=new TestGen0<String,String>();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正确输出:value
这只是个例子(Java中集合框架都泛型化了,这里费了2遍事.),不过看看是不是创建一个用类型作为参数的类,参数是K,V,传入的“值”是String类型。这个类他没有特定的待处理型别,以前我们定义好了一个类,在输入输入参数有所固定,是什么型别的有要求,但是现在编写程序,完全可以不制定参数的类型,具体用的时候来确定,增加了程序的通用性,像是一个模板。
呵呵,类似C++的模板(类似)。
1.1. 泛型通配符
下面我们先看看这些程序:
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看这个方法有没有异议,这个方法会通过编译的,假如你传入String,就是这样List<String>。
接着我们调用它,问题就出现了,我们将一个List<String>当作List传给了方法,JVM会给我们一个警告,说这个破坏了类型安全,因为从List中返回的都是Object类型的,而让我们再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List<String> l) {
for (Object o : l)
System.out.println(o);
}
因为这里的List<String>不是List<Object>的子类,不是String与Object的关系,就是说List<String>不隶属于list<Object>,他们不是继承关系,所以是不行的,这里的extends是表示限制的。
类型通配符是很神奇的,List<?>这个你能为他做什么呢?怎么都是“?”,它似乎不确定,他总不能返回一个?作为类型的数据吧,是啊他是不会返回一个“?”来问程序员的?JVM会做简单的思考的,看看代码吧,更直观些。
//code list 4
List<String> l1 = new ArrayList<String>();
li.add(“String”);
List<?> l2 = l1;
System.out.println(l1.get(0));
这段代码没问题的,l1.get(0)将返回一个Object。
1.2. 编写泛型类要注意:
1) 在定义一个泛型类的时候,在 “<>”之间定义形式类型参数,例如:“class TestGen<K,V>”,其中“K” , “V”不代表值,而是表示类型。
2) 实例化泛型对象的时候,一定要在类名后面指定类型参数的值(类型),一共要有两次书写。例如:
TestGen<String,String> t=new TestGen<String,String>();
3) 泛型中<K extends Object>,extends并不代表继承,它是类型范围限制。
2、泛型与数据类型转换
2.1. 消除类型转换
上面的例子大家看到什么了,数据类型转换的代码不见了。在以前我们经常要书写以下代码,如:
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
这个我们做了类型转换,是不是感觉很烦的,并且强制类型转换会带来潜在的危险,系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做,如:
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable<String,Integer> h = new Hashtable<String,Integer> ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了,类型转换的过程交给编译器来处理,是不是很方便,而且很安全。上面是String映射到String,也可以将Integer映射为String,只要写成HashTable<Integer,String> h=new
HashTable<Integer,String>();h.get(new Integer(0))返回value。果然很方便。
2.2 自动解包装与自动包装的功能
从上面有没有看到有点别扭啊,h.get(new Integer(123))这里的new Integer(123);好烦的,在JDK5.0之前我们只能忍着了,现在这种问题已经解决了,请看下面这个方法。我们传入一个int这一基本型别,然后再将i的值直接添加到List中,其实List是不能储存基本型别的,List中应该存储对象,这里编译器将int包装成Integer,然后添加到List中去。接着我们用List.get(0);来检索数据,并返回对象再将对象解包装成int。恩,JDK5.0给我们带来更多方便与安全。
//Code list 7
public void autoBoxingUnboxing(int i) {
ArrayList<Integer> L= new ArrayList<Integer>();
L.add(i);
int a = L.get(0);
System.out.println("The value of i is " + a);
}
2.3 限制泛型中类型参数的范围
也许你已经发现在code list 1中的TestGen<K,V>这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围,怎么做呢?看看如下的代码:
//Code list 8
class TestGen2<K extents String,V extends Number>
{
private V v=null;
private K k=null;
public void setV(V v){
this.v=v;
}
public V getV(){
return this.v;
}
public void setK(K k){
this.k=k;
}
public V getK(){
return this.k;
}
public static void main(String[] args)
{
TestGen2<String,Integer> t2=new TestGen2<String,Integer>();
t2.setK(new String("String"));
t2.setV(new Integer(123));
System.out.println(t2.getK());
System.out.println(t2.getV());
}
}
上边K的范围是<=String ,V的范围是<=Number,注意是“<=”,对于K可以是String的,V当然也可以是Number,也可以是Integer,Float,Double,Byte等。看看下图也许能直观些请看上图A是上图类中的基类,A1,A2分别是A的子类,A2有2个子类分别是A2_1,A2_2。
然后我们定义一个受限的泛型类class MyGen<E extends A2>,这个泛型的范围就是上图中兰色部分。
这个是单一的限制,你也可以对型别多重限制,如下:
class C<T extends Comparable<? super T> & Serializable>
我们来分析以下这句,T extends Comparable这个是对上限的限制,Comparable< super T>这个是下限的限制,Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
2.4. 多态方法
//Code list 9
class TestGen {
<T extends Object> public static List<T> make(T first) {
return new List<T>(first);
}
}
相关文章推荐
- 全面总结Java泛型
- 全面总结Java泛型
- Java_全面总结Java泛型
- Java 泛型全面总结
- 接口java.io.Serializable的用处 (全面搜集总结)
- java笔记总结_06_集合泛型
- java语法总结07--泛型
- 黑马程序员 java泛型学习总结(二)
- 黑马程序员 java泛型学习总结(一)
- java 泛型 很全面的
- 黑马程序员:Java基础总结----泛型(高级)
- JAVA 泛型全面讲解
- Java基础加强总结(3)(泛型)
- [转]java中泛型创建数组的总结
- java.string.format方法使用总结!!!很全面的!
- java 泛型总结 简单实例
- Java 5.0 新特性总结 三 泛型
- 关于Java的泛型在所声明的对象中如何获取class或者实例的方法的总结
- java中的泛型总结
- 基于java中泛型的总结分析