------- android培訓、java培訓、期待與您交流！ ----------

一、eclipse的使用技巧

1.設定自己的執行環境

在Eclipse解壓的時候，會自動的為我們找到Java的JRE，我們當然也可以自己來配置我們自己希望的jre。

a、單擊選單欄中的Windows選擇Preferences。

b、在Preferences的左邊的列表中單擊Java前面的的"+"

c、在出現的下來選項中單擊Install JREs————選擇Java程式執行的jre

d、可以點選Add，Remove等按鈕，新增和移除JRE

e、在出現的下來選項中單擊Compiler————選擇編譯源程式的的版本

2、快捷鍵配置：

Windows——>Preferences——>General——>Keys——>Content Assist——>解除原來的繫結——>設定新的繫結。

3、Java模版設定：

Windows——>Preferences——>java——>edit——>templates——>new

4、工程匯入

File——>import——>Existing Projects into Workspace——>選擇工程目錄。

二、JDK1.5新語法

（一）靜態匯入

1、import語句可以匯入一個類或包中的所有的類。import static語句匯入一個類中的某個靜態方法或者所有靜態方法。

匯入格式：

import static 包名.類名.方法名；——匯入某個靜態方法

import static 包名.類名.*；——匯入該類的全部靜態方法。

例：求兩個數相減結果的絕對值。

在未使用靜態匯入之前呼叫靜態方式是類名.方法名 的程式是

package com.heima.test;

public class StaticImport {
	public static void main(String[] args) {
		System.out.println(Math.max(2, 6));
		System.out.println(Math.abs(2-6));
	}
}
 

在使用靜態匯入之後可以不用使用類名，可以直接使用方法。，程式如下

package com.heima.test;
import static java.lang.Math.*;
public class StaticImport {
	public static void main(String[] args) {
		System.out.println(max(2, 6));
		System.out.println(abs(2-6));
	}
}

（二）可變引數：

1、含義：一個方法接受的引數個數不確定。

2、可變引數的定義：在引數列表後加 ：引數型別...

3、可變引數的特點：

1、只能出現在引數列表的最後。

2、...位於變數型別和變數名之間，前後有誤空格都可以。

3、呼叫可變引數的方法時，編譯器為該可變引數隱含建立一個數組，在方法體中以陣列的形式訪問可變引數

4、例：將給定的引數進行相加，引數個數不定

在使用前可變引數前，我們只能通過過載來實現（侷限性很大）

使用可變引數之後：

package com.heima.test;

public class VarableParameter {

	public static void main(String[] args) {
	System.out.println(add(2,3));
	System.out.println(add(2,3,4,5));

	}
	//在下面這個引數中使用可變引數來定義
	public static int add(int x,int...ar){
		int sun = 0;
		for(int i=0;i<ar.length;i++){
			sun = sun+ar[i];
		}
		return sun;
	}

}

（三）增強for迴圈

1、語法：for(type 變數名：集合變數){...}

2、注意事項：

1、迭代變數必須在()中定義。

2、集合變數可以是陣列或實現Iterable介面的集合類

3、例：在（二）中的例子中可以使用增強for迴圈來代替for迴圈。

package com.heima.test;

public class VarableParameter {

	public static void main(String[] args) {
	System.out.println(add(2,3));
	System.out.println(add(2,3,4,5));

	}
	//在下面這個引數中使用可變引數來定義
	public static int add(int x,int...args){
		int sun = 0;
		/*for(int i=0;i<args.length;i++){
			sun = sun+args[i];
		}*/
		//for迴圈增強
		for(int arg:args){
			sun +=arg; 
		}
		return sun;
	}

}

（四）自動拆裝箱及亨元設計模式

1、自動裝箱：如果把整數裝成Integer物件，如果整數在一個位元組內，則同一個數的裝箱物件是同一個物件

在JDK1.5以前，在定義Integer裝箱時，只能是   Integer a = new Integer(5);

在JDK1.5上，能自動裝箱，即  Integer a = 5;

2、自動拆箱：

在JDK1.5可以直接將Integer物件與int型別數字進行運算。

3、享元模式（flyweight）：有很多小的物件，他們有很多屬性相同（內部狀態），將不同的屬性變成方法的引數（外部狀態）。就將其封裝成一個物件，以此來減少記憶體。

（五）、列舉

1、作用：規定該類物件的取值，如果取值不在指定範圍類，則在編譯時期就會報錯。提高了安全性。

2、列舉的說明：

