泛型

1.泛型的引入以及概述
(1).概述:
我們知道集合也是一種儲存資料的工具，之前我們學習過StringBuffer和陣列，這倆種在儲存資料的時候都是明確了要儲存什麼型別的資料，如果
儲存的資料型別和定義要儲存的資料不一致的時候就會報錯。那麼集合為了資料儲存的一致性，也提供了類似的機制，那麼就是在建立集合物件
的時候要明確需要儲存的資料型別是什麼，這一個機制就叫做泛型。

(2).泛型定義:把型別明確的工作推遲到建立物件或者是呼叫方法的時候才去明確的特殊型別。引數化型別，把型別當做引數一樣進行傳遞。

(3).格式:
<資料型別>
注意:資料型別只能夠使引用型別。

(4).泛型的好處
A:把執行時間的錯誤提前到了編譯期間(防止儲存不同的資料型別在一個集合中)
B:避免了強制型別轉化
C:優化了程式，解決了警告。
D:解決了部分安全問題

2.泛型的應用

(1).泛型類
A:什麼是泛型類
所謂的泛型類是指把泛型定義在類上。
B:泛型類格式
public class 類名<泛型型別1.....>

C:注意事項:
泛型型別必須是引用型別

D:泛型類基本使用測試程式碼

//泛型類定義
public class ObjectTool<T> {

private T obj;

public T getObj() {
return obj;
}

public void setObj(T obj) {
this.obj = obj;
}
}

//使用測試
public static void main(String[] args) {
ObjectTool<String> ot = new ObjectTool<String>();

ot.setObj(new String("張三"));
String s = ot.getObj();
System.out.println(s);

System.out.println("------------");

ObjectTool<Integer> ot1 = new ObjectTool<Integer>();
ot1.setObj(new Integer(12));
Integer age = ot1.getObj();
System.out.println(age);
}

//由此可見泛型類的定義可以解決儲存不同引數的問題。便於程式碼的複用，但是會加強程式碼之間的耦合。

(2).泛型方法
A:概述
所謂的泛型方法，就是把方法定義在泛型上。

B:格式
public <泛型型別> 返回型別 方法名(泛型型別...)

C:泛型方法基本使用

//泛型方法定義
public class ObjectTool {

public <T> void show(T t){
System.out.println("內容是:"+t);
}
}
//使用測試
public static void main(String[] args) {
ObjectTool ot = new ObjectTool();
ot.show("你好");
ot.show(12);
ot.show(true);
}

//由此可見泛型方法的好處是可以往引數裡面傳遞不同的引數進去。


(3).泛型介面
A:概述
所謂的泛型介面就是把泛型定義在介面上。

B:格式
public interface 介面名<T>{}

C:程式碼測試

//定義泛型介面
public interface Inter<T> {
public abstract void show(T t);
}

//定義介面實現類
public class InterImpl <T> implements Inter<T>{
@Override
public void show(T t) {
System.out.println("impl show:"+t);
}
}

//定義泛型測試類
public static void main(String[] args) {
Inter<String> it = new InterImpl<String>();
it.show("年後");
Inter<Integer> lt1 = new InterImpl<Integer>();
lt1.show(12);
}

(4).泛型萬用字元
A：泛型萬用字元<?>
表示的是任意的型別，如果沒有明確，那麼就是Object以及其任意的java類
B: ? extends E
向下限定，E以及其子類
C: ? super E
向上限定，E以及其父類

//程式碼測試:
public static void main(String[] args) {
//測試？：表示可以匹配任意型別的資料
Collection<?> ct = new ArrayList<Animal>();
Collection<?> ct1 = new ArrayList<dog>();
Collection<?> ct2 = new ArrayList<cat>();
//測試 ? extends E
Collection<? extends Animal> ct3 = new ArrayList<Animal>();
Collection<? extends Animal> ct4 = new ArrayList<dog>();
Collection<? extends Animal> ct5 = new ArrayList<cat>();
//測試? super E
Collection<? super Animal> ct6 = new ArrayList<Animal>();
Collection<? super Animal> ct7 = new ArrayList<Object>();

}

//動物類
class Animal{}
//狗類
class dog extends Animal{}
//貓類
class cat extends Animal{}

3.JDK5新特性

(1).增強for
A:概述
所謂的增強for,其實就是for迴圈的一種，簡化陣列和Collection集合的遍歷。

B:格式
for(元素資料型別 變數:陣列或者是Collection集合){
使用變數即可，該變數就是元素
}

C:增強for的好處
簡化遍歷

D:增強for使用注意事項
增強for在使用之前需要判斷目標是否為null;
增強for實質就是用來替代迭代器的。

E:增強for程式碼測試
public static void main(String[] args) {
List<String> lt = new ArrayList<String>();
lt.add("hello");
lt.add("world");
lt.add("java");
//普通for迴圈
for(int i = 0; i<lt.size();i++){
System.out.println(lt.get(i));
}

System.out.println("----------");

for(String str:lt){
System.out.println(str);
}
}

(2).靜態匯入
A:靜態匯入概述
所謂的靜態匯入就是可以通過匯入，直接可以匯入到方法級別。

B:格式
import static 包名....類名.方法名。
注意事項：這裡面的匯入直接是匯入到了方法這一個級別

C:靜態匯入的注意事項:
a:該方法必須是靜態的(因為我們在使用的時候直接需要通過方法名來實現該方法的功能)
b:如果有多個同名的靜方法，就很容易不知道使用的是誰的，所以在使用的時候，必須需要新增字首。由此可見意義不大。

D：靜態匯入測試
import static java.lang.Math.abs;
import static java.lang.Math.max;

public class InterDemo {
public static void main(String[] args) {
System.out.println(abs(-10));
System.out.println(max(1,2));
}
}

//注意:匯入的級別是方法級別，同時這一個方法還是靜態的。

(3).可變引數[*****]

A:概述
方法在定義的時候不知道有多少個引數。

B:格式
修飾符 返回值型別 方法名(資料型別... 變數名){}

C:注意事項
a:可變引數中的引數其實是一個數組。
b:如果說一個方法有可變引數，並且有多個引數，那麼可變引數肯定是最後一個。(也就是說可變引數後面不允許還有引數)

D:程式碼測試
public static void main(String[] args) {
int result = sum(12,12,13,14);
System.out.println(result);
}

public static int sum(int... a){
int returnValue = 0;

//可見是一個數組
for(int x:a){
returnValue += x;
}

return returnValue;
}