泛型整理

 

1.泛型的使用环境

泛型是在jdk1.5及1.5以上的版本可以使用。

2.泛型的参数命名约定

 

 

  • E – Element，主要由Java Collections框架使用。

  • K – Key，主要用来表示地图的参数类型。

  • V – 值，主要用于表示地图的参数类型值。

  • N – 数字，主要用于表示数字。

  • T – Type，主要用于表示第一个泛型类型参数。

  • S – Type，主要用于表示第二个泛型类型参数。

  • U – Type，主要用来表示第三个泛型类型参数。

  • V – Type，主要用于表示第四个泛型类型参数。

 

 

3.普通泛型实例

 1 public class GenericsDemo {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Student<String,Integer> student = new Student<String,Integer>();
 6         student.setAge(25);
 7         student.setName("大志");
 8         
 9         System.out.println("获取到的数据为     :"+student.getName()+"&&"+student.getAge());
10         fun(student) ;
11         
12     }
13     
14     public static void fun(Student<?,?> newStudent){
15         System.out.println("使用通配符的方式:"+newStudent.getName()+"&&"+newStudent.getAge());
16     }
17 
18 }
19 
20 class Student<T,S>{
21     private T name;
22     private S age;
23     
24     public T getName() {
25         return name;
26     }
27     public void setName(T name) {
28         this.name = name;
29     }
30     public S getAge() {
31         return age;
32     }
33     public void setAge(S age) {
34         this.age = age;
35     }
36     
37 }

 

注：这里有一点需要留意，那就是此处的代码14行中使用到了通配符<?>；

　　通配符可以表示任意的类型；

　　而<T>里面的内容只能替代输入时指定的类型。

4.受限泛型

　　受限泛型包括了两种：受限下界<T extends<S>>和受限上界<T super<S>>，使用这种方式也会使得代码变得更复杂，但对应的是可扩展得逻辑性确大大提高。

　　这里先解释下这两种方式区别：

　　1.<T extends<S>>这种方式表示：在调用使用这种受限泛型的方式时，T可以是S得子类，用集合表示即T是S得子集（可以S==T）；

　　2.<T super<S>>这种方式表示：在调用使用这种受限泛型的方式时，S可以是T得子类，用集合表示即S是T得子集（可以S==T）；

　　

下面用图来描述一下这两种的区别：

1).受限下界<T extends<S>>:                                                        2).受限上界<T super<S>>:

　　这两张图转自：https://www.cnblogs.com/drizzlewithwind/p/6100164.html

　　下面用代码来表示：

　　

 1 public class GenericsDemo {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Point<Integer> p1 = new Point<Integer>();
 6         Point<Float> p2 = new Point<Float>();
 7         p1.setT(10086);
 8         p2.setT(10010F);
 9         fun1(p1);
10         fun1(p2);
11         System.out.println("=======================");
12         Point<Number> p3 = new Point<Number>();
13         Point<Object> p4 = new Point<Object>();
14         p3.setT(5);
15         p4.setT(new Object());
16         fun2(p3);
17         fun2(p4);
18         
19     }
20     
21     public static void fun1(Point<? extends Number> p){// 只能接收Number及其Number的子类 
22         System.out.println("受限泛型下界方式："+p.getT());
23     }
24     
25     public static void fun2(Point<? super Number> p){// 只能接收Number及其Object类型
26         System.out.println("受限泛型上界方式："+p.getT());
27     }
28 
29 }
30 
31 class Point<T>{
32     private T t;
33 
34     public T getT() {
35         return t;
36     }
37 
38     public void setT(T t) {
39         this.t = t;
40     }
41     
42 }

 

 

 

　　以上是我对泛型方式的理解，欢迎大家指出错误和不足之处，谢谢。

 

 

 

版权声明：本文为jiaxiaoyang原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jiaxiaoyang/p/10186395.html