java泛型介绍

普通泛型代码  

1. class Point<T>{//此处可以随便写标识符号，T是type的简称  
2.     private T var;//var的类型由T指定，即：由外部指定  
3.     public T getVar(){//返回值的类型由外部决定  
4.         return var;  
5.     }  
6.     public void setVar(T var){//设置的类型也由外部决定  
7.         this.var = var;  
8.     }  
9. };  
10. public class GenericsDemo06{  
11.     public static void main(String args[]){  
12.         Point<String> p = new Point<String>();//里面的var类型为String类型  
13.         p.setVar("it");//设置字符串  
14.         System.out.println(p.getVar().length());//取得字符串的长度  
15.     }  
16. };  
17. ----------------------------------------------------------  
18. class Notepad<K,V>{// 此处指定了两个泛型类型  
19.     private K key;// 此变量的类型由外部决定  
20.     private V value;//此变量的类型由外部决定  
21.     public K getKey(){  
22.         return this.key ;  
23.     }  
24.     public V getValue(){  
25.         return this.value ;  
26.     }  
27.     public void setKey(K key){  
28.         this.key = key ;  
29.     }  
30.     public void setValue(V value){  
31.         this.value = value ;  
32.     }  
33. };  
34. public class GenericsDemo09{  
35.     public static void main(String args[]){  
36.         Notepad<String,Integer> t = null;//定义两个泛型类型的对象  
37.         t = new Notepad<String,Integer>();//里面的key为String，value为Integer  
38.         t.setKey("汤姆";  // 设置第一个内容  
39.         t.setValue(20);// 设置第二个内容  
40.         System.out.print("姓名；" + t.getKey());// 取得信息  
41.         System.out.print("，年龄；" + t.getValue());// 取得信息  
42.     }  
43. };  

 

通配符泛型代码  

1. class Info<T> {  
2.     private T var;//定义泛型变量  
3.   
4.     public void setVar(T var) {  
5.         this.var = var;  
6.     }  
7.   
8.     public T getVar() {  
9.         return this.var;  
10.     }  
11.   
12.     public String toString() {//直接打印  
13.         return this.var.toString();  
14.     }  
15. };  
16.   
17. public class GenericsDemo14 {  
18.     public static void main(String args[]) {  
19.         Info<String> i = new Info<String>();//使用String为泛型类型  
20.         i.setVar("it");//设置内容  
21.         fun(i);  
22.     }  
23.   
24.     public static void fun(Info<?> temp) {//可以接收任意的泛型对象  
25.         System.out.println("内容：" + temp);  
26.     }  
27. };  

  

受限泛型代码  

1. class Info<T>{  
2.     private T var;//定义泛型变量  
3.     public void setVar(T var){  
4.         this.var = var ;  
5.     }  
6.     public T getVar(){  
7.         return this.var ;  
8.     }  
9.     public String toString(){//直接打印  
10.         return this.var.toString() ;  
11.     }  
12. };  
13. public class GenericsDemo17{  
14.     public static void main(String args[]){  
15.         Info<Integer> i1 = new Info<Integer>();//声明Integer的泛型对象  
16.         Info<Float> i2 = new Info<Float>();//声明Float的泛型对象  
17.         i1.setVar(30);// 设置整数，自动装箱  
18.         i2.setVar(30.1f);//设置小数，自动装箱  
19.         fun(i1) ;  
20.         fun(i2) ;  
21.     }  
22. //只能接收Number及其Number的子类  
23.     public static void fun(Info<? extends Number> temp){    
24. System.out.print(temp);  
25.     }  
26. };  
27. ----------------------------------------------------------  
28. class Info<T>{  
29.     private T var ; // 定义泛型变量  
30.     public void setVar(T var){  
31.         this.var = var ;  
32.     }  
33.     public T getVar(){  
34.         return this.var ;  
35.     }  
36.     public String toString(){//直接打印  
37.         return this.var.toString() ;  
38.     }  
39. };  
40. public class GenericsDemo21{  
41.     public static void main(String args[]){  
42.         Info<String> i1 = new Info<String>();// 声明String的泛型对象  
43.         Info<Object> i2 = new Info<Object>();// 声明Object的泛型对象  
44.         i1.setVar("hello") ;  
45.         i2.setVar(new Object()) ;  
46.         fun(i1) ;  
47.         fun(i2) ;  
48.     }  
49.     //只能接收String或Object类型的泛型  
50.     public static void fun(Info<? super String> temp){  
51.         System.out.print(temp) ;  
52.     }  
53. };  

 

 

泛型无法向上转型代码  

1. class Info<T> {  
2.     private T var;//定义泛型变量  
3.   
4.     public void setVar(T var) {  
5.         this.var = var;  
6.     }  
7.   
8.     public T getVar() {  
9.         return this.var;  
10.     }  
11.   
12.     public String toString() {//直接打印  
13.         return this.var.toString();  
14.     }  
15. };  
16.   
17. public class GenericsDemo23 {  
18.     public static void main(String args[]) {  
19.         Info<String> i1 = new Info<String>();//泛型类型为String  
20.         Info<Object> i2 = null;  
21.         i2 = i1;//这句会出错 incompatible types  
22.     }  
23. };  

 

 

接口泛型代码  

1. interface Info<T>{//在接口上定义泛型  
2.     public T getVar();//定义抽象方法，抽象方法的返回值就是泛型类型  
3. }  
4. class InfoImpl<T> implements Info<T>{//定义泛型接口的子类  
5.     private T var;//定义属性  
6.     public InfoImpl(T var){//通过构造方法设置属性内容  
7.         this.setVar(var) ;    
8.     }  
9.     public void setVar(T var){  
10.         this.var = var ;  
11.     }  
12.     public T getVar(){  
13.         return this.var ;  
14.     }  
15. };  
16. public class GenericsDemo24{  
17.     public static void main(String arsg[]){  
18.         Info<String> i = null;// 声明接口对象  
19.         i = new InfoImpl<String>("汤姆");//通过子类实例化对象  
20.         System.out.println("内容："+ i.getVar()) ;  
21.     }  
22. };  
23. ----------------------------------------------------------  
24. interface Info<T>{//在接口上定义泛型  
25.     public T getVar();//定义抽象方法，抽象方法的返回值就是泛型类型  
26. }  
27. class InfoImpl implements Info<String>{//定义泛型接口的子类  
28.     private String var;//定义属性  
29.     public InfoImpl(String var){//通过构造方法设置属性内容  
30.         this.setVar(var) ;    
31.     }  
32.     public void setVar(String var){  
33.         this.var = var ;  
34.     }  
35.     public String getVar(){  
36.         return this.var ;  
37.     }  
38. };  
39. public class GenericsDemo25{  
40.     public static void main(String arsg[]){  
41.         Info i = null; //声明接口对象  
42.         i = new InfoImpl("汤姆");//通过子类实例化对象  
43.         System.out.println("内容："+ i.getVar()) ;  
44.     }  
45. };  

 

 

泛型方法代码  

1. class Demo {  
2.     public <T> T fun(T t) {//可以接收任意类型的数据  
3.         return t;//直接把参数返回  
4.     }  
5. };  
6.   
7. public class GenericsDemo26 {  
8.     public static void main(String args[]) {  
9.         Demo d = new Demo();//实例化Demo对象  
10.         String str = d.fun("汤姆");//传递字符串  
11.         int i = d.fun(30);//传递数字，自动装箱  
12.         System.out.println(str);//输出内容  
13.         System.out.println(i);//输出内容  
14.     }  
15. };  

 

 

通过泛型方法返回泛型实例代码  

1. class Info<T extends Number> {//指定上限，只能是数字类型  
2.     private T var;//此类型由外部决定  
3.   
4.     public T getVar() {  
5.         return this.var;  
6.     }  
7.   
8.     public void setVar(T var) {  
9.         this.var = var;  
10.     }  
11.   
12.     public String toString() {//覆写Object类中的toString()方法  
13.         return this.var.toString();  
14.     }  
15. };  
16.   
17. public class GenericsDemo27 {  
18.     public static void main(String args[]) {  
19.         Info<Integer> i = fun(30);  
20.         System.out.println(i.getVar());  
21.     }  
22.     //方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定  
23.     public static <T extends Number> Info<T> fun(T param) {       
24. Info<T> temp = new Info<T>();//根据传入的数据类型实例化Info  
25.         temp.setVar(param);//将传递的内容设置到Info对象的var属性之中  
26.         return temp;//返回实例化对象  
27.     }  
28. };  

 

 

通过泛型统一传入参数类型代码  

1. class Info<T> {//指定上限，只能是数字类型  
2.     private T var;//此类型由外部决定  
3.   
4.     public T getVar() {  
5.         return this.var;  
6.     }  
7.   
8.     public void setVar(T var) {  
9.         this.var = var;  
10.     }  
11.   
12.     public String toString() {//覆写Object类中的toString()方法  
13.         return this.var.toString();  
14.     }  
15. };  
16.   
17. public class GenericsDemo28 {  
18.     public static void main(String args[]) {  
19.         Info<String> i1 = new Info<String>();  
20.         Info<String> i2 = new Info<String>();  
21.         i1.setVar("HELLO");//设置内容  
22.         i2.setVar("汤姆");//设置内容  
23.         add(i1, i2);  
24.     }  
25.   
26.     public static <T> void add(Info<T> i1, Info<T> i2) {  
27.         System.out.println(i1.getVar() + " " + i2.getVar());  
28.     }  
29. };  

 

 

泛型数组代码  

1. public class GenericsDemo30 {  
2.     public static void main(String args[]) {  
3.         Integer i[] = fun1(1, 2, 3, 4, 5, 6);//返回泛型数组  
4.         fun2(i);  
5.     }  
6.   
7.     public static <T> T[] fun1(T... arg) {//接收可变参数  
8.         return arg;//返回泛型数组  
9.     }  
10.   
11.     public static <T> void fun2(T param[]) {//输出  
12.         System.out.print("接收泛型数组：");  
13.         for (T t : param) {  
14.             System.out.print(t + "、");  
15.         }  
16.     }  
17. };  

 

 

泛型嵌套代码  

1. class Info<T, V> {//接收两个泛型类型  
2.     private T var;  
3.     private V value;  
4.   
5.     public Info(T var, V value) {  
6.         this.setVar(var);  
7.         this.setValue(value);  
8.     }  
9.   
10.     public void setVar(T var) {  
11.         this.var = var;  
12.     }  
13.   
14.     public void setValue(V value) {  
15.         this.value = value;  
16.     }  
17.   
18.     public T getVar() {  
19.         return this.var;  
20.     }  
21.   
22.     public V getValue() {  
23.         return this.value;  
24.     }  
25. };  
26.   
27. class Demo<S> {  
28.     private S info;  
29.   
30.     public Demo(S info) {  
31.         this.setInfo(info);  
32.     }  
33.   
34.     public void setInfo(S info) {  
35.         this.info = info;  
36.     }  
37.   
38.     public S getInfo() {  
39.         return this.info;  
40.     }  
41. };  
42.   
43. public class GenericsDemo31 {  
44.     public static void main(String args[]) {  
45.         Demo<Info<String, Integer>> d = null;//将Info作为Demo的泛型类型  
46.         Info<String, Integer> i = null;//Info指定两个泛型类型  
47.         i = new Info<String, Integer>("汤姆", 30);//实例化Info对象  
48.         d = new Demo<Info<String, Integer>>(i);//在Demo类中设置Info类的对象  
49.         System.out.println("内容一：" + d.getInfo().getVar());  
50.         System.out.println("内容二：" + d.getInfo().getValue());  
51.     }  
52. };