Myeclipse和eclipse的區別
Myeclipse：是elipse的插件，用於開發javaEE的平臺，爲其打補丁，擴展其功能，可以開發JavaEE程序即web項目，但是現在Myeclipse也集成了eclipse的功能，可直接使用Myeclipse。
eclipse：是開發java的一款專業的IDE（集成開發環境），以前需要Myeclipse才能開發JavaEE程序，現在的eclipse的版本也可以不用再安裝Myeclipse插件，直接可以開發JavaEE項目。
名詞
1）IDE：ItegrityDevelopment Enviroment，集成開發環境
2）JavaEE：javaEnterprise Edition：java企業版開發工具。
3）JMS：Java MessageService，Java消息服務，是一個Java平臺中關於面向消息中間件的API，用於在兩個應用程序間，或分佈式系統中，發送消息，進行異步通信。
4）JMX：Java ManagementExtensions，Java管理擴展；是一個爲應用程序、設備、系統植入管理功能的框架。
5）JNDI：Java Nameingand Directory Interface：Java命名和目錄接口。
6）JDBC：Java DataBase Connectivity：Java數據庫連接。
靜態導入 importstatic
1、import語句：是導入一個類或某個包中的所有類。
2、import static語句：導入一個類中的某個靜態方法或所有靜態方法。
增強for循環
1、語法：for(type 變量名 : 集合變量名){statement}
2、注意：迭代變量必須定義在()中，集合變量可以使參數或實現Iterable接口的集合類，變量類型前可加修飾符，如final（可被局部內部類訪問到）。
可變參數（方法的重載）
特點：
1、只能出現在參數列表的最後。
2、用…這三個點表示參數可以有很多，且這三個點位於變量類型和變量名之間，前後有無空格皆可。
3、調用可變參數的方法時，編譯器爲該可變參數隱含創建一個數組，在方法體中以數組的形式訪問可變參數。
public class VarableParameter {
public static void main(String [] args){
System.out.println(add(2, 3));
System.out.println(add(2, 3, 5));
}
public static int add(int x,int... args){
int sum = x;
/*for(int i=0;i<args.length;i++){
sum += args[i];
}*/
for(int arg : args){
sum += arg;
}
return sum;
}
}
基本數據類型的自動拆箱與裝箱
1、自動裝箱：Integer iObj = 3;
2、自動拆箱：iObj + 2;
3、對於基本數據類型的說明：整數在-128 ~ 127之間的數，包裝成Integer類型對象，會存入常量池中的緩存，再創建同一個對象的時候，會直接使用前一個已有的值，因爲這些小數值使用的頻率很高，所以這些數值需要如此的使用以優化內存。
享元模式（flyweight）
如果很多很小的對象，他們有很多相同的屬性，那麼就可變爲一個對象使用，這些屬性稱爲內部狀態，還有些不同的屬性，作爲方法參數植入，這些稱爲外部狀態。這種優化內存，只創建一個對象的模式，稱之爲享元模式。
應用：
（1）word中輸入英文字母，可創建26對象，每個對象值是出現的位置不同（座標），所以可用一個對象調用位置的方法：如，字母i：i.display(intx,int y)，將高度重複使用的char類型的字母i封裝成一個對象使用。
（2）圖標：window下的文件夾圖標，只喲名稱這個屬性不同，包含了很多其他相同的屬性，那麼可以應用享元模式。
（3）valueOf(int x)：Integer中靜態方法，講一個整數轉換爲Integer，即把基本數據類型變爲包裝類。
枚舉類
1、通過enum定義枚舉類，在其中列出所有同類的元素常量值作爲子類的實例對象使用。枚舉類是一個特殊的類，每個元素都是該類的一個實例對象。
2、用枚舉類規定值，如上面的WeekDay類。以後用此類型定義的值只能是這個類中規定好的那些值，若不是這些值，編譯器不會通過。
3、好處：在編譯時期就會發現錯誤，表明值不符合，減少了運行時期的錯誤。
4、如果調用者想打印枚舉類中元素的信息，需由編寫此類的人定義toString方法。
5、採用抽象方法定義的nextDay可將大量的if else語句轉換成了一個個獨立的類。
6、如果想在一個類中編寫完每個枚舉類和測試調用類，那麼可將枚舉類定義成調用類的內部類。
枚舉類是一個class，而且是一個不可被繼承的final類，其中的元素都是類靜態常量。
public class EnumText {
public static void main(String[] args) {
WeekDayTest weekDay = WeekDayTest.MON;
System.out.println(weekDay.nextDay());
WeekDay weekDay2 = WeekDay.FRI;
System.out.println("獲取此對象：" + weekDay2);
System.out.println("獲取對象名稱：" + weekDay2.name());
System.out.println("獲取排行：" + weekDay2.ordinal());
System.out.println("獲取類名：" + weekDay2.getClass());
//靜態方法：
System.out.println("通過字符串獲取對象："+WeekDay.valueOf("SUN"));
System.out.println("將元素存入數組："+WeekDay.values().length);
}
//定義星期枚舉類
public enum WeekDay{
SUN(1),MON,TUE,WED,THI,FRI,SAT;
private WeekDay(){
System.out.println("first");
}
private WeekDay(int x){
System.out.println("second");
}
}
//定義交通燈
public enum TrafficLamp{
//定義3個元素，即此類的子類，覆寫抽象方法
RED(30){
public TrafficLamp nextLamp() {
return GREEN;
}},
GREEN(45){
public TrafficLamp nextLamp() {
return YELLOW;
}},
YELLOW(5) {
public TrafficLamp nextLamp() {
return RED;
}};
private int time;
//構造方法
private TrafficLamp(int time){this.time = time;}
//抽象方法，轉爲下個燈
public abstract TrafficLamp nextLamp();
}
}
1、構造器：
1）構造器只是在構造枚舉值的時候被調用。
2）構造器只有私有private，絕不允許有public構造器。這樣可以保證外部代碼無法重新構造枚舉類的實例，這樣是合情合理的，因爲枚舉值是public static final的常量，但是枚舉類的方法和數據域是可以被外部訪問的。
3）構造器可以有多個，調用哪個即初始化相應的值。
2、所有的枚舉類都繼承了Enum方法，方法如下：
1）toString() 返回枚舉量的名稱
2）ordina() 返回枚舉值在枚舉類中的順序，按定義的順序排
3）getClass() 獲取對應的類名
靜態方法：
1）valueOf(String e) 轉爲類中對應的對象，即將字符串轉爲對象
2）values()獲取數組，將元素放入一個數組中。
三、注意：
1、元素列表即所有的元素項目，必須放在整個類的最前面。
2、元素列表後要有分號
3、枚舉類中的方法爲private
4、在元素後跟上()，就可指定要使用的構造方法，含參數。
5、枚舉類中的每個元素都是它的一個子類對象，當枚舉類中存在abstract方法，須在子類後加{}，並在其中實現此方法。
四、總結：
1、匿名內部類比較常用
2、類的方法返回的類型可以是類的類型
3、類中可定義靜態常量，常量的結果就是自己這個類型的實例對象
4、如果枚舉只有一個成員，就可以作爲一種單利的實現方式，對象只有一個。
Class
Class是Java程序中各個Java類的總稱；它是反射的基石，通過Class類來使用反射。
Class和class的區別
1）class：Java中的類用於描述一類事物的共性，該類事物有什麼屬性，沒有什麼屬性，至於這個屬性的值是什麼，則由此類的實例對象確定，不同的實例對象有不同的屬性值。
2）Class：指的是Java程序中的各個Java類是屬於同一類事物，都是Java程序的類，這些類稱爲Class。例如人對應的是Person類，Java類對應的就是Class。
Class對象的創建和使用
1、創建實例對象：不可用new Class()的方式，因爲Class沒有這樣的構造方法。而是將字節碼對象賦值給Class變量。如Class c1 =Person.class。
如Person類，它的字節碼：首先要將Person的java文件編譯爲class文件放於硬盤上，即爲二進制代碼，再將這些代碼加載到內存中，接着用它創建一個個對象。就是把類的字節碼加載進內存中，再用此字節碼創建一個個對象。當有如Person、Math、Date等等的類，那麼這些字節碼就是分別的一個Class對象。即Class c2 =Date.class;。
2、獲得類的字節碼對象：如Class.forName(”java.lang.String”)即獲得String.class。得到這個字節碼對象有兩種情況：
1）此類已經加載進內存：若要得到此類字節碼，不需要再加載。
2）此類還未加載進內存：類加載器加載此類後，將字節碼緩存起來，forName()方法返回加載進來的字節碼。
3、得到各字節碼對應的實例對象(Class類型)的方式：
1）類名.class：如System.class，String.class等等
2）對象.class：如new Date().getClass()或者d.getClass()。（Date d = new Date()）
3）Class.forName(“類名”)：如Class.forName(”java.lang.String”)
當獲取類名的時候，是不知道此類的名稱的，forName(字符串參數)方法中傳入字符串型的變量作爲對外訪問的入口，即傳入什麼類名就獲得什麼類名，從而得知相應的類名。
注：forName()是靜態方法，是反射中使用的一種方式獲取字節碼的實例對象。每個類的字節碼對象只有唯一的一個，如任何字符串對象，對應唯一的String.clas字節碼。
4、九個預定義的Class：
1）包括八種基本類型（byte、short、int、long、float、double、char、boolean）的字節碼對象和一種返回值爲void類型的void.class。
2）Integer.TYPE是Integer類的一個常量，它代表此包裝類型包裝的基本類型的字節碼，所以和int.class是相等的。
基本數據類型的字節碼都可以用與之對應的包裝類中的TYPE常量表示
數組類型的Class實例對象，可以用Class.isArray()方法判斷是否爲數組類型的。
5、總結：只要是在源程序中出現的類型都有各自的Class實例對象，如int[].class、void.class等。
Class類方法
1、static Class forName(String className) 返回與給定字符串名的類或接口的相關聯的Class對象。
2、Class getClass() 返回的是Object運行時的類，即返回Class對象即字節碼對象
3、Constructor getConstructor() 返回Constructor對象，它反映此Class對象所表示的類的指定公共構造方法。
4、Field getField(String name) 返回一個Field對象，它表示此Class對象所代表的類或接口的指定公共成員字段。
5、Field[] getFields() 返回包含某些Field對象的數組，表示所代表類中的成員字段。
6、Method getMethod(String name,Class… parameterTypes) 返回一個Method對象，它表示的是此Class對象所代表的類的指定公共成員方法。
7、Method[] getMehtods() 返回一個包含某些Method對象的數組，是所代表的的類中的公共成員方法。
8、String getName() 以String形式返回此Class對象所表示的實體名稱。
9、String getSuperclass() 返回此Class所表示的類的超類的名稱
10、boolean isArray() 判定此Class對象是否表示一個數組
11、boolean isPrimitive() 判斷指定的Class對象是否是一個基本類型。
12、T newInstance() 創建此Class對象所表示的類的一個新實例。
<span style="font-family:Arial;">public static void fuction()throws Exception{
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
//判斷是否爲基本類型：isPrimitive()
System.out.println(cls1.isPrimitive());//false
System.out.println(int.class == Integer.class);//false
//Integer.TYPE代表包裝類對應的基本數據類型的字節碼
System.out.println(int.class == Integer.TYPE);//true
System.out.println(int[].class.isPrimitive());//false
//判斷是否爲數組類型的
System.out.println(int[].class.isArray());//true
}
</span>反射
把Java類中的各種成分映射成相應的Java類。如Class中的每一個方法返回的都是一種類（型），即Method對所有方法抽取成了這個類Method，它的每一個對象（如變量methodObj1）代表了一個方法。
一個類中的組成成分：成員變量、方法、構造函數、包等信息，也用一個個java類來表示（如汽車是一個類，其中的發動機，變速箱等也是對應的一個個類），表示Java類的Class類顯然要提供一系列的方法來獲取其中的變量、方法、構造函數、修飾符、包等信息，這些信息就是用相應的類的實例對象來表示，他們是Field、Method、Contructor、Package等。一個類中的每個成員都可用相應的反射API類的一個實例對象來表示，通過調用Class類的方法可得到這些實例對象。
反射中的類
一、Constructor類
1、Constructor代表某個類的構造方法
2、獲取構造方法：
1）如何得到摸個類的所有構造方法：如得到String類的所有構造方法
Constructor[] cons = Class.forName(“java.lang.String”).getConstructors()；
2）獲取某一個構造方法：
Constructor con =String.class.getConstructor(StringBuffer.class);①
3、創建實例對象：
1）通常方式：String str = new String(new StringBuffer (”abc”));
2）反射方式：String str = (String)con.newInstance(new StringBuffer(“abc”));②
調用獲得的方法時要用到上面相同類型的實例對象，即兩個StringBuffer()要對應相等。
NewInstance()：構造出一個實例對象，每調用一次就構造一個對象。
注意：上面的兩個地方①②都要用到StringBuffer，這必須是一致的。
第①個是指定要帶StringBuffer參數類型的構造方法，即所需使用的是含StringBuffer類型的構造方法。
第②個是用這個構造方法創建對象，要傳入的參數類型是StringBuffer。
4、Class.newInstance()：創建一個對象，不帶參數的構造方法。
//new String(new StringBuffer("abc"));
Constructor constructor1 =
String.class.getConstructor(StringBuffer.class);
String str2 =
(String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2);
//Class.newInstrance創建不帶參數的構造方法
String str3 =
(String)Class.forName("java.lang.String").newInstance();
System.out.println("str3:"+str3);
二、Field類
1、Field類代表成員變量（字段）的反射。
public class ReflectPoint {
private int x;
public int y;
public String toString(){
return str1+";" + str2 + ";" + str3;
}
}
public class FieldTest(){
ReflectPoint pt1 = new ReflectPoint(3,5);
//fieldX和fieldY並不是對象身上的變量，而是類上的
//要用它去取某個對象上的對應的值，傳入什麼對象，就取相應對象的值。
Field fieldY = pt1.getClass().getField("y");
System.out.println(fieldY.get(pt1));
//獲取私有的成員變量
Field fieldX = pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
}
2、獲取成員變量：
如上例子所示：
1）獲取公有的成員變量：
getField(String name)和get(變量)
2）獲取私有的成員變量：暴力反射
getDeclared(String name)
setAccessible(boolean b)，將b設爲true即可
get(變量)
//替換字符
private static void changeStringValue(Object obj) throws Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//此處需要用==比較，因爲是同一份字節碼對象
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b','a');
field.set(obj, newValue);
}
}
}
三、Method類
1、Method類代表某個類中的一個成員方法。調用某個對象身上的方法，要先得到方法，再針對某個對象調用。
2、專家模式：誰調用這個數據，就是誰在調用它的專家。
如人關門：
調用者：是門調用管的動作，對象是門，因爲門知道如何執行關的動作，通過門軸之類的細節實現。
指揮者：是人在指揮門做關的動作，只是給門發出了關的信號，讓門執行。
總結：變量使用方法，是方法本身知道如何實現執行的過程，也就是“方法對象”調用方法，才執行了方法的每個細節的。
3、獲取某個類中的某個方法：（如String str = ”abc”）
1）通常方式：str.charAt(1)
2）反射方式：
Method charAtMethod =Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);
charAtMethod.invoke(str,1);
說明：如果傳遞給Method對象的invoke()方法的第一個參數爲null，說明Method對象對應的是一個靜態方法
4、用反射方式執行某個main方法：
首先要明確爲何要用反射：在寫源程序時，並不知道使用者傳入的類名是什麼，但是雖然傳入的類名不知道，而知道的是這個類中的方法有main這個方法，所以可以通過反射的方式，通過使用者傳入的類名（可定義字符串型變量作爲傳入類名的入口，通過這個變量代表類名），內部通過傳入的類名獲取其main方法，然後執行相應的內容。
//Method類演示
private static void methodTest(String [] args) throws Exception {
String str1 = "abc";
//一般方法：
System.out.println(str1.charAt(1));
//反射方法 ：
Method methodCharAt =
Class.forName("java.lang.String").getMethod("charAt",int.class);
System.out.println(methodCharAt.invoke(str1,1));
//用反射方式執行某個main方法
//一般方式：
Test.main(new String[]{"111","222","333"});
System.out.println("-------");
//反射方式：
String startingClassName = args[0];
Method methodMain =
Class.forName(startingClassName).getMethod("main",String[].class);
//方案一：強制轉換爲超類Object，不用拆包
methodMain.invoke(null,(Object)new String[]{"111","222","333"});
//方案二：將數組打包，編譯器拆包後就是一個String[]類型的整體
methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});
}
//定義一個測試類
class Test{
public static void main(String [] args){
for(String arg : args){
System.out.println(arg);
}
}
}
四、數組的反射
1、數組字節碼的名字：有[和數組對應類型的縮寫，如int[]數組的名稱爲：[I
2、基本數據類型的一維數組不能轉換爲Object數組，如：
int[] a = new int[3]；Object[] obj= a;這樣是不成立的。
3、如何得到某個數組中的某個元素的類型：
例：int a = newint[3]；Object[] obj= new Object[]{”ABC”,1}；
無法得到某個數組的具體類型，只能得到其中某個元素的類型，如
Obj[0].getClass().getName()得到的是java.lang.String
若通過b.getClass().getName()，結果是：[Ljava.lang.Object;
public static void arrayTest()throws Exception {
int[] a1 = new int[]{1,2,3};
int[] a2 = new int[4];
int[][] a3 = new int[2][3];
Integer[] ai = new Integer[3];
String[] a4 = new String[]{"a","b","c"};
System.out.println(a1.getClass() == a2.getClass());
System.out.println((Object)a1.getClass() == (Object)a3.getClass());
System.out.println(a3[0].getClass() == a1.getClass());
System.out.println(a3[0].getClass().getSuperclass().getName());
System.out.println(a1.getClass().equals(a3.getClass()));
System.out.println(a1.getClass().equals(a4.getClass()));
System.out.println(a1.getClass().getName());
System.out.println("----:" + a1.getClass());
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a2.getClass().getSuperclass().getName());
Object obj1 = a1;
Object obj2 = a2;
//int基本數據類型不是Object的
//Object[] obj3 = a1;
Object[] obj4 = a3;
Object[] obj5 = a4;
System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));
System.out.println(Arrays.asList(a4));
System.out.println("-------");
int[] a = new int[3];
Object[] obj = new Object[]{"abc",new Integer(1)};
System.out.println(a.getClass().getName());
System.out.println(obj.getClass().getName());
System.out.println(obj[0].getClass().getName());
}
反射的作用
1、通過反射調用位置Java類的一種方式。如房地產商造房子用戶住，門窗和空調等等內部都是由用戶自己安裝，房子就是框架，用戶需使用此框架，安好門窗等放入到房地產商提供的框架中。
框架和工具類的區別：工具類被用戶類調用，而框架是調用用戶提供的類。
2、框架機器要解決的核心問題：
我們在寫框架（造房子的過程）的時候，調用的類（安裝的門窗等）還未出現，那麼，框架無法知道要被調用的類名，所以在程序中無法直接new其某個類的實例對象，而要用反射來做。
3、簡單框架程序的步驟：
1）右擊項目名-->File-->命名，寫入鍵值對：className=java.util.ArrayList，等號右邊的可以自己定義集合的名稱，即用戶可以對此記事本修改成自己的類名。
2）代碼實現，加載此文件：
①將文件讀取到讀取流中，一定要用完整的路徑，可以使用getRealPath()方法獲取路徑名，再加上自己定義的文件夾名。
②用Properties類的load()方法將流加載經內存，即提取文件中的信息。
③關閉流：關閉的是讀取流，因爲流中的數據已經加載進內存。
3）通過getProperty()方法獲取類名屬性，將傳入的類名賦值給指定變量。
4）用反射的方式，創建對象newInstance()
5）進行相關的具體操作。
類加載器
1、簡述：類加載器是將.class的文件加載經內存，也可將普通文件中的信息加載進內存。
2、文件的加載問題：
1）eclipse會將源程序中的所有.java文件加載成.class文件，以確保編譯，然後放到classPath指定的目錄中去。並且會將非.java文件原封不動的複製到.class指定的目錄中去。在真正編譯的時候，使用classPath目錄中的文件，即放置.class文件的目錄。
2）寫完程序是要講配置文件放到.class文件目錄中一同打包，這些都是類加載器加載的，資源文件（配置文件）也同樣加載了配置文件。
3）框架中的配置文件都要放到classPath指定的文件夾中，原因是它的內部就是用類加載器加載的文件。
3、資源文件的加載：是使用類加載器。
1）由類加載器ClassLoader的一個對象加載經內存，即用getClassLoader()方法加載。若要加載普通文件，可用getResourseAsStream(String name)在classPath的文件中逐一查找要加載的文件。
2）在.class身上也提供了方法來加載資源文件，其實它內部就是先調用了Loader方法，再加載的資源文件。
如：Reflect.class.getResourseAsStream(String name)
4、配置文件的路徑問題：
第一、用絕對路徑，通過getRealPath()方法運算出來具體的目錄，而不是內部編碼出來的。
一般先得到用戶自定義的總目錄，在加上自己內部的路徑。可以通過getRealPath()方法獲取文件路徑。對配置文件修改是需要要儲存到配置文件中，那麼就要得到它的絕對路徑才行，因此，配置文件要放到程序的內部。
第二、name的路徑問題：
①如果配置文件和classPath目錄沒關係，就必須寫上絕對路徑，
②如果配置文件和classPath目錄有關係，即在classPath目錄中或在其子目錄中（一般是資源文件夾resource），那麼就得寫相對路徑，因爲它自己瞭解自己屬於哪個包，是相對於當前包而言的。
例：配置文件內容：className=java.util.ArrayList
<span style="font-family:Arial;">import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest2 {
public static void main(String [] args)throws Exception{
//讀取系統文件到讀取流中
//方式一：
//InputStream ips = new FileInputStream("config.propert");
/*getRealPath()--得到完整的路徑//如：金山詞霸/內部
* 一定要用完整的路徑，但完整的路徑不是硬編碼出來的，而是運算出來的。*/
//方式二：
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/text1/config.propert");
//方式三：
//第一種：配置文件（資源文件）在當前包中
InputStream ips = ReflectTest2.class.getResourceAsStream("resourse/config.propert");
//第二種：配置文件（資源文件）不在當前包中，和此包沒太大關係
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/test2/resourse/config.properties");
//加載文件中的鍵值對
Properties props = new Properties();
props.load(ips);
//關閉資源，即ips調用的那個系統資源
//注意：關閉的是ips操作的流，加載進內存後，就不再需要流資源了，需要關閉
ips.close();
//定義變量，將文件中的類名賦值給變量
String className = props.getProperty("className");
//通過變量，創建給定類的對象
Collection cons =
(Collection)Class.forName(className).newInstance();
//將元素添加到集合中
/*Collection cons = new HashSet();*/
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
cons.add(pt1);
cons.add(pt2);
cons.add(pt3);
cons.add(pt1);
//移除元素
cons.remove(pt1);
System.out.println(cons.size());
}
}
</span>詳細請查看： http://edu.csdn.net