1、列舉是一種特殊的類，其中的每個元素都是該類的一個例項物件。列舉元素必須位於列舉體中的最開始部分。

2、列舉也可以定義構造方法（必須私有）、成員變數、和抽象方法。但是抽象方法必須在元素裡實現。

3、只要用到列舉類，列舉類裡的元素都會初始化，呼叫無參的構造方法。

4、如要呼叫有參，在元素後面加括號裡面傳入相應的型別引數。

5、列舉裡只有一個元素時，就可以作為一種單例的實現方式。

3、列舉的常用方法：

1、valueOf(Class<T> enumType, String name):返回帶指定名稱的指定列舉型別的列舉常量。

2、toString()：反回當前列舉的名稱。

3、ordinal()：返回列舉常量的序數（它在列舉宣告中的位置，其中初始常量序數為零）。

4、列舉的定義例項：

package com.heima.test;

public class EnumTest {
	public static void main(String[] args){

		WeekDay weekDay2 = WeekDay.MON;
		System.out.println(weekDay2.ordinal());
		
	}
	//定義列舉型別——星期
	public enum WeekDay{
		//元素必須位於沒具體的開始位置
		//如果呼叫有參建構函式，在元素後的括號內傳入相應型別的引數
		SUN(1),MON(2),TUE(3),WED(4),TRI(5),FRI,SAT(6);
		private WeekDay(){System.out.println("first");}
		private WeekDay(int day){}
	}
	//定義列舉型別——訊號燈
	public enum TrafficLamp{
		//如果呼叫有參建構函式，在元素後的括號內傳入相應型別的引數
		//在元素後面實現該列舉型別的抽象方法
		RED(30){
			public TrafficLamp nextLamp() {
				return GREEN;
			}
			
		},
		GREEN(25){

			public TrafficLamp nextLamp() {
				return YELLOW;
			}
			
			
		},YELLOW(10){

			public TrafficLamp nextLamp() {

				return RED;
			}
			
		};
		//宣告抽象方法
		public abstract TrafficLamp nextLamp();
		//定義引數
		private int time;
		//有參構造方法
		private TrafficLamp(int time){
			this.time =time;
		}
	}

}

（六）反射

1、反射基石——>Class:

1、java程式中的各個Java類屬於同一類事物，描述這類事物的Java類名就是Class.

2、Class的例項物件就Java中類的位元組碼

3、取得各個位元組碼對應的例項物件（Class型別）

1、類名.class   如：System.class

2、物件.getClass()   如：new Person().getClass()

3、Class.forName("類名")

4、九個預定義Class例項物件

八個基本資料型別和void都有自己的Class例項物件。

5、陣列型別的Class例項物件

Class.isArray()

總之，只要是在源程式出現的型別，都有各自的Class例項物件。

2、反射：——>

1、反射就是把Java類中的各種成分對映成相應的Java類。例如：一個Java類中用一個Class類的物件來表示，一個類中的組成部分：成員變數，方法，構造方法，包等等資訊用一個個的Java類來表示。

2、表示Java類的Class類提供了一系列的方法，來獲得其中的變數、方法、構造方法、修飾符、包資訊，這些資訊就是用相應類的例項物件來表示。他們是Field、Method、Contructor、Package

3、Constructor類：

1、表示代表某個類中的一個構造方法。

2、得到某個類所有的構造方法：

方法：Constructor[] constructor = Class.forName("java.lang.String").getConstructor()；

3、得到某一個構造方法：

方法：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

4、例項演示：通過獲取String類中String（StringBuffer）的這個函式的反射，再通過該反射建立一個String物件。

package com.heima.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class cons {

	public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
		// 1、獲取String類中相應構造方法的位元組碼物件
		Constructor strc = String.class.getConstructor(StringBuffer.class);
		
		//2、通過newInstance()方法建立物件
		String str = (String) strc.newInstance(new StringBuffer("你好"));
		
		System.out.println(str);
	}

}

4、Field類：

1.Field類是類中屬性的總稱。

2、獲取類中屬性的方法：

1、獲取所有的公有屬性：         類位元組碼物件.getFields();

2、獲取私有屬性：類位元組碼物件.getDeclaredFields（）；

3、獲取指定名稱的公有屬性：類的位元組碼物件.getField("屬性名");

4、獲取指定名稱的私有屬性：  類的位元組碼物件.getDeclaredField("屬性名");

3、操作所獲取到的屬性。

注意：

1、這裡所指的“所獲取到的屬性”是指獲取的是指定的屬性，不是該類的某個物件的屬性。所以在使用的時候，必須宣告該屬性作用的物件。

