day01-java重點複習

day01
MyEclipse介紹

1　debug斷點調試
 設置斷點；
 測試跳入（F5）；
 測試跳過（F6）；
 測試跳出（F7）；
 添加斷點；
 測試進入下一斷點；
 測試返回當前方法棧的頭部（Drop To Frame）；
 清除斷點；
 清除表達式；
注意，中止程序！

2　經常使用快捷鍵
　　必須的：
 Alt + /（內容助理）：補全；
 Ctrl + 1（快速定位）：出錯時定位錯誤，與點擊「紅X」效果同樣；
 Ctrl + Shift + O：導包；
 Ctrl + Shift + F：格式化代碼塊；

不是必須的（本身讀，不講）：
 Ctrl + Shift + T：查看源代碼；
 Ctrl + 點擊源代碼：查看源代碼；
 F3：查看選中類的源代碼；
 Alt + 左鍵：查看源代碼時的「原路返回」；
 Ctrl + Shift + X：把小寫修改成大寫；
 Ctrl + Shift + Y：把小寫修改成小寫；
 Ctrl + Alt + 下鍵：複製當前行；
 Ctrl + /：添加或撤銷行註釋；
 Ctrl + Shift + /：對選中代碼添加段註釋；
 Ctrl + Shift + ：撤銷當前段註釋；
 Alt + 上鍵：向上移動當前行；
 Alt + 下鍵：向上移動當前行；
 Ctrl + D：刪除當前行；

JUnit
1　JUnit的概述
當咱們寫完了一個類後，老是要執行一下類中的方法，查看是否符合咱們的意圖，這就是單元測試了。而Junit就是單元測試工具。
 導包：導入Junit4或以上版本；
 編寫一個類：Person，它就是要被測試的類；
 編寫測試類：PersonTest，給出測試方法，在測試方法上使用@Test註解；
 執行測試方法。

Person
package cn.itcast;

public class Person {
public void run() {
System.out.println("run");
}
public void eat() {
System.out.println("eat");
}
}

包資源管理器選中Person類右鍵newJUnit TestCase修改包名爲junit.test下一步選中要測試的方法。

PersonTest
package junit.test;

import org.junit.Test;
import cn.itcast.Person;

public class PersonTest {
@Test
public void testRun () {
Person person = new Person();
person.run();
}
@Test
public void testEat () {
Person person = new Person();
person.eat();
}
}

選中某個測試方法，鼠標右鍵Run asJunit Test，即執行測試方法。
@Test註解的做用是指定方法爲測試方法，測試方法必須是public、void、無參的！！！

2　@Before和@After(瞭解)
若是你須要某個方法在每一個測試方法以前先執行，那麼你須要寫一個方法，而後使用@Before來標記這個方法。例如在testRun()和testEat()方法以前須要建立一個Person對象。
PersonTest
package junit.test;

import org.junit.Before;
import org.junit.Test;
import cn.itcast.Person;

public class PersonTest {
private Person person;
@Before
public void setUp () {
person = new Person();
}
@Test
public void testRun() {
person.run();
}
@Test
public void testEat() {
person.eat();
}
}

@After註解標記的方法會在每一個執行方法以後執行
@Before和@After標記的方法必須是public、void、無參。

JDK5.0新特性

1 自動拆裝箱
自動拆裝箱是JDK5.0的新特性之一，這一特性可使基本類型，與之對應的包裝器類型之間直接轉換，例如int的包裝器類型是Integer！在JDK5.0以後，你甚至能夠把int看成成Integer來使用，把Integer當成int來使用。固然，這不是100%的！
1.1　自動拆裝箱概述
在JDK5.0以後，Java容許把基本類型與其對應的包裝器類型之間自動相互轉換。
 自動裝箱：Integer i = 100，把int類型直接賦值給Integer類型；
 自動拆裝：int a = new Integer(100)，把Integer類型直接賦值給int類型。

1.2　自動拆裝箱原理
其實自動拆裝箱是由編譯器完成的！咱們寫的代碼，再由編譯器「二次加工」，而後再編譯成.class文件！那麼編譯器是怎麼「二次加工」的呢？
 Integer i = 100：編譯器加工爲：Integer i = Integer.valueOf(100)；
 int a = i：編譯器加載爲：int a = i.intValue()；
這也說明一個道理：JVM並不知道什麼是自動拆裝箱，JVM仍是原來的JVM（JDK1.4以前），只是編譯器在JDK5.0時「強大」了！

1.3　自動拆裝箱演變
你們來看看下面代碼：
Integer i = 100;//這是自動裝箱
Object o = i;//這是身上轉型

上面代碼是沒有問題的，咱們是否能夠修改上面代碼爲：
Object o = 100;

ok，這是能夠的！經過編譯器的處理後上面代碼爲：
Object o = Integer.valueOf(100);

在來看下面代碼：
Object o = Integer.valueOf(100);
int a = o;//編譯失敗！

上面代碼是不行的，由於o不是Integer類型，不能自動拆箱，你須要先把o轉換成Integer類型後，才能賦值給int類型。
Object o = Integer.valueOf(100);
int a = (Integer)o;

1.4　變態小題目
來看下面代碼：
Integer i1 = 100;
Integer i2 = 100;
boolean b1 = i1 == i2;//結果爲true

Integer i3 = 200;
Integer i4 = 200;
boolean b2 = i3 == i4;//結果爲false

你可能對上面代碼的結果感到費解，那麼咱們來打開這個疑團。第一步，咱們先把上面代碼經過編譯器的「二次加工」處理一下：
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
boolean b1 = i1 == i2;//結果爲true

Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
boolean b2 = i3 == i4;//結果爲false

