CoreJava第十七天         2007-5-21
                        
一、Java5.0新特性                        
1、編譯器的功能更加強(qiáng)大，JVM變化不大
2、Java在逐漸與C++融合
3、五小點(diǎn)，四大點(diǎn)

二、五小點(diǎn)
1、自動(dòng)封箱AutoBoxing/自動(dòng)解封
   自動(dòng)封箱和自動(dòng)拆箱，它實(shí)現(xiàn)了簡(jiǎn)單類型和封裝類型的相互轉(zhuǎn)化時(shí)，實(shí)現(xiàn)了自動(dòng)轉(zhuǎn)化。  
    byte b     -128~127
    Byte b     在以上數(shù)量的基礎(chǔ)上多一個(gè)null

   簡(jiǎn)單類型和封裝類型之間的差別
   封裝類可以等于null  ，避免數(shù)字得0時(shí)的二義性。
   Integer i=null；
   int ii=i；  //會(huì)拋出NullException 異常。相當(dāng)于 int ii=i.intValue();
   Integer i=1； //相當(dāng)于Integer i=new Integer(1);
   i++;    // i = new Integer(i.intValue()+1);

   在基本數(shù)據(jù)類型和封裝類之間的自動(dòng)轉(zhuǎn)換
   5.0之前
   Integer i=new Integer（4）；
   int  ii= i.intValue();

   5.0之后
   Integer i=4；
   Long l=4.3;
   
   public void m(int i){......}
   public void m(Integer i){......}
   以上兩個(gè)函數(shù)也叫方法重載
   自動(dòng)封箱解箱只在必要的時(shí)候才進(jìn)行。能不封箱找到匹配的就不封箱。
   
2、靜態(tài)引入 StaticImport
   使用類中靜態(tài)方法時(shí)不用寫類名
   
   System.out.println(Math.round(PI));
   可以用以下代碼實(shí)現(xiàn)：
   import static java.lang.System.*;  //注意，要寫" 類名.* "
   import static java.lang.Math.*;
   out.println(round(PI));
   
   注意：靜態(tài)引入的方法不能重名
   
3、for-each
   統(tǒng)一了遍歷數(shù)組和遍歷集合的方式   
   for(Object o:list){     //Object o 表示每個(gè)元素的類型 ，list 表示要遍歷的數(shù)組或集合的名字
       System.out.println(o);  //打印集合或數(shù)組中的每個(gè)元素
   }
   
4、可變長(zhǎng)參數(shù)
   處理方法重載中，參數(shù)類型相同，個(gè)數(shù)不同的情況      
   public void m(int... is){.....}
   
   int... is 相當(dāng)于一個(gè) int[] is
   編譯器會(huì)把給定的參數(shù)封裝到一個(gè)數(shù)組中，再傳給方法
   在一個(gè)方法中只能有一個(gè)可變長(zhǎng)參數(shù)，而且，必須放在最后一個(gè)參數(shù)的位置
   
5、格式化輸入/輸出
   java.util.Formatter類 對(duì)格式的描述
   System.out.printf("Hello %s",str);  //打印字符串類型的變量，用一個(gè)占位符   
   
   格式化I/O(Formatted I/O)
   java.util.Sacner類可以進(jìn)行格式化的輸入，可以使用控制臺(tái)輸入，結(jié)合了BufferedReader和StringTokener的功能。
   
三、四大點(diǎn)   
1、枚舉
  枚舉是一個(gè)類，并且這個(gè)類的對(duì)象是現(xiàn)成的，在定義類的時(shí)候，即定義好了對(duì)象
  程序員要使用的時(shí)候，只能從中選擇，無(wú)權(quán)創(chuàng)建
  enum 枚舉名{ 
	枚舉值1(..)，枚舉值2(..)，.....;
  }
  
