1. MyEclipse是Eclipse的一個插件，此插件可以對Eclipse的功能進行擴展。使Eclipse可以開發JAVAEE的項目，爲了避免安裝的複雜度，MyEclipse廠商將MyEclipse和Eclipse整合到了一起。在開發時只要安裝Eclipse工具即可
2. IDE itegrity development environment（集成開發環境）
3. 一個工作間包含多個工程，對一個工作間的設置會影響到這個工作間下的所有工程
4. File —— Switch WorkSpace—— Other新建一個工作間
5. File —— Switch WorkSpace切換工作間
6. 爲工作間配置內容助理快捷鍵
Window —— Preferences —— General——Keys —— Content Assist —— Binding(Alt+/) ——Apply
若已有快捷鍵但不是Alt+/則需Unbind Command然後再重新綁定
若Alt+/已被另一個命令所佔用則需將其Remove Binding
最後Apply即可
7. 視圖是一個個的小窗口，透視圖是很多個視圖的集合
8. 若某個視圖被關閉了可以通過 Window —— Show View —— Other來打開關閉的視圖
9. 某個程序的JRE的版本比編譯器的版本低則程序運行時時會被：Bad version number
爲了保證程序正常運行要讓JRE與編譯器的版本號保持一致
10. 一個工作間進行了某種功能的設置，則這個工作間下的所有工程都會受到影響。這就是繼承的一個體現。若這個工作間下的某個工程要想擁有自己獨特的設置，則只需對該工程進行設置即可。這就是覆蓋的一個體現。
11. eclipse中配置java模板代碼
案例：配置try…finally
Window ——Preferences —— Java —— Editor —— Templates —— New
Name: tryf
Pattern:
try{
${line_selection}
}finally{
${cursor}
}
最後 Apply即可
12. 在MyEclipse中導入已有工程時報錯，只需把該工程的JRE給Remove掉然後換成MyEclipse中自動的JRE即可
13. Libray（庫）中封裝了很多JAR，添加一個庫就相當於添加了很多個JAR
14. import語句可以導入一個類或者某個包中的所有類
15. import static 語句導入一個類中的某個靜態方法或所有靜態方法
16. JDK1.5的新特性：
① 靜態導入
② 可變參數
③ 基本數據類型的自動拆箱和裝箱
④ 枚舉
⑤ 註解
⑥ 泛型
17. 靜態導入例子
導入一個類中的某個靜態方法
import static java.lang.Math.max;
導入一個類中的所有靜態方法
import static java.lang.Math.*;
18. 可變參數的特點：
① 只能出現參數列表的最後
② …位於變量類型和變量名之間，前後有無空格都可以
③ 調用可變參數的方法時，編譯器爲該可變參數隱含創建一個數組，在方法體中以數組的形式訪問可變參數。
19. 增強for語法：
for(type 變量名：集合變量名){…}
注意事項：
① 迭代變量必須在()中定義
②集合變量可以是數組或實現了Iterable接口的集合類
20. 對於int類型的數據，若其取值範圍是 -128到127之間，則在將其裝箱成Integer類型時，2個Integer類型的變量的內存地址是相同的
如：Integer i1=55;
Integer i2=55;
i1==i2; //true
21. 享元模式（flyweight）：有很多個小的對象，因爲它們有很多屬性相同，就把它們變成一個對象，不同的屬性變成方法的參數。這些參數稱之爲外部狀態，相同的屬性稱之爲內部狀態
22. 枚舉可以讓某個類型的變量的取值只能是若干個固定值中的一個
枚舉就相當於一個類，其中可以定義構造方法，成員變量，普通方法和抽象方法
枚舉元素必須位於枚舉體中的最開始的部分，枚舉元素列表的後嗎要用分號和其它成員分隔
枚舉只有一個成員時，就可以作爲一種單例的實現方式
23. 自定義一個枚舉
publicabstractclass WeekDay1 {
private WeekDay1(){}
//抽象類不能夠創建對象，必須由其子類去實現抽象類中的方法
publicstaticfinal WeekDay1MON=new WeekDay1(){
@Override
public WeekDay1 nextDay() {
return SUN;
}
};
publicstaticfinal WeekDay1SUN=new WeekDay1(){
@Override
public WeekDay1 nextDay() {
return MON;
}
};
//抽象方法必須定義在抽象類中
publicabstract WeekDay1 nextDay();
public String toString(){
returnthis==MON?"MON" : "SUN";
}
}
publicclass EnumTest {
publicstaticvoid main(String[] args) {
WeekDay1 weekDay=WeekDay1.SUN;
System.out.println(weekDay.nextDay());
}
}
24. 枚舉就是一個類，類中的元素就是枚舉的對象，枚舉重寫了Object類中的toString方法
25. 枚舉中的方法
publicclass EnumTest {
publicstaticvoid main(String[] args) {
WeekDay day=WeekDay.SUN;
//枚舉重寫了Object類中的toString()
System.out.println(day);
//打印枚舉的名稱
System.out.println(day.name());
//返回當前枚舉值的位置
System.out.println(day.ordinal());
//將字符串變成枚舉對象
System.out.println(WeekDay.valueOf("MON"));
//獲取枚舉值對象數組的長度
System.out.println(WeekDay.values().length);
}
publicenum WeekDay{
SUN,MON,THU,WEN,THI,FRI,SAT
}
}
26. 帶有構造方法的枚舉
publicclass EnumTest {
publicstaticvoid main(String[] args) {
WeekDay weekDay2=WeekDay.SUN;
}
publicenum WeekDay{
SUN(1),MON,THU,WEN,THI,FRI,SAT;
private WeekDay(){System.out.println("first");}
private WeekDay(int day){System.out.println("second");}
}
}
在創建枚舉對象時默認調用無參構造方法
27. 帶有抽象方法的枚舉
publicenum TrafficLamp{
//若枚舉中有抽象方法，則枚舉中的元素要重寫抽象方法
//若枚舉中有有參構造方法，則枚舉中的元素必須顯示的調用此構造方法
RED(30) {
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},GREEN(54) {
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
publicabstract TrafficLamp nextLamp();
privateinttime;
private TrafficLamp(int time){
this.time=time;
}
}
28. Java程序中的各個Java類屬於同一個事物，描述這類事物的Java類名就是Class
29. 每一個字節碼就是一個Class實例對象
30. Class.forName的作用：返回類的字節碼
31. 獲取字節碼對應的實例對象的三種方式：
類名.class如：System.class
對象.getClass()如：new Date().getClass()
Class.forName(“類名”)如：Class.forName(“java.util.Date”)
32. 反射就是把Java類中的各種成分映射成相應的Java類
33. Constructor類代表某個類中的一個構造方法
① 獲取某個類中的所有構造方法
如：Constructor [ ] cns=Class.forName(“java.lang.String”).getConstructors();
② 獲取某一個構造方法
Constructor cns=Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
③ 用反射生成對象
Constructor c=String.class.getConstructor(StringBuffer.class);
String str=c.newInstance(new StringBuffer("abc"));
④ Class.newInstance() 用默認的構造方法創建實例對象
此方法底層用到了緩存機制來保存默認構造方法的實例對象
34. 成員變量的反射
publicclass ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x,int y) {
super();
this.x = x;
this.y = y;
}
}
publicclass ReflectTest {
publicstaticvoid main(String[] args)throws Exception{
ReflectPoint rp=new ReflectPoint(3, 5);
//訪問共有變量
Field fieldY=rp.getClass().getField("y");
System.out.println(fieldY.getName()+"::"+fieldY.getInt(rp));
//訪問私有變量
Field fieldX=rp.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.getName()+"::"+fieldX.getInt(rp));
}
}
35. 成員變量反射的綜合案例
將任意一個對象中的所有String類型的成員變量所對應的字符串內容中的”b”改成”a”
publicclass ReflectPoint {
private int x;
public int y;
public Stringstr1="ball";
public Stringstr2="basketball";
public Stringstr3="itcast";
public ReflectPoint(int x,int y) {
super();
this.x = x;
this.y = y;
}
@Override
public String toString() {
returnstr1+":"+str2+":"+str3;
}
}
publicclass ReflectTest {
publicstaticvoid main(String[] args)throws Exception{
ReflectPoint rp=new ReflectPoint(3, 5);
changeStringValue(rp);
System.out.println(rp);
}
privatestaticvoid changeStringValue(Object obj)throws Exception{
Field[] fields=obj.getClass().getFields();
for(Field field : fields){
Type type=field.getType();
if(type==String.class){
String oldVal=(String)field.get(obj);//獲取某個對象中的字段
if(oldVal.contains("b")){
String newVal=oldVal.replace("b","a");
field.set(obj, newVal);
}
}
}
}
}
36. 成員方法的反射
Method類代表某個類中的一個成員方法
如：
String str="abc";
//str.chaAt(2);
Method m=String.class.getMethod("charAt",int.class);
System.out.println(m.invoke(str, 2));
37. 對接收數組參數的成員方法進行反射
publicclass ReflectTest {
publicstaticvoid main(String[] args)throws Exception{
Class startingClassName=Class.forName(args[0]);
Method m=startingClassName.getMethod("main", String[].class);
// m.invoke(null, (Object)new String[]{"11","22","33"});
m.invoke(null,new Object[]{new String[]{"11","22","33"}});
}
}
class ParameterTest{
publicstaticvoid main(String[] args) {
for(String arg : args){
System.out.println(arg);
}
}
}
當把一個字符串數組作爲參數傳遞給invoke方法時，按jdk1.5的語法，會把這個參數當作是一個字符串數組，而按jdk1.4的語法，會把字符串數組打散成爲若干個單獨的參數；java在執行代碼時，會按照jdk1.4的語法去處理
38. 反射會影響程序的性能
39. 數組也是Object類型的元素
40. 具有相同維數和元素類型的數組屬於同一個類型，即具有相同的Class實例對象
41. 代表數組的Class實例對象的getSuperClass()方法返回的父類爲Object類對應的Class
42. 基本類型的一維數組可以被當做Object類型使用
43. 非基本類型的一維數組既可以當做Object類型使用，又可以當做Object[ ]類型使用
44. Arrays.asList()方法處理int[ ]和 String[ ]是有差異的，它會把int[ ]當成一個元素去處理，把String[ ]中的每一個元素當成一個元素去處理。這是因爲在jdk1.4中asList接收的參數類型是Object[]而jdk1.5中asList接收的參數類型是可變參數。
45. 數組與Object的關係及其反射類型
①int[ ] a1=new int[3];
②int[ ] [ ] a2=new int[2][3];
③String [ ] a3=new String[3];
②, ③均屬於Object[ ]類型
①屬於Object類型
46. 數組的反射
Array工具類用於完成對數組的反射操作
如：
private static void printObj(Object obj) {
Class clazz=obj.getClass();
if(clazz.isArray()){
int len=Array.getLength(obj);
for(int x=0; x<len; x++){
System.out.println(Array.get(obj, x));
}
}else{
System.out.println(clazz);
}
}
在main方法中定義函數：
printObj(a4);
printObj("abc");
47. Object類中的equals()方法比較的是內存地址(hashCode值)
48. 當一個對象被存儲進HashSet集合中以後，就不能修改這個對象中的那些參與計算哈希值的字段了，否則，對象修改後的哈希值與最初存進HashSet集合中的哈希值就不同了，在這種情況下，即使在contains方法使用該對象的當前引用作爲的參數去HashSet集合中檢索對象，也將返回不到對象的結果，這也會導致無法從HashSet集合中單獨刪除當前對象，從而造成內存泄露。
49. 獲取資源文件的2中方式：
//必須寫上資源文件的完整路徑
//InputStream is=ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/resource/Info.properties");
//路徑寫資源文件相對於本java文件所在目錄("cn/itcast/day1)即可
InputStream is=ReflectTest2.class.getResourceAsStream("resource/Info.properties");
50. 內省（IntroSpector）
需要導入的包：commons-beanutils-1.8.3.jar commons-logging-1.1.2.jar
ReflectPoint rp=new ReflectPoint(3, 5);
BeanUtils.getProperty(rp,"x").getClass().getName();//java.lang.String
BeanUtils.setProperty(rp, "x", 9);
51. 一個註解就是一個類，當用到某個註解時就相當於創建了這個註解的對象
52. 註解可以加在包，類，字段，方法，方法的參數以及局部變量上
53. 基本的註解：
① @SuppressWarnings(“deprecation”) 告知編譯器不要提示方法過時
② @Deprecated 告知編譯器該方法已過時
③ @Override 告知編譯器該方法是覆蓋父類的方法
54. 註解的使用
@Retention(RetentionPolicy.RUNTIME)
用於指定註解的生命週期在哪個階段（CLASS,RUNTIME,SOURCE）
SOURCE—源代碼階段
CLASS—源代碼編譯後的CLASS文件階段
RUNTIME—類加載器將CLASS文件加載進內存階段
@Target({ElementType.METHOD,ElementType.TYPE})
用於指定註解可以標識的位置，即可以標識在方法上，也可以標識在類，枚舉，接口上，等；
55. 元註解：註解的註解
56. 爲註解增加各種屬性
public@interfaceMetaAnnotation {
String value();
}
//@Retention --指定註解的聲明週期
@Retention(RetentionPolicy.RUNTIME)//類加載器將CLASS文件加載進內存階段
//@Target --指定註解的標註位置
@Target({ElementType.METHOD,ElementType.TYPE})//可以將註解標註在方法，類，接口，枚舉上
public@interfaceItcastAnntation {
//註解中的屬性類似於方法,屬性名後都帶()
//註解的返回值類型：8種基本數據類型，String，Class，enum，Array，註解
//定義枚舉的屬性
String color() default"blue";
//若枚舉中只有一個value屬性時，在設置value屬性時可以省略value=
String value();
//定義數組屬性
int[] arr()default {3,4,5};
//定義枚舉屬性
EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;
//定義註解屬性
MetaAnnotation annotationAttr()default@MetaAnnotation("zhujieshuxing");
//定義Class屬性
Class clazz() default Object.class;
}
//若數組屬性中只有一個元素，屬性值可以省略大括號
@ItcastAnntation(clazz=String.class,annotationAttr=@MetaAnnotation("invoke zhujieshuxing"),color="red",value="abc",arr=1)
publicclass AnnotationTest {
@SuppressWarnings("deprecation")
@ItcastAnntation("xyz")
publicstaticvoid main(String[] args) {
System.runFinalizersOnExit(true);
//檢查該類上是否有註解
if(AnnotationTest.class.isAnnotationPresent(ItcastAnntation.class)){
ItcastAnntation annotation=AnnotationTest.class.getAnnotation(ItcastAnntation.class);
//調用註解的屬性
System.out.println(annotation.color());
System.out.println(annotation.value());
System.out.println(annotation.arr().length);
System.out.println(annotation.lamp().nextLamp());
System.out.println(annotation.annotationAttr().value());
System.out.println(annotation.clazz().getName());
}
}
57. 泛型的內部原理
泛型是提供給javac編譯器使用的，可以限定集合中的輸入類型，讓編譯器擋住源程序中的非法輸入，編譯器編譯帶類型說明的集合時會去除掉“類型”信息，使程序運行效率不受影響，對於參數化的泛型類型，getClass()方法的返回值和原始類型完全一樣。由於編譯生成的字節碼會去掉泛型的類型信息，只要能跳過編譯器，就可以往某個泛型集合中加入其它類型的數據，如，用反射得到集合，再調用其add方法即可。
舉例：
publicclass GenericTest {
publicstaticvoid main(String[] args)throws Exception{
ArrayList<String> col1=new ArrayList<String>();
ArrayList<Integer> col2=new ArrayList<Integer>();
System.out.println(col1.getClass() == col2.getClass());
//用反射往col2中添加字符串元素
col2.getClass().getMethod("add",Object.class).invoke(col2,"abc");
System.out.println(col2.get(0));
}
}
58. ArrayList<E>類定義和ArrayList<Integer>類引用中涉及如下術語：
ArrayList<E> 泛型類型，E：類型參數
ArrayList<Integer> 泛型參數類型，Integer：實際類型參數
< > 念typeof
ArrayList：原始類型
59. 泛型中的類型不存在父子關係
60. 即Collection<Object>與Collection<Integer>不存在等號關係
61. 編譯器不允許創建類型變量的數組。即在創建數組實例時，數組的元素不能使用參數化的類型。
62. 泛型中通配符的使用
①使用？通配符可以引用其它各種參數化的類型，？通配符定義的變量主要用作引用，可以調用與參數化無關的方法，不能調用與參數化有關的方法。
②泛型中的？通配符擴展
1) 限定通配符的上界
Vector<? extends Number> x = new Vector<Integer>();
?— Number或Number的子類
2) 限定通配符的下界
Vector<? super Integer> x = new Vector<Number>();
?— Integer或Integer的父類
提示：限定通配符總是包括自己
63. 只有引用類型才能作爲泛型方法的實際參數。
publicstatic <T>void swap(T[]arr,int x,int y){
T temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
swap(new String[]{"aa","bb","cc"},1,2);
64. Arrays.asList()不能轉換Int類型的數組
65. <T>一般放在方法的修飾符之後，方法的返回值之前
66. 普通方法，構造方法和靜態方法中都可以使用泛型
67. 靜態方法不能使用類定義的泛形，而應單獨定義泛形
68. 用反射獲取泛型的實際類型參數
publicclass GenericTest {
publicstaticvoid main(String[] args)throws Exception{
Method m=GenericTest.class.getMethod("applyVector", Vector.class);
Type[] type=m.getGenericParameterTypes();
ParameterizedType pt=(ParameterizedType)type[0];
System.out.println("原始類型："+pt.getRawType());
System.out.println("實際類型參數："+pt.getActualTypeArguments()[0]);
}
}
publicstaticvoid applyVector(Vector<Date> v1){
}
69. Java虛擬機中可以安裝多個類加載器，系統默認三個主要的類加載器，每個類加載器負責加載特定位置的類。
BootStrap ExtClassLoader AppClassLoader
70. 類加載器：加載類的工具
71. rt.jar：存放java系統提供的類
72. 有包名的類不能調用無包名的類
73. 類加載器的委託機制
每個ClassLoader本身只能分別加載特定位置和目錄中的類，但它們可以委託其它的類裝載器去加載類，這就是類加載器的委託模式。類裝載器一級級委託到BootStrap類加載器，當BootStrap無法加載當前所要加載的類時，然後才一級級回退到子孫類裝載器去進行真正的加載。當回退到最初的類裝載器時，如果它自己也不能完成類的裝載，那就報ClassNotFoundException異常
74. 當Java虛擬機要加載一個類時，到底派出哪個類加載器去加載呢
首先當前線程的類加載器去加載線程中的第一個類
若類A中引用了類B，Java虛擬機將使用加載類A的類裝載器來加載類B
還可以直接調用ClassLoader.loadClass()方法來指定某個類加載器去加載某個類
75. 安全，事務，日誌等功能要貫穿到好多個模塊中，所以稱它們爲交叉業務
76. 交叉業務的編程問題即爲面向方面的編程（Aspect oriented program簡稱AOP）AOP的目標就是要使交叉業務模塊化
77. 代理是實現AOP功能的核心技術
78. 動態代理類：JVM在運行期動態生成的類的字節碼
79. CGLIB庫可以動態生成一個類的子類，一個類的子類也可以用作該類的代理，故要爲一個沒有實現接口的類生成動態代理類，可以使用CGLIB庫
80. 把切面代碼用對象的方式進行封裝，並以對象的方式進行傳遞，執行對象就相當於執行切面的代碼