java基礎--------JDK1.5新特性之泛型、自動拆裝箱、增強for、靜態導入、可變參數

第一部分 泛型

泛型是指將一種類型明確的工作推遲到創建對象或者調用方法的時候纔去明確的特殊的類型。是JDK1.5之後的新特性。下面是個簡單的泛型應用

一、泛型類

<span style="font-size:14px;">class ObjectTool<T>{
//這裏只用寫一個方法，創建對象的時候，只要能夠對象明確類型，就能夠將相應的類型參數，傳遞到該方法，並使用。
	public void show(T t){
	<span style="white-space:pre">	</span>System.out.println("我想學java");
	}
}
class GenericDem{
	public static void main(String[] args) {
//明確對象爲String類型
		ObjectTool<String> s=new ObjectTool<String>();
		s.show("itheima");
//明確對象爲Integer類型
		ObjectTool<Integer> s1=new ObjectTool<Integer>();
		s1.show(520);//自動裝箱
//明確對象爲Boolean類型。
		ObjectTool<Boolean> s2=new ObjectTool<Boolean>();
		s2.show(true);
	}
		
}</span>

通過上面這個例子，我們可以發現泛型的好處，極大地優化了我們的程序，本來需要創建三個方法通過重載來完成，此時通過泛型只要一個方法就可以輕易解決，並且還可以擴展到多個類型都可以條用。就像java的宣傳一樣“一次編譯，到處運行”。泛型似乎也有類似的效果。

泛型的好處：能夠將運行時期出現的錯誤，提早到編譯時期出現。
能夠避免使用顯示的強制類型轉換。

二、泛型方法

class ObjectTool{
	public<T> void show(T t){
		System.out.println("我要去黑馬學安卓"+t);
	}
}


class GenericDemo{
	public static void main(String [] args){
		ObjectTool ob=new ObjectTool();
		ob .show("itheima.com");
		ob.show(100);//自動裝箱
		ob.show(true);
	}
}

泛型方法在被調用的時候，在參數列表中無論傳什麼類型都可以調用。用於放置泛型的類型參數的尖括號應出現在方法的其它所有修飾符之後和在方法的返回類型之前，也就是緊鄰返回之前。

泛型中的術語介紹：ArrayList<E>成爲泛型類型，其中的E成爲類型變量。ArrayList<Integer>稱爲參數化類型，其中的Integer稱爲實際類型參數。

泛型通常是在集合中使用，泛型也可以被理解爲類類型的參數傳遞。


三、泛型接口
將泛型定義在接口上
1、已知實現類在實現時的類型

interface Inter<T>{//將泛型定義在接口上
	//建立一個抽象方法
	public abstract show(T t);
}
//已知接口的實現類爲String類型。
class InterImpl implements Inter<String>{
	public void show(String t){
		System.out.println("it黑馬"+t);
	}
}


class InterDemo{//測試類
	public static void main(String [] args){
//建立對象時，將接口加上泛型實際參數String。
		Inter<String) i=new InterImpl();
		i.show("hello");	
	}
}

2、未知實現類在實現接口時的類型。

interface Inter<T>{//
	public abstract show(T t);
}


class InterImpl implements Inter<T>{//未知實現類的泛型實參
	public void show(T t){
		System.out.println(t);
	}
}


public class InterDemo{
	//當實現類爲String類型的實參時
	Inter<String> i=new InterImpl<String>();
	i.show("hello");
	//當實現類爲Integer類型的實參時
	Inter<Integer> ii=new InterImpl<Integer>();
	ii.show(100);
}

四：泛型通配符

<?>:任意類型，如果沒有明確，那麼久是Object以及任意的java類
?extends E  向下限定，E及其子類
?super E 向上限定，E及其父類。

public class GenericDemo{
	public static void main(String [] args){
	//泛型如果類型明確，前後必須一致。?表示任意類型都可以 
		Collection<?> c=new ArrayList<Object>();
		Collection<?> c1=new ArrayList<Animal>();
		Collection<?> c2=new ArrayList<Cat>();
		Collection<?> c3=new ArrayList<Dog>();


	//? extends E 向下限定E及其子類。
	<span style="white-space:pre">	</span>Collection<? extends Animal> c4=new ArrayList<Object>();//本條語句將會報錯
	<span style="white-space:pre">	</span>Collection<? extends Animal> c5=new ArrayList<Animal>();
	<span style="white-space:pre">	</span>Collection<? extends Animal> c6=new ArrayList<Cat>();
	<span style="white-space:pre">	</span>Collection<? extends Animal> c7=new ArrayList<Dog>();


	//? super E 向上限定，E及其父類。
		Collection<? super Animal> c8=new ArrayList<Object>();
		Collection<? super Animal> c9=new ArrayList<Animal>();
		Collection<? super Animal> c10=new ArrayList<Cat>();//本條語句將會報錯
		Collection<? super Animal> c11=new ArrayList<Dog>();//本條語句將會報錯
		
	}
}
class Animal{}


class Dog extends Animal{}


class Cat extends Animal{}

第二部分 JDK1.5其他新特性


自動拆裝箱
自動裝箱：把基本類型轉換爲包裝類類型
自動拆箱：把包裝類類型轉換爲基本類型

public class IntegerDemo {
	public static void main(String[] args) {
		// 定義了一個int類型的包裝類類型變量i
		// Integer i = new Integer(100);
		Integer ii = 100;
		ii += 200;
		System.out.println("ii:" + ii);


		// 通過反編譯後的代碼
		// Integer ii = Integer.valueOf(100); //自動裝箱
		// ii = Integer.valueOf(ii.intValue() + 200); //自動拆箱，再自動裝箱
		// System.out.println((new StringBuilder("ii:")).append(ii).toString());


		Integer iii = null;
		// NullPointerException
		if (iii != null) {
			iii += 1000;
			System.out.println(iii);
		}
	}
}

增強for
for(元素數據類型 變量：數組或者Collection集合）{使用變量即可，該變量就是元素}
增強for的弊端是如果對象爲空，for循環在編譯時期不能報錯。
增強for是用來替代迭代器的，因此應該注意併發修改異常。

class StrengthFor{
	public static void main(String [] args){
		int [] arr ={1,2,3,4,5}
		for(int x:arr){
			System.out.println(x);
		}
		ArrayList<String> array=new ArrayList<String>();
		array.add("我");
		array.add("愛");
		array.add("黑");
		array.add("馬");
		for（String s: array){
			System.out.println(s);
		}
		//此處應該注意空指針異常
		List<String> list=null;
		if(list!=null){
			for(String s:array){
				System.out.println(s);
			}
		}
		
	}
}

靜態導入
靜態導入格式：
import static 包名...類名.方法名；
注意：方法必須是靜態的
如果有多個同名的靜態方法，容易不知道使用誰？這個時候要使用前綴。

//靜態導入到方法名
import static java.lang.Math.abs;
class StaticDemo{
	public static void main(String [] args){
		System.out.println(abs(-10));
	}
}

可變參數
格式：修飾符 返回值類型 方法名(數據類型...變量名）{}
注意：這裏的變量其實是一個數組，如果一個方法有可變參數，並且有多個參數，那麼可變參數肯定是最後一個。

class ArgsDemo{
	public static void main(String [] args){
		int a =10;
		int b=20;
		int c=20;
		int d=30;
		System.out.println(sum(a,b));
		System.out.println(sum(a,b,c));
		System.out.println(sum(a,b,c,d));
			
	}
		
	public static int sum(int...a){//這裏的變量a其實是個數組。
		int s=0;
		for(int x:a){
			s+=x;
		}
		return s;	
	}
}

枚舉（後面博客補入）