（1） 在5.0之前使用模式做出一個(gè)面向?qū)ο蟮拿杜e
    final class Season{
	public static final Season SPRING=new Season();
	public static final Season WINTER=new Season();
	public static final Season SUMMER=new Season();
        public static final Season AUTUMN=new Season();
        private Season(){}
    } 
    完全等價(jià)于
    enum Season2{
	SPRING(..),//枚舉值
	SUMMER(..),
	AUTUMN(..),
	WINTER(..)
    }      
  
    枚舉本質(zhì)上也是一個(gè)類，Enum是枚舉的父類。
    這個(gè)類編譯以后生成一個(gè).class類
    這個(gè)類有構(gòu)造方法，但是是私有的
  
    枚舉中的values()方法會(huì)返回枚舉中的所有枚舉值
    枚舉中可以定義方法和屬性，最后的一個(gè)枚舉值要以分號(hào)和類定義分開(kāi)，枚舉中可以定義的構(gòu)造方法。
    枚舉不能繼承類（本身有父類），但可以實(shí)現(xiàn)接口，枚舉不能有子類也就是final的，枚舉的構(gòu)造方法是private（私有的）。
    枚舉中可以定義抽象方法，可以在枚舉值的值中實(shí)現(xiàn)抽象方法。
    枚舉值就是枚舉的對(duì)象，枚舉默認(rèn)是final，枚舉值可以隱含的匿名內(nèi)部類來(lái)實(shí)現(xiàn)枚舉中定義抽象方法。
  
（2）枚舉類(Enumeration Classes)和類一樣，具有類所有特性。Season2的父類是java.lang.Enum;
    隱含方法： 每個(gè)枚舉類型都有的方法。
    Season2[] ss=Season2.values();     ----獲得所有的枚舉值  
    for(Season2 s:ss){
      System.out.println(s.name());   ----- 打印枚舉值
      System.out.println(s.ordinal()); ----- 打印枚舉值的編號(hào)
    }
  
  
（3）  enum可以switch中使用（不加類名）。 
  switch( s ){
	case SPRING:
			…………….
	case SUMMER:
			…………….
	…………..
  }


（4）枚舉的有參構(gòu)造
  enum Season2{
	SPRING(“春”),-------------------------------逗號(hào)
	SUMMER(“夏”),-------------------------------逗號(hào)
	AUTUMN(“秋”),-------------------------------逗號(hào)
	WINTER(“冬”);-------------------------------分號(hào)
	private String name;
	Season2(String name){    //構(gòu)造方法必須是私有的,可以不寫private,默認(rèn)就是私有的
		this.name=name;
        }
        String getName(){
	        return name;
        }

  }
  Season2.SPRING.getName()         ---------------------春
  

（5）枚舉中定義的抽象方法，由枚舉值實(shí)現(xiàn)：
  enum Operation{
	ADD('+'){
		public double calculate(double s1,double s2){
			return s1+s2;
		}
	},
	SUBSTRACT('-'){
		public double calculate(double s1,double s2){
			return s1-s2;
		}
	},
	MULTIPLY('*'){
		public double calculate(double s1,double s2){
			return s1*s2;
		}
	}，
	DIVIDE('/'){
		public double calculate(double s1,double s2){
			return s1/s2;
		}
	}；
	char name;
	public char getName(){
		return this.name;
	}
	Operation(char name){
		this.name=name;
	}
	public abstract double calculate(double s1 ,double s2);
  }
  有抽象方法枚舉元素必須實(shí)現(xiàn)該方法。
  
  Operator[] os = Operator.values();
  for(Operator o:os){
     System.out.println("8 "+o.name()+" 2="+o.calculate(8,2));
  }
  for(Operator o:os){
     System.out.println("8 "+o.getName()+" 2="+o.calculate(8,2));
  }  
  
  運(yùn)行結(jié)果：
  8 ADD 2=10.0
  8 SUBSTRACT 2=6.0
  8 MULTIPLY 2=16.0
  8 DIVIDE 2=4.0
  8 + 2=10.0
  8 - 2=6.0
  8 * 2=16.0
  8 / 2=4.0
  
  
2、泛型  
(1)增強(qiáng)了java的類型安全，可以在編譯期間對(duì)容器內(nèi)的對(duì)象進(jìn)行類型檢查，在運(yùn)行期不必進(jìn)行類型的轉(zhuǎn)換。
   而在java se5.0之前必須在運(yùn)行期動(dòng)態(tài)進(jìn)行容器內(nèi)對(duì)象的檢查及轉(zhuǎn)換，泛型是編譯時(shí)概念，運(yùn)行時(shí)沒(méi)有泛型

   減少含糊的容器，可以定義什么類型的數(shù)據(jù)放入容器
   