2、在操作私有屬性前，必須先通過setAccessible(Boolean)方法，將布林值設為為true，意思是將反射的物件在使用時應該取消 Java 語言訪問檢查。

程式碼示例：

package com.itcast;

import java.lang.reflect.Field;

public class ReflectField {
	/**
	 * 通過反射的方式獲取物件的私有以及共有屬性
	 */
	
	public static void main(String[] args) throws SecurityException, NoSuchFieldException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException {
		// TODO Auto-generated method stub
		//建立一個ReflectPoint物件
		ReflectPoint rp = new ReflectPoint(6,7);
		
		//獲取ReflectPoint的私有屬性
		Field fieldx = Class.forName("com.itcast.ReflectPoint").getDeclaredField("x");
		fieldx.setAccessible(true);
		
		//獲取ReflectPoint的屬性（公有）
		Field fieldy = Class.forName("com.itcast.ReflectPoint").getField("y");
		
		//獲取指定物件的屬性物件
		int x1 = (Integer) fieldx.get(rp);
		int y1 = (Integer) fieldy.get(rp);
		
		System.out.println("x1："+x1+", y1:"+y1);
	}

}
class ReflectPoint {
	
	private int x;
	public int y;
	
	public ReflectPoint(int x, int y) {
		this.x = x;
		this.y = y;
	}
}

5、Method類：

1、指類中方法物件的總稱。

2、獲取方法：

原理和獲取指定類中的屬性物件一樣。

3、在使用該方法物件的時候：

如果方法是非靜態的，則必須指明作用的物件，並且傳入相應的引數。

如果方法是靜態的，則無需指明作用的物件，即可以在物件的那個位置填null.

4、程式碼示例：

package com.itcast;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class RelectMethod {

	/**
	 *通過反射獲取物件的方法，並執行該方法。
	 */
	public static void main(String[] args) throws SecurityException, NoSuchMethodException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		// TODO Auto-generated method stub
		ReflectPoint1 rp = new ReflectPoint1(7,8);
		Method method = Class.forName("com.itcast.ReflectPoint1").getDeclaredMethod("sys", null);
		method.setAccessible(true);
		method.invoke(rp, null);
	}

}
class ReflectPoint1 {
	
	private int x;
	public int y;
	
	public ReflectPoint1(int x, int y) {
		this.x = x;
		this.y = y;
	}
	private void sys(){
		System.out.println("x ="+x+"  y ="+y);
	}
}

示例2：

通過使用者提供的類名（完整的類名）去指定指定的類。即根據傳入的類名，去指定該類的主函式。

注意：在傳遞陣列的時候，必須用new Object 或者（Object）將陣列封裝，因為為了相容JDK1.4傳進的資料會被拆包。

程式：

package com.itcast;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class RelectMethod {

	/**
	 *通過反射獲取物件的方法，並執行該方法。
	 */
	public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, ClassNotFoundException {
		String StartClass = args[0]; 
		Method main = Class.forName(StartClass).getMethod("main", String[].class);
		main.invoke(null, new Object[]{new String[]{"黑馬","is","Best"}});
	}

}
class MainMethod {
	
	public static void main(String[] args){
		for(String arg:args){
			System.out.println(arg);
		}
	}
}

6、陣列的反射

總結：

1、當陣列的元素型別和維度相同時，則該類陣列的反射物件都是同一個。

2、類得到位元組碼的方法是  類名.class。類的物件得到位元組碼的方法是  物件.getClass();

3、獲取類位元組碼物件的父類位元組碼物件的名字：位元組碼物件.getSuperclass().getName();

4、基本資料型別不是Object型別。

5、如果定義了一個數組在後面 指定了元素，則不能再指定陣列的長度。

6、通過工具類中Arrays中asList()方法將一個數組轉換成一個List集合的時候，如果是非基本型別的陣列，則該陣列中的物件是屬於Object型別，所以呼叫該方法則是將該資料中的元素存進一個list集合中，然後返回該集合，如果是基本資料型別陣列，因為基本型別不是Object型別，所以是隻能通過jdk1.5的處理方式，把該陣列當作一個物件。所以基本資料型別呼叫該方法，是將該陣列物件存進list集合再返回該集合。

 7、為什麼不能獲取陣列的型別？

因為在jdk1.4中運算元組傳進的引數是Object型別的陣列，在Object陣列中的元素可以是任意型別，所以不能知道該陣列的型別。只能通過陣列中的元素呼叫getClass().getName()方法獲取該元素的型別。