java編程筆記19 java進階特性

1，自動裝箱與拆箱

自動裝箱是指把基礎資料型別 (Elementary Data Type)封裝成類對象，拆箱是指把類對象拆成基礎資料型別 (Elementary Data Type)。

例如下列代碼在java 5.0以後都是可以編譯通過的

//自動裝箱Integer in = 3;Short sh = 2;Long lo = 3L;Double dbl = 3.4D;Float fl = 1.2F;Byte bt = 12;Character cht = 'c';// 自動拆箱int i = new Integer(3);short s = new Short((short)1);long l = new Long(3L);double d = new Double(2.3D);float f = new Float(1.2F);byte b = new Byte((byte)23);char ch = new Character('a');

而在java5.0以前則不行，因為兩邊的資料類型不一樣，一個是基礎資料型別 (Elementary Data Type)一個是對象，必須通過調用wrapper類的方法來實現對象和基礎資料型別 (Elementary Data Type)之間的轉化

關於封裝類在這裡不詳述。

2，新的for/in迴圈，

只需要在for迴圈裡指出遍曆的元素類型，和遍曆的對象即可：

package com.book.ch10.java5;import java.util.ArrayList;import java.util.List;public class JForInArray {public static void main(String[] args) {String[] array = { "a", "b", "c", "d" };for (String s : array) {System.out.println("遍曆數組：" + s);}List<String> list = new ArrayList<String>();list.add("A");list.add("b");list.add("C");list.add("D");for (String obj : list) {System.out.println("遍曆集合：" + obj);}}}

3，可變長參數法

定義一個可變長參數的方法是在參數類型的後面加上省略符號，然後加上可變長參數名。可變長參數在方法內部表現為數組，可以使用傳統的數組遍曆方式來使用數組，也可以使用新的for/in迴圈：