(2)List<Integer> aList = new ArrayList<Integer>();
   aList.add(new Integer(1));
   // ...
   Integer myInteger = aList.get(0);  //從集合中得到的元素不必強(qiáng)制類型轉(zhuǎn)換
   支持泛型的集合，只能存放制定的類型，或者是指定類型的子類型。   

   HashMap<String,Float> hm = new HashMap<String,Float>();
   
   不能使用原始類型
   GenList<int> nList = new GenList<int>(); //編譯錯(cuò)誤
   
   編譯類型的泛型和運(yùn)行時(shí)類型的泛型一定要一致。沒(méi)有多態(tài)。
   List<Dog> as = new ArrayList<Dog>(); 
   List<Animal> l = as;  //error  Animal與Dog的父子關(guān)系不能推導(dǎo)出List<Animal> 與 List<Dog> 之間的父子類關(guān)系
   
（3）泛型的通配符"?"   
   ?   是可以用任意類型替代。
   <?> 泛型通配符表示任意類型
   <? extends 類型>  表示這個(gè)類型是某個(gè)類型或接口的子類型。
   <? super 類型>    表示這個(gè)類型是某個(gè)類型的父類型。

  import java.util.*;
  import static java.lang.System.*;
  public class TestTemplate {
	public static void main(String[] args) {
		List<Object> l1=new ArrayList<Object>();
		List<String> l2=new ArrayList<String>();
		List<Number> l3=new ArrayList<Number>();  //Number --- Object的子類，所有封裝類的父類
		List<Integer> l4=new ArrayList<Integer>();
		List<Double> l5=new ArrayList<Double>();
		
		print(l1);
		print(l2);
		print(l3);
		print(l4);
		print(l5);
	}
       static void print(List<? extends Number> l){    //所有Number及其子類 l3,l4,l5通過(guò)
		for(Number o:l){
			out.println(o);
		}
	}
       static void print(List<? extends Comparable> l){……}    //任何一個(gè)實(shí)現(xiàn)Comparable接口的類 l2,l4,l5通過(guò)
       static void print(List<? super Number> l){……}          //所有Number及其父類 l1,l3通過(guò)
      // "?"可以用來(lái)代替任何類型, 例如使用通配符來(lái)實(shí)現(xiàn)print方法。
       public static void print(GenList<?> list){……} //表示任何一種泛型

  }

（4）泛型方法的定義 --- 相當(dāng)于方法的模版
  把數(shù)組拷貝到集合時(shí)，數(shù)組的類型一定要和集合的泛型相同。
  <...>定義泛型，其中的"..."一般用大寫字母來(lái)代替，也就是泛型的命名，其實(shí)，在運(yùn)行時(shí)會(huì)根據(jù)實(shí)際類型替換掉那個(gè)泛型。
  在方法的修飾符和返回值之間定義泛型
  <E> void copyArrayToList(E[] os,List<E> lst){……}
  static <E extends Number & Comparable> void copyArrayToList(E[] os,List<E> lst){……}   //定義泛型的范圍 類在前接口在后
  static<E , V extends E> void copyArrayToList(E[] os,List<E> lst){……} //定義多個(gè)泛型
  "super"只能用在泛型的通配符上，不能用在泛型的定義上
  
  import java.util.*;
  public class TestGenerics3 {
	public static void main(String[] args) {
		List<String> l1=new ArrayList<String>();
		List<Number> l2=new ArrayList<Number>();
		List<Integer> l3=new ArrayList<Integer>();
		List<Double> l4=new ArrayList<Double>();
		List<Object> l5=new ArrayList<Object>();
		String[] s1=new String[10];
		Number[] s2=new Number[10];
		Integer[] s3=new Integer[10];
		Double[] s4=new Double[10];
		Object[] s5=new Object[10];
		copyFromArray(l1,s1);
		copyFromArray(l2,s2);
		copyFromArray(l3,s3);
		copyFromArray(l4,s4);
		copyFromArray(l5,s5);
		
	}
	//把數(shù)組的數(shù)據(jù)導(dǎo)入到集合中
	public static <T extends Number&Comparable> void copyFromArray(List<T> l,T[] os){
		for(T o:os){
			l.add(o);
		}
	}
  }
  
  受限泛型是指類型參數(shù)的取值范圍是受到限制的. extends關(guān)鍵字不僅僅可以用來(lái)聲明類的繼承關(guān)系, 也可以用來(lái)聲明類型參數(shù)(type parameter)的受限關(guān)系.
  泛型定義的時(shí)候，只能使用extends不能使用 super，只能向下，不能向上。
  調(diào)用時(shí)用<?>定義時(shí)用 <E>
  
