通过代码理解java泛型

时间:2022-09-27 14:18:38

泛型数据java基础,但真正理解需要悉心品尝。毕竟在工作中用到的是在是太多了。

不要以为new arraylist<>这就是泛型,这只能属于会使用。

在工作中,相对于现有的项目源码的数据库操作层,无论是mybatis,hibernate或者是自己封装的basemodel层,都会使用到泛型。

以及<? extends t> 和 <? super t>这个屌东西。

泛型使用情况分为三类

1. 泛型类。

2. 泛型方法。

3. 泛型接口。

出于规范的目的,java 还是建议我们用单个大写字母来代表类型参数。常见的如:

1. t 代表一般的任何类。

2. e 代表 element 的意思,或者 exception 异常的意思。

3. k 代表 key 的意思。

4. v 代表 value 的意思,通常与 k 一起配合使用。

5. s 代表 subtype 的意思,文章后面部分会讲解示意。

最直接的一段代码。

?
1
2
3
list<string> l1 = new arraylist<string>();
  list<integer> l2 = new arraylist<integer>();
  system.out.println(l1.getclass() == l2.getclass());

打印的判断为true,因为泛型信息被擦除了。

泛型擦除实例。

?
1
2
3
4
5
6
7
8
9
list<string> listerasure = new arraylist<string>() {
   // 直接初始化,这也是一种方式。直接传入一个collection。
   {add("aaa");add("bbb");}
  };
  listerasure.add("ccc");
  class<? extends list> class1 = listerasure.getclass();
  method method = class1.getmethod("add",object.class);
  method.invoke(listerasure, 123);
  system.out.println(listerasure)

输出结果  [aaa, bbb, ccc, 123]

明明是接收string类型,但是却可以通过反射对其进行integer类型的操作。

可见泛型只是在编译期间有效。

 

<?> 代表着类型未知

<? extends t> 和 <? super t>这个东西经常见到,但是并没有字面意义那么简单。

通配符有 3 种形式。

  1. <?> 被称作无限定的通配符。
  2. <? extends t> 被称作有上限的通配符。
  3. <? super t> 被称作有下限的通配符。
?
1
2
3
class a{}
class b extends a{}
class c extends b{}
?
1
2
3
4
5
6
7
8
9
10
list<? extends b> listextends = new arraylist<b>();
//  listextends.add(new a()); 全部编译错误。因为使用的是extends,丧失了写的操作能力。跟f3方法一样,是未知类型,只是确定了里面对象的范围。是b的子类。
//  listextends.add(new b());
//  listextends.add(new c());
  
  // 能进行对b以及b的子类操作。这是super的神奇之处。
  list<? super b> listsuper = new arraylist<b>();
//  listsuper.add(new a());//会编译错误。
  listsuper.add(new b());
  listsuper.add(new c());

以及方法泛型的返回

泛型作为参数的传递。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static <ttt>ttt f1(ttt t) {
  return t;
 }
 
 // 传递指定的a类型,对应的list可以进行对应的list应有的方法。
 public static void f2(list<a> list) {
  list.add(new a());
  system.out.println(list.size());
 }
 
 public static void f3(list<?> list) {
//  list.add(new a()); //当传入的是?通配符的话表示只能进行跟?无关的操作,类似于size方法,增加代码的可读性。
  system.out.println(list.size());
 }
 
 public static void f4(list<? extends b> listextends) {
//  listextends.add(new b());//不能进行写做操,因为是?,增加了可读性。
  system.out.println(listextends.size());
 }

测试代码,很全面

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package com.javase.fanxing;
 
import java.lang.reflect.invocationtargetexception;
import java.lang.reflect.method;
import java.util.arraylist;
import java.util.list;
 
class a{}
class b extends a{}
class c extends b{}
public class demo<t,tt> {
 t value;
 tt value2;
 public tt getvalue2() {
  return value2;
 }
 public void setvalue2(tt value2) {
  this.value2 = value2;
 }
 public t getvalue() {
  return value;
 }
 public void setvalue(t value) {
  this.value = value;
 }
 public static <ttt>ttt f1(ttt t) {
  return t;
 }
 // 传递指定的a类型,对应的list可以进行对应的list应有的方法。
 public static void f2(list<a> list) {
  list.add(new a());
  system.out.println(list.size());
 }
 public static void f3(list<?> list) {
//  list.add(new a()); //当传入的是?通配符的话表示只能进行跟?无关的操作,类似于size方法,增加代码的可读性。
  system.out.println(list.size());
 }
 public static void f4(list<? extends b> listextends) {
//  listextends.add(new b());//不能进行写做操,因为是?,增加了可读性。
  system.out.println(listextends.size());
 }
 public static void main(string[] args) throws nosuchmethodexception, securityexception, illegalaccessexception, illegalargumentexception, invocationtargetexception, instantiationexception {
  // 打印的判断为true,因为泛型信息被擦除了。
  list<string> l1 = new arraylist<string>();
  list<integer> l2 = new arraylist<integer>();
  system.out.println(l1.getclass() == l2.getclass());
  // 泛型擦除实例。
  list<string> listerasure = new arraylist<string>() {
   // 直接初始化,这也是一种方式。直接传入一个collection。
   {add("aaa");add("bbb");}
  };
  listerasure.add("ccc");
  class<? extends list> class1 = listerasure.getclass();
  method method = class1.getmethod("add",object.class);
  method.invoke(listerasure, 123);
  system.out.println(listerasure);
  demo<string,integer> demo = new demo<string,integer>();
  demo.setvalue("string");
  system.out.println(demo.getvalue());
  
  
  demo<integer,string> demo2 = new demo<integer,string>();
  demo2.setvalue(100);
  system.out.println(demo2.getvalue());
  
  
  system.out.println(f1(123));
//  list<a> lista = new arraylist<a>();
//  list<b> listb = lista;//new arraylist<b>();虽然b是a的子类,并不代表泛型之间也具备继承关系。
  
  
  arraylist<a> lista = new arraylist<a>();
  lista.add(new a());
  f3(lista); // 不对f3方法进行任何操作,是1.
  f2(lista); // 2对应的方法实现还进行了一次插入操作。
  f3(lista); // static ,对应的lista的集合数量是引用值。
  
  
  arraylist<b> listb = new arraylist<b>();
  listb.add(new b());
  f3(listb); // f3方法传递的是通配符?,不能进行add操作。
  
   
  // <? extends t> 和 <? super t>
  list<? extends b> listextends = new arraylist<b>();
//  listextends.add(new a()); 全部编译错误。因为使用的是extends,丧失了写的操作能力。跟f3方法一样,是未知类型,只是确定了里面对象的范围。是b的子类。
//  listextends.add(new b());
//  listextends.add(new c());
  
  // 能进行对b以及b的子类操作。这是super的神奇之处。
  list<? super b> listsuper = new arraylist<b>();
//  listsuper.add(new a());//会编译错误。
  listsuper.add(new b());
  listsuper.add(new c());
  
  
  // 没毛病。
  list<b> listbs = new arraylist<b>();
  listbs.add(new b());
  f4(listbs);
 }
}

原文链接:https://www.cnblogs.com/c-h-y/p/9465040.html