package com.book.ch10.java5;public class JVarargsTest {public static double avg(double... values) {//可變長參數的定義方法double total = 0;int count = values.length;for (double i : values) {//可變長參數的使用total += i;}return total / count;}public static void main(String[] args) {System.out.printf("平均數為 %s. %n", avg(3, 4.2, 2));System.out.printf("平均數為 %s. %n", avg());System.out.printf("平均數為 %s. %n", avg(new double[] { 3, 4.2, 2 }));}}

4，協變式傳回型別

允許在覆蓋父類方法的時候，使父類方法的傳回值更加具體。例如ArrayList類的get(int index)返回的是Object，繼承ArrayList之後可以覆蓋get方法，並修改傳回值為String，因為String也是Object的子類。在java5.0版本以前，這是不允許的。

package com.book.ch10.java5;import java.util.ArrayList;import java.util.List;@SuppressWarnings(value="serial")public class JCovariantReturnTypesTest extends ArrayList {@Override//可以這樣來覆蓋父類中的方法，在5.0以前是不允許在覆蓋的時候傳回值類型跟父類不一樣的public String get(int index) {return (String)super.get(index);}public static void main(String...args){JCovariantReturnTypesTest list = new JCovariantReturnTypesTest();list.add("字串");// 可以直接返回 String 類型 而不是父類中的 ObjectString result = list.get(0);System.out.printf("%s", result);}}

5，靜態匯入

即impot Static指令匯入某個類的靜態方法和靜態變數，在使用的時候就可以直接使用變數名和方法名，而不用再帶上“類名. ”了。

package com.book.ch10.java5;// 靜態匯入變數import static java.lang.Math.PI;// 靜態匯入方法import static java.lang.Math.sin;// 靜態匯入所有的方法跟變數import static java.lang.Math.*;public class JStaticImportTest {public static void main(String[] args){// 直接使用方法和變數，無需 Math 首碼System.out.printf("sin(%s) = %s%n", PI, sin(PI));System.out.printf("cos(%s) = %s%n", PI, cos(PI));}}

6，泛型

在這裡只介紹最基本的文法，後面將詳細介紹

類與方法都可以被泛型化，泛型避免了一些執行階段錯誤，使得許多錯誤在編譯階段就能發現。

類泛型ArrayList<E>代表的意思是ArrayList存放的資料類型是E類型，E代表一個類的類型

方法泛型public E get(int index)代表方法的傳回值是E型的

看一個例子：

package com.book.ch10.java5;import java.util.ArrayList;import java.util.Date;import java.util.List;public class JGenericTest {public static void main(String[] args){// 範型 限制為 Date 類型List<Date> list = new ArrayList<Date>();list.add(new Date());list.add(new Date());list.add(new Date());// 無需 ClassCast. Date date = list.get(0);System.out.printf("%s %n", date);for(Date dd : list){System.out.printf("for/in 迴圈：%1$tF %1$tT%n", dd);}}}

注意，泛型程式設計只能使用類，不能使用基本類型。

集合中使用多個泛型的一個例子：

package com.book.ch10.java5;import java.util.Date;import java.util.HashMap;import java.util.Map;public class JHashMapGeneric {public static void main(String[] args) {Map<String, Date> map = new HashMap<String, Date>();//多個泛型map.put("time_1", new Date());map.put("time_2", new Date());map.put("time_3", new Date());for(String key : map.keySet()){Date date = map.get(key);System.out.printf("Key: %1$s, Value: %2$tF %2$tT%n", key, date);}}}

再來看一下泛型萬用字元：萬用字元只能用來進行型別安全檢查，而不能用來聲明具體的類泛型

<?>代表任何類型，不過單獨使用？基本沒有什麼用（單獨一個？也就是不用泛型的意思），一般與extends和super一起用

<?>與extends一起表示指定類型及其所有子類

<?>與super一起表示指定類型及其所有父類

由於萬用字元只能進行型別安全檢查，不能用來聲明具體的泛型類，故下面的用法是錯誤的

List <?> = new ArrayList<?>   //不能用來做聲明用

看下面用萬用字元做類型檢查的一個例子：

package com.book.ch10.java5;import java.util.ArrayList;import java.util.Date;import java.util.List;public class JWildCard {//萬用字元指定接受的list可以是Number及其子類public static void numberList(List<? extends Number> list){for(Number num : list){System.out.printf("輸出數字：%1$s %n", num);}}//同上public static void dateList(List<? extends Date> list){for(Date date : list){System.out.printf("輸出日期：%1$tF %1$tT%n", date);}}public static void main(String[] args){List<Date> dateList = new ArrayList<Date>();//型別宣告要用具體的泛型List<Integer> intList = new ArrayList<Integer>();dateList.add(new Date());dateList.add(new Date());intList.add(3);intList.add(6);numberList(intList);dateList(dateList);}}

泛型化一個類是在類名後面定義泛型型別，泛型化一個方法需要在方法名的傳回型別前定義泛型型別：下面寫一個自己的泛型：

package com.book.ch10.java5;import java.util.Date;public class JGenericMethod {// 範型化類. 在類名後使用<>定義了範型類型 T.static class A<T> {// 定義之後直接使用 Ｔ 即可public T generic(T t){return t;}}static class B {// 範型化方法. 在方法傳回型別前使用<>定義範型類型 Tpublic <T> T generic(T t){return t;}// 範型化方法. 在方法傳回型別前使用<>定義範型類型 T, 該範型類型只能為 Date 及其子類public <T extends Date> T genericDate(T t){return t;}}public static void main(String[] args){A<String> a = new A<String>();String ss = a.generic("一個字串");B b = new B();String ss2 = b.generic("另一個字串");Date date = b.genericDate(new Date());}}

7，枚舉類型

枚舉類型不能在方法內部聲明，只能聲明為一個類變數，

public enum Sex{MALE,FEMAL,UNKNOW};

枚舉類型裡德變數是實實在在的對象，可以把他們看成是static，final，public的

package com.book.ch10.java5;public class JEnumeration {public static enum Sex { MALE, FEMALE, UNKOWN, };public static void main(String[] args){System.out.printf("Sex.FEMALE.toString(): \t%s %n", Sex.FEMALE.toString());System.out.printf("Sex.FEMALE.ordinal(): \t%s %n", Sex.FEMALE.ordinal());System.out.printf("Sex.FEMALE.getClass(): \t%s %n", Sex.FEMALE.getClass());System.out.printf("%n遍曆所有的 Sex 枚舉變數: ");for(Sex sex : Sex.values()){System.out.printf("%s, ", sex);}switch(Sex.FEMALE){case MALE:// do somethingbreak;case FEMALE:// do somethingbreak;case UNKOWN:// do somethingbreak;default:// do something}}}

下面來看一下擴充枚舉類型，enum和class，interface一樣是一種對象。因此它可以擴充，添加屬性或方法，跟interface不能有建構函式一樣，enum也有一些限制：

enum內部可以有構造方法，但不能有public的構造方法

enum內建對象間必須用逗號隔開，聲明完所有的內建對象後用分號結束

enum內建對象必須使用聲明的建構函式，否則編譯錯誤

看一個例子：

package com.book.ch10.java5;public class JEnumTest {static enum Type {// 內建的枚舉類型對象// 各枚舉類型對象之間用逗號隔開。MANAGER("經理", 10000), ASSISTANT("助理", 6000), WORKER("員工", 4000),;//分號結束// 擴充的屬性private String name;private double pay;// 建構函式 不能為 public Type(String name, double pay){this.name = name;this.pay = pay;}}static class Person {public Person(String name, Type type){//注意person的類型
                this.name = name;this.type = type;}private String name;private Type type;public String getName() {return name;}public void setName(String name) {this.name = name;}public Type getType() {return type;}public void setType(Type type) {this.type = type;}}public static void printInfo(Person person){System.out.printf("姓名：%1$s, \t職業：%2$s, \t崗位薪水：%3$s  %n", person.getName(), person.getType().name, person.getType().pay);}public static void main(String[] args){Person p1 = new Person("張三", Type.MANAGER);Person p2 = new Person("李四", Type.WORKER);Person p3 = new Person("王五", Type.ASSISTANT);printInfo(p1);printInfo(p2);printInfo(p3);}}