（5）泛型類的定義
  類的靜態(tài)方法不能使用泛型，因?yàn)榉盒皖愂窃趧?chuàng)建對(duì)象的時(shí)候產(chǎn)生的。
  class MyClass<E>{
	public void show(E a){
		System.out.println(a);
	}
	public E get(){
		return null;
	}
	
  }

  受限泛型
  class MyClass <E extends Number>{
	public void show(E a){

	}
  }  
  
3、注釋
4、并發(fā)


四、反射 reflect
  反射，在運(yùn)行時(shí)，動(dòng)態(tài)分析或使用一個(gè)類進(jìn)行工作。
  反射是一套API，是一種對(duì)底層的對(duì)象操作技術(shù)
1、類加載
  類加載，生成.class文件，保存類的信息  
  類對(duì)象，是一個(gè)描述這個(gè)類信息的對(duì)象，對(duì)虛擬機(jī)加載類的時(shí)候，就會(huì)創(chuàng)建這個(gè)類的類對(duì)象并加載該對(duì)象。
  Class，是類對(duì)象的類。稱為類類。只有對(duì)象才會(huì)被加載到虛擬機(jī)中。一個(gè)類只會(huì)被加載一次。  
  
2、獲得類對(duì)象的三種方式：（類對(duì)象不用new的方法得到的）
1)也可以用 類名.Class,獲得這個(gè)類的類對(duì)象。
2)用一類的對(duì)象掉用a.getClass()，得到這個(gè)對(duì)象的類型的類對(duì)象。
3)也可以使用Class.forName(類名)（Class類中的靜態(tài)方法），也可以得到這個(gè)類的類對(duì)象，
  （注意，這里寫的類名必須是全限定名（全名），是包名加類名，XXX.XXX.XXXX）。強(qiáng)制類加載，這種方法是經(jīng)常使用的。
  
  一個(gè)類的類對(duì)象是唯一的。
  在使用Class.forName(類名)時(shí)，如果使用時(shí)寫的類名的類，還沒(méi)有被加載，則會(huì)加載這個(gè)類。
  
  Class c;
  c.getName(); 返回類名
  c.getSuperclass(); 這個(gè)方法是獲得這個(gè)類的父類的類對(duì)象。
  c.getInterfaces(); 會(huì)獲得這個(gè)類所實(shí)現(xiàn)的接口，這個(gè)方法返回是一個(gè)類對(duì)象的數(shù)組。
  
  方法對(duì)象是類中的方法的信息的描述。java.lang.reflect.Method,方法類的對(duì)象可以通過(guò)類對(duì)象的getMethods() 方法獲得，
  獲得的是一個(gè)方法對(duì)象的數(shù)組，獲得類中的定義的所有方法對(duì)象，除了構(gòu)造方法。

  構(gòu)造方法對(duì)象，是用來(lái)描述構(gòu)造方法的信息。java.lang.reflect.Constructor構(gòu)造方法類的對(duì)象可以通過(guò)類對(duì)象的getConstructors()方法獲得，
  獲得這個(gè)類的所有構(gòu)造方法對(duì)象。

  屬性對(duì)象，使用來(lái)描述屬性的信息。java.lang.reflect.Field屬性類的對(duì)象對(duì)象可以通過(guò)類對(duì)象getFields() 這個(gè)方法是獲得所有屬性的屬性對(duì)象。

作業(yè)：
1、通過(guò)運(yùn)行時(shí)命令行參數(shù)輸入一個(gè)類名，類出類中所有的方法
2、實(shí)現(xiàn)一個(gè)帶泛型的堆棧，用來(lái)存放Number
3、實(shí)現(xiàn)一個(gè)棧，用來(lái)存放任意類型
  方法：遍歷,pop,push,從數(shù)組拷貝
4、定義一個(gè)枚舉，枚舉值是課程，每個(gè)枚舉值有個(gè)教師姓名的屬性