jdk1.5出現的安全機制
1.將運行時期的問題ClassCastException轉到了編譯時期。
2.避免了強制轉換的麻煩。
什麼時候用？
當操作的引用數據類型不確定的時候，就使用<>。將要操作的引用數據類型傳入即可。
其實<>就是一個用於接收具體引用數據類型的參數范圍。
在程序中，只要用到了帶有<>的類或者接口，就要明確傳入的具體引用數據類型。
泛型技術是給編譯器使用的技術，用於編譯時期。確保了類型的安全。
運行時，會將泛型去掉，生成的class文件中是不帶泛型的，這個稱為泛型的擦除。
為什麼要擦除呢？ 為了兼容運行的類加載器。
泛型的補償： 在運行時，通過獲取元素的類型進行轉換動作。不用 使用者 在強制轉換了。
？ extends E：接受E類型或E的子類型對象。上限一般存儲對象的時候用。比如，添加元素 addAll boolean addAll(<? extends E> c)
？ super E ：接受E類型或E的父類型對象。下限，一般取出對象的時候用。比如比較器。 TreeSet(Comparator<? super E> comparator)
1 import java.util.ArrayList;
2 import java.util.Iterator;
3
4 public class GenericDemo {
5
6 public static void main(String[] args) {
7 ArrayList<String> al = new ArrayList<String>(); //強制轉化
8
9 al.add("abc");
10 al.add("hahah");
11 // al.add(123); //會報錯
12
13 Iterator<String> it = al.iterator(); //強制轉化
14
15 while (it.hasNext())
16 {
17 String str = it.next(); //不用強制轉化了
18 System.out.println(str);
19 }
20
21 }
22
23 }
Comparator，Comparable的泛型
1 package p2;
2
3 public class Person implements Comparable<Person> {
4 private String name;
5 private int age;
6
7 public Person(){
8 super();
9 }
10
11 public Person(String name, int age)
12 {
13 super();
14 this.name = name;
15 this.age = age;
16 }
17
18 @Override
19 public int compareTo(Person o) {
20 // Person p = (Person)obj; //不用強制轉化了
21 int temp = this.age - o.age;
22
23 return temp==0?this.name.compareTo(o.name):temp;
24 }
25
26 public String getName() {
27 return name;
28 }
29
30 public void setName(String name) {
31 this.name = name;
32 }
33
34 public int getAge() {
35 return age;
36 }
37
38 public void setAge(int age) {
39 this.age = age;
40 }
41
42 /* （非 Javadoc）
43 * @see java.lang.Object#hashCode()
44 */
45 @Override
46 public int hashCode() {
47 final int prime = 31;
48 int result = 1;
49 result = prime * result + age;
50 result = prime * result + ((name == null) ? 0 : name.hashCode());
51 return result;
52 }
53
54 /* （非 Javadoc）
55 * @see java.lang.Object#equals(java.lang.Object)
56 */
57 @Override
58 public boolean equals(Object obj) {
59 if (this == obj)
60 return true;
61 if (obj == null)
62 return false;
63 if (getClass() != obj.getClass())
64 return false;
65 Person other = (Person) obj;
66 if (age != other.age)
67 return false;
68 if (name == null) {
69 if (other.name != null)
70 return false;
71 } else if (!name.equals(other.name))
72 return false;
73 return true;
74 }
75
76 /* （非 Javadoc）
77 * @see java.lang.Object#toString()
78 */
79 @Override
80 public String toString() {
81 return "Person [name=" + name + ", age=" + age + "]";
82 }
83
84
85
86 }
87
88
89 package p3;
90
91 import java.util.Comparator;
92
93 import p2.Person;
94
95 public class ComparatorByName implements Comparator<Person> {
96
97 @Override
98 public int compare(Person o1, Person o2) {
99 int temp = o1.getName().compareTo(o2.getName());
100
101 return temp==0? o1.getAge()-o2.getAge() : temp;
102 }
103
104
105 }
106
107 import java.util.Iterator;
108 import java.util.TreeSet;
109
110 import p2.Person;
111 import p3.ComparatorByName;
112
113 public class GenericDemo2 {
114
115 public static void main(String[] args) {
116 TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());
117
118 ts.add(new Person("sfsf",21));
119 ts.add(new Person("fdg",14));
120 ts.add(new Person("erw",18));
121 ts.add(new Person("iu",30));
122
123 Iterator<Person> it = ts.iterator();
124
125 while(it.hasNext())
126 {
127 Person p = it.next();
128
129 System.out.println(p);
130 }
131
132 }
133
134 }
類和方法上的泛型
1 public class Tool<QQ> {
2 private QQ q;
3
4 public QQ getObject() {
5 return q;
6 }
7
8 public void setObject(QQ object) {
9 this.q = object;
10 }
11
12 /*
13 * 將泛型定義在方法上
14 *
15 * */
16
17 public <W> void show(W str)
18 {
19 System.out.println(str.toString());
20 }
21
22 public void print(QQ str)
23 {
24 System.out.println(str); //如果寫str.length(); 是錯誤的； 因為不知道泛型QQ究竟是什麼具體類型，所以不能使用具體類型的方法。
25 //不過可以使用Object的方法
26 }
27
28 /*
29 * 當方法靜態時，不能訪問類上定義的泛型。
30 * 如果靜態方法使用泛型，只能將泛型定義在方法上。
31 * 泛型一定要放在返回值類型的前面，修飾符的後面
32 *
33 * */
34 public static <Y> void method(Y obj)
35 {
36 System.out.println(obj);
37 }
38
39
40
41 }