這時你應該能夠看到，疑團在Integer.valueOf()方法身上。傳遞給這個方法100時，它返回的Integer對象是同一個對象，而傳遞給這個方法200時，返回的倒是不一樣的對象。這是咱們須要打開Integer的源碼（這裏就不粘貼Integer的源代碼了），查看它的valueOf()方法內容。
Integer類的內部緩存了-128~127之間的256個Integer對象，若是valueOf()方法須要把這個範圍以內的整數轉換成Integer對象時，valueOf()方法不會去new對象，而是從緩存中直接獲取，這就會致使valueOf(100)兩次，都是從緩存中獲取的同一個Integer對象！若是valueOf()方法收到的參數不在緩存範圍以內，那麼valueOf()方法會new一個新對象！這就是爲何Integer.valueOf(200)兩次返回的對象不一樣的緣由了。

2　可變參數
可變參數就是一個方法能夠接收任意多個參數！例如：fun()、fun(1)、fun(1,1)、fun(1,1,1)。你可能認爲這是方法重載，但這不是重載，你想一想重載能重載多少個方法，而fun()方法是能夠傳遞任何個數的參數，你能重載這麼多個方法麼？

2.1　定義可變參數方法
public void fun(int… arr) {}
上面方法fun()的參數類型爲int…，其中「…」不是省略號，而是定義參數類型的方式。參數arr就是可變參數類型。你能夠把上面代碼理解爲：public void fun(int[] arr)。
public int sum1(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
public int sum2(int... arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}

你可能會想，「int[]」和「int…」沒有什麼不一樣，只是「int…」是一種新的定義數組形參的方式罷了。那麼我應該恭喜你了！沒錯，這麼理解就對了！但要注意，只有在方法的形參中可使用int…來代替int[]。

2.2　調用帶有可變參數的方法
sum1()和sum2()兩個方法的調用：
sum1(new int[]{1,2,3});
sum2(new int[]{1,2,3});

這看起來沒什麼區別！可是對於sum2還有另外一種調用方式：
sum2();
sum2(1);
sum2(1,2);
sum2(1,2,3);

　　這看起來好像是使用任意多個參數來調用sum2()方法，這就是調用帶有可變參數方法的好處了。

2.3　編譯器「二次加工」
編譯器對sum2方法定義的「二次加工」結果爲：
public int sum2(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}

即把「int…」修改成「int[]」類型。
編譯器對sum2方法調用的二次加載結果爲：
sum2(new int[0]);
sum2(new int[] {1});
sum2(new int[] {1, 2});
sum2(new int[] {1, 2, 3});

結論：可變參數其實就是數組類型，只不過在調用方法時方便一些，由編譯器幫咱們把多個實參放到一個數組中傳遞給形參。

2.4　可變參數方法的限制
 一個方法最多隻能有一個可變參數；
 可變參數必須是方法的最後一個參數。

3　加強for循環
加強for循環是for的一種新用法！用來循環遍歷數組和集合。

3.1　加強for的語法
for(元素類型 e : 數組或集合對象) {
}
例如：
int[] arr = {1,2,3};
for(int i : arr) {
System.out.println(i);
}
　　加強for的冒號左邊是定義變量，右邊必須是數組或集合類型。例如上例中循環遍歷的主濁arr這個int數組，加強for內部會依次把arr中的元素賦給變量i。

3.2　加強for的優缺點
 只能從頭至尾的遍歷數組或集合，而不能只遍歷部分；
 在遍歷List或數組時，不能獲取當前元素下標；
 加強for使用便簡單，這是它惟一的優勢了；
 加強for比使用迭代器方便一點！

3.3　加強for原理
其實加強for內部是使用迭代器完成的！也就是說，任何實現了Iterable接口的對象均可以被加強for循環遍歷！這也是爲何加強for能夠循環遍歷集合的緣由（Collection是Iterable的子接口）。
但要注意，Map並無實現Iterable接口，因此你不能直接使用加強for來遍歷它！
Map<String, String> map = new HashMap<String,String>();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");

for(String key : map.keySet() ) {
        String value = map.get(key);
        System.out.println(key + "=" + value);
    }

泛型

1　泛型概述
泛型是JDK5.0新特性，它主要應用在集合類上。有了泛型以後，集合類與數組就愈來愈像了。例如：Object[] objs = new Object[10]，能夠用來存儲任何類型的對象。String[] strs = new String[10]只能用來存儲String類型的對象。
ArrayList list = new ArrayList()，能夠用來存儲任何類型的對象。ArrayList list = new ArrayList ()只有用來存儲String類型的對象。
1.1　理解泛型類
泛型類具備一到多個泛型變量，在建立泛型類對象時，須要爲泛型變量指定值。泛型變量只能賦值爲引用類型，而不能是基本類型。例如ArrayList類中有一個泛型變量E，在建立ArrayList類的對象時須要爲E這個泛型變量指定值。
list list = new ArrayList ();，
其中String就是給List的泛型變量E賦值了。查閱ArrayList的API你會知道，泛型變量E出如今不少方法中：
boolean add(E e)
E get(int index)
由於咱們在建立list對象時給泛型類型賦值爲String，因此對於list對象而言，全部API中的E都會被String替換。
boolean add(String e)
String get(int index)
也就是說，在使用list.add()時，只能傳遞String類型的參數，而list.get()方法返回的必定是String類型。
list.add(「hello」);
String s = list.get(0);

1.2　使用泛型對象
建立泛型對象時，引用和new兩端的泛型類型須要一致，例如上面的引用是List ，而new一端是new ArrayList ，兩端都是String類型！若是不一致就會出錯：
List