1.什麼是泛型
泛型是一種安全機制。程序的安全問題，由原來的運行時期，提到了編譯時期。
使用泛型的好處：避免了數據類型的強制轉換
//==================================================
2.如何使用泛型
泛型的格式: 集合類<數據類型>
變量 = new 集合類<數據類型>();
指示這個集合，只能存儲已經定義的數據類型
/*
* 泛型的安全性
*/
import java.util.*;
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("afe");
array.add("btefd");
array.add("qewd");
array.add("befv");
//迭代的過程中，輸出每一個字符串的長度
//存儲的數據類型，不是String，導致出現類型轉換異常，異常發生在運行時期的
Iterator<String>it = array.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s.length());
}
}
}
//==================================================
3.自定義泛型
利用泛型，提高程序的安全性，不可以隨便傳遞參數
/*
* 自定義的泛型
* 寫一個工廠，創建對象
*/
class Student{}
class Worker{}
//爲了解決運行時期的安全性問題，對這個工廠類，進行泛型的定義
// new Factory<Student>
class Factory<T>{
private T t;
public void setQ(T t){
this.t = t;
}
public QQ getQ(){
return t;
}
}
public class GenericDemo1 {
public static void main(String[] args) {
Factory<Student> f = new Factory<Student>();
f.setQ(new Student());
Student s = f.getQ();
System.out.println(s);
}
}
//==================================================
4.泛型的類，泛型的方法
泛型類，在定義類的時候，在類的右邊寫<變量>
泛型方法，是在方法的聲明上寫<變量>
/*
* 泛型類和泛型方法
*/
//xt變量，建立對象的時候，傳遞什麼，變量就變成什麼數據類型
class Generic<xt>{
public void print(xt s){
System.out.println(s);
}
//在方法的定義上寫泛型，此時這個方法，不受類上泛型的約束
public <QQ> void show(QQ q){
System.out.println(q);
}
//靜態方法中，定義泛型，泛型寫在static後面
public static<T> void method(T t){
System.out.println(t);
}
}
public class GenericDemo2 {
public static void main(String[] args) {
Generic<Integer> g = new Generic<Integer>();
g.print(124);
g.show(12.34);
Generic.method(false);
}
}
//==================================================
5.泛型接口
在接口上定義泛型
接口是需要類實現
類實現接口，不指定泛型，由創建實現類的同時指定類型
類實現接口，直接指定泛型
/*
* 泛型接口
*/
interface MyInter<T>{
public abstract void show(T t);
}
//定義實現類，實現的時候，不指定泛型，由創建對象的時候，指定泛型
class MyIntertImpl<T> implements MyInter<T>{
public void show(T t){
System.out.println(t);
}
}
//定義實現類，直接指定泛型
class MuMyIntertImpl2 implements MyInter<Integer>{
public void show(Integer t){
System.out.println(t);
}
}
public class GenericDemo3 {
public static void main(String[] args) {
MyIntertImpl<String> my = new MyIntertImpl<String>();
my.show("abc");
MuMyIntertImpl2 my2 = new MuMyIntertImpl2();
my2.show(123);
}
}
//==================================================
6.泛型的通配符
泛型的通配符<?>表示不清楚泛型是什麼數據類型
如果只簡單的做遍歷迭代是可以的，提高安全性，避免強制轉換不可以了
import java.util.*;
public class GenericDemo4 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("abc1");
array.add("abc2");
array.add("abc3");
method(array);
HashSet<Integer> hs = new HashSet<Integer>();
hs.add(1231);
hs.add(1232);
hs.add(1233);
hs.add(1234);
method(hs);
//迭代器迭起兩個集合
//將迭代器提取成一個方法，當你需要的時候，直接調用方法
}
private static void method(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//==================================================
7.泛型的限定
泛型限定的格式<? XXX Xx>， 泛型限定的使用，必須有繼承和多態
泛型的上限格式：<? extends E> 傳遞E類型，和E的子類類型。泛型的上限（限制的是最高父類）
泛型的下限格式：<? super T>傳遞T類型，和T的父類類型，泛型的下限（限制最低的子類。
泛型接受本類類型，接受父類類型
//==================================================
自定義泛型案例：
public class GenericPerson implements Comparable<GenericPerson>{
private String name;
private int age;
public int compareTo(GenericPerson p){
int num = this.name.compareTo(p.name);
return num == 0 ? this.age - p.age : num ;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public GenericPerson(String name, int age) {
this.name = name;
this.age = age;
}
}
///=====
/*
* HashSet 集合存儲自定義對象Person，加上泛型
*/
import java.util.*;
public class HashSetDemo {
public static void main(String[] args) {
// HashSet<Person> hs = new HashSet<Person>();
TreeSet<GenericPerson> hs = new TreeSet<GenericPerson>(new MyComparator());
hs.add(new GenericPerson("haha",101));
hs.add(new GenericPerson("haha",10));
hs.add(new GenericPerson("xixi",10));
hs.add(new GenericPerson("haha",10));
hs.add(new GenericPerson("hehe",10));
Iterator<GenericPerson> it = hs.iterator();
while(it.hasNext()){
GenericPerson p = it.next();
System.out.println(p.getName() +"..." + p.getAge());
}
}
}
class MyComparator implements Comparator<GenericPerson>{
public int compare(GenericPerson p1, GenericPerson p2){
int num = p1.getAge() - p2.getAge();
return num == 0 ? p1.getName().compareTo(p2.getName()) : num;
}
}