* eclipse：是一個免費的開發(fā)工具
* myeclipse：是一個收費的插件，破解myeclipse，
** 安裝目錄的要求： 不能有中文和空格
** 安裝完成之后，選擇一個工作空間 ，這個工作空間不能有中文和空格
* 破解myeclipse
** 運行run.bat文件，但是運行之前，必須要安裝jdk，通過配置環(huán)境變量
* myeclipse的使用
* 創(chuàng)建一個工程 
- 類型 java project web project
- 選擇依賴的jdk，可以使用myeclipse自帶的jdk，或者可以使用安裝的jdk
* 創(chuàng)建包 package
- cn.itcast.test XX.XX.XX
* 在包里面創(chuàng)建一個類
- 類的命名規(guī)范：
** 首字母要大寫
比如： TestDemo1 UserManager
* 在類里面創(chuàng)建方法
public void test1(參數(shù)列表) {
方法體或者返回值;
} 
- 方法的命名規(guī)范
首字母小寫 比如：addNum()
* 定義變量
- 變量的命名規(guī)范
** 首字母小寫，第二個單詞的首字母要大寫 ，比如 userName
* 這些命名還有一種方式
** 使用漢語拼音命名 yonghuming mima
** 不能把漢語拼音和英文字母混合使用
userMing
* 命名的最基本的原則：看到名字知道是什么含義
* 代碼需要有縮進
* 運行程序 run as java application
debug as java application

* 使用這種模式，調試程序（看到程序里面數(shù)據(jù)的變化）
* 使用debug第一步需要設置一個斷點（讓程序運行停止在這一行）
- 顯示出來行號
- 雙擊左邊，出現(xiàn)一個圓點，表示設置了一個斷點
* 使用debug as方式，運行程序
- 提示是否進入到調試界面，yes
- 在斷點那一個，有一個綠色條，表示程序停止在這一行，沒有向下運行
* 可以讓程序向下執(zhí)行，
- 使用 step over 快捷鍵是 F6（單步執(zhí)行）
- resume F8：表示調試結束，直接向下運行
** 比如當前的斷點之后還有斷點，跳到下一個斷點，
**　如果當前斷點后面沒有斷點，程序直接運行結束
* debug另外一個用途
** 查看程序的源代碼
** F5 step into：進入到方法
** F7 step return :返回

* 代碼提示 alt /
* 快速導包 ctrl shift o
* 單行注釋 ctrl /
* 去掉單行注釋 ctrl /
* 多行注釋 ctrl shift /
* 去掉多行注釋 ctrl shift \
* 刪除行 ctrl d

* 單元測試
* 測試對象是 是一個類中的方法
* juint不是javase的一部分，想要使用導入jar包
** 但是，在myeclipse中自帶了junit的jar包
* 首先junit版本 3.x 4.x
* 單元測試方法時候，方法命名規(guī)則 public void 方法名() {}
* 使用注解方式運行測試方法, 在方法的上面
** @Test：表示方法進行單元測試
--- @Test
public void testAdd1() {
TestJunit test01 = new TestJunit();
test01.testAdd(2, 3);
}
- 選中方法名稱，右鍵運行 點擊run as --- junit test
- 當出現(xiàn)綠色條，表示方法測試通過
- 當出現(xiàn)了紅棕色條，表示方法測試不通過
--- 要運行類中的多個測試方法，點擊類中的其他位置，run as --- junit test
** @Ignore ：表示這個方法不進行單元測試
** @Before: 在每個方法執(zhí)行運行
** @After：在每個方法之后運行
** 斷言（了解）
- Assert.assertEquals("測試期望的值", "方法運行的實際的值")
jdk5.0新特性
jdk 1.1 1.2 1.4 5.0
** 泛型、枚舉、靜態(tài)導入、自動拆裝箱、增強for、可變參數(shù)
** 反射

* 為什么要使用泛型？
- 一般使用在集合上
** 比如現(xiàn)在把一個字符串類型的值放入到集合里面，這個時候，這個值放入到集合之后，失去本事的類型，只能是object類型，
這個時候，比如想要對這個值進行類型轉換，很容易出現(xiàn)類型轉換錯誤，怎么解決這個問題，可以使用泛型來解決
* 在集合上如何使用泛型
- 常用集合 list set map
- 泛型語法 集合<String> 比如 List<String>
* 在泛型里面寫是一個對象，String 不能寫基本的數(shù)據(jù)類型 比如int (****)
** 寫基本的數(shù)據(jù)類型對應包裝類
byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char -- Character
boolean -- Boolean
* 在list上使用泛型
list的三種實現(xiàn) ArrayList linkedList Vector
代碼：
@Test
public void testList() {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//遍歷list集合 有幾種方式 三種
//普通for循環(huán) 迭代器 增強for
//普通for循環(huán)
for(int i=0;i<list.size();i++) {
String s = list.get(i);
System.out.println(s);
}
System.out.println("=================");
//使用增強for
for (String s1 : list) {
System.out.println(s1);
}
System.out.println("=================");
//使用迭代器遍歷
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
* 作業(yè)1： ArrayList linkedList Vector 這三個區(qū)別
* 在set上使用泛型
代碼：
//泛型使用set集合上
@Test
public void testSet() {
Set<String> set = new HashSet<String>();
set.add("www");
set.add("qqq");
set.add("zzz");
//set.add("qqq");
//遍歷set 有幾種方式 兩種
//迭代器 增強for
//使用增強for遍歷
for (String s2 : set) {
System.out.println(s2);
}
System.out.println("=================");
//使用迭代器遍歷
Iterator<String> it1 = set.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
}
* 在map上面使用泛型
- map結構：key-valu形式
代碼：
//在map上使用泛型
@Test
public void testMap() {
Map<String,String> map = new HashMap<String,String>();
map.put("aaa", "111");
map.put("bbb", "222");
map.put("ccc", "333");
//遍歷map 有幾種遍歷方式 兩種
// 1、獲取所有的key，通過key得到value 使用get方法
// 2、獲取key和value的關系
//使用第一種方式遍歷
//獲取所有的key
Set<String> sets = map.keySet();
//遍歷所有key返回的set
for (String key : sets) {
//通過key得到value
String value = map.get(key);
System.out.println(key+" : "+value);
}
System.out.println("==============");
//得到key和value的關系
Set<Entry<String, String>> sets1 = map.entrySet();
//遍歷sets1
for (Entry<String, String> entry : sets1) {
//entry是key和value關系
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+" : "+valuev);
}
}

* 定義一個數(shù)組，實現(xiàn)指定位置上數(shù)組元素的交換
* 方法邏輯相同，只是數(shù)據(jù)類型不同，這個時候使用泛型方法
* /*
* 使用泛型方法 需要定義一個類型 使用大寫字母表示 T :這個T表示任意的類型
* 寫在返回值之前 void之前 <T>
* =======表示定義了一個類型 這個類型是 T
* 在下面就可以使用這個類型了 T
* */
public static <T> void swap1(T[] arr ,int a,int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
** 作業(yè)2： 實現(xiàn)一個泛型方法，接受任意一個數(shù)組，顛倒數(shù)組中所有元素

* 在一個類上定義一個類型，這個類型可以在類里面直接使用
* public class TestDemo04<T> {
//在類里面可以直接使用T的類型
T aa;
public void test11(T bb) {}
//寫一個靜態(tài)方法 在類上面定義的泛型，不能再靜態(tài)方法里面使用
public static <A> void test12(A cc) {}
}

* 什么是枚舉？
** 需要在一定的范圍內取值，這個值只能是這個范圍內中的任意一個。
** 現(xiàn)實場景：交通信號燈，有三種顏色，但是每次只能亮三種顏色里面的任意一個
* 使用一個關鍵字 enum
** enum Color3 {
RED,GREEN,YELLOW;
}
* 枚舉的構造方法也是私有的
* 特殊枚舉的操作（了解）
** 在枚舉類里面有構造方法
** 構造方法里面有參數(shù)，需要在每個實例上面都寫參數(shù)
** 在枚舉類里面有抽象方法
** 在枚舉的每個實例里面都重寫這個抽象方法

** name() ：返回枚舉的名稱
** ordinal() ：枚舉的下標，下標從0開始
** valueOf(Class<T> enumType, String name) ：得到枚舉的對象
** 還有兩個方法，都是這兩個方法不在api里面，編譯的時候生成兩個方法
*** valueof(String name) 轉換枚舉對象
*** values() 獲得所有枚舉對象數(shù)組
* 練習：枚舉對象、枚舉對象下標、枚舉對象名稱表示之間的轉換
- //知道枚舉的對象，得到枚舉名稱和下標
@Test
public void test1() {
//得到枚舉對象
Color100 c100 = Color100.RED;
//枚舉名稱
String name = c100.name();
//枚舉的下標
int idx = c100.ordinal();
System.out.println(name+" "+idx);
}
- //知道枚舉的名稱，得到枚舉的對象和下標
@Test
public void test2() {
String name1 = "GREEN";
//得到對象
Color100 c1 = Color100.valueOf(name1);
//枚舉下標
int idx1 = c1.ordinal();
System.out.println(idx1);
}
- //知道枚舉的下標，得到枚舉的對象和名稱
@Test
public void test3() {
int idx2 = 2;
//得到枚舉的對象
Color100[] cs = Color100.values();
//根據(jù)下標得到對象
Color100 c12 = cs[idx2];
//得到枚舉的名稱
String name = c12.name();
System.out.println(name);
}

* 可以在代碼里面，直接使用靜態(tài)導入方式，導入靜態(tài)方法或者常量
* import static XX.XX.xxx
* import static java.lang.System.out;
import static java.util.Arrays.sort;
** 比如現(xiàn)在實現(xiàn)一個計算器 在Math類里面

* 裝箱
** 把基本的數(shù)據(jù)類型轉換成包裝類
* 拆箱
** 把包裝類轉換成基本的數(shù)據(jù)類型
** //自動裝箱
Integer i = 10;
//自動拆箱
int m = i;
** 在jdk1.4里面如何實現(xiàn)裝箱和拆箱
- //在jdk1.4里面實現(xiàn)拆裝箱
public void test1() {
//裝箱
Integer m = new Integer(10); 
//拆箱 
int a = m.intValue();
}
** jdk是會向下兼容
- 比如 jdk1.4里面寫的代碼，這個時候到5.0里面也可以運行
** 練習：向下兼容
== 執(zhí)行的結果是會調用 doSomething(double m)
== 首先在jdk1.4里面肯定調用這個方法，如果調用下面的方法，需要類型轉換，但是jdk1.4不能實現(xiàn)自動拆裝箱
== 由于jdk是向下兼容，所以，在jdk1.4調用這個方法，在jdk5.0里面還是會調用這個方法
public static void main(String[] args) {
doSomething(10);
}
public static void doSomething(double m) {
System.out.println("double......");
}
public static void doSomething(Integer a){
System.out.println("integer.....");
}
** 記?。喊朔N基本的數(shù)據(jù)類型對應的包裝類
* int --- Integer
* char--- Character

* 語法 for(遍歷出來的值 : 要遍歷的集合) {}
- for(String s : list) {
System.out.println(s);
}
* 使用場景： 數(shù)組；實現(xiàn)Iterable接口的集合 可以使用增強for循環(huán)
* 在集合上使用增強for循環(huán)遍歷
list set 實現(xiàn)了Iterator接口，所以可以使用增強for循環(huán)
map不能使用增強for循環(huán)，沒有實現(xiàn)Iterator接口，所以不能使用增強for循環(huán)
* 增強for循環(huán)出現(xiàn)目的：為了替代迭代器
** 增強for底層就是迭代器實現(xiàn)的

（1）泛型擦除
* 首先泛型只是出現(xiàn)在源代碼階段，當編譯之后泛型不存在了
（2）練習：實現(xiàn)一個泛型方法，接受任意類型的數(shù)組，顛倒數(shù)組中所有元素
代碼
public static <T> void reverses(T[] arr1) {
/*
* 基本思想：把第一個元素和最后一個元素交換位置，把第二個元素和倒數(shù)第二個元素交換位置。。。。
* 交換 長度/2
* */
//遍歷數(shù)組
for(int i=0;i<arr1.length/2;i++) {
/*int temp = arr1[0];
arr1[0] = arr1[arr1.length-1];*/
T temp = arr1[i];
arr1[i] = arr1[arr1.length-i-1];
arr1[arr1.length-i-1] = temp;
}
}

* 可變參數(shù)可以應用在什么場景：
** 實現(xiàn)兩個數(shù)的相加，實現(xiàn)三個數(shù)的相加 四個數(shù)的相加
-- 如果實現(xiàn)的多個方法，這些方法里面邏輯基本相同，唯一不同的是傳遞的參數(shù)的個數(shù)，可以使用可變參數(shù)
* 可變參數(shù)的定義方法 數(shù)據(jù)類型...數(shù)組的名稱
* 理解為一個數(shù)組，這個數(shù)組存儲傳遞過來的參數(shù)
- 代碼
public static void add1(int...nums) {
//nums理解為一個數(shù)組，這個數(shù)組存儲傳遞過來的參數(shù)
//System.out.println(nums.length);
int sum = 0;
//遍歷數(shù)組
for(int i=0;i<nums.length;i++) {
sum += nums[i];
}
System.out.println(sum);
}
* 注意的地方
（1）可變參數(shù)需要寫在方法的參數(shù)列表中，不能單獨定義
（2）在方法的參數(shù)列表中只能有一個可變參數(shù)
（3）方法的參數(shù)列表中的可變參數(shù)，必須放在參數(shù)最后
- add1(int a,int...nums)

* 應用在一些通用性比較高的代碼 中
* 后面學到的框架，大多數(shù)都是使用反射來實現(xiàn)的
* 在框架開發(fā)中，都是基于配置文件開發(fā)
** 在配置文件中配置了類，可以通過反射得到類中的 所有內容，可以讓類中的某個方法來執(zhí)行
* 類中的所有內容：屬性、沒有參數(shù)的構造方法、有參數(shù)的構造方法、普通方法
* 畫圖分析反射的原理
* 首先需要把java文件保存到本地硬盤 .java
* 編譯java文件，成.class文件
* 使用jvm，把class文件通過類加載加載到內存中
* 萬事萬物都是對象，class文件在內存中使用Class類表示
* 當使用反射時候，首先需要獲取到Class類，得到了這個類之后，就可以得到class文件里面的所有內容
- 包含屬性 構造方法 普通方法
* 屬性通過一個類 Filed
* 構造方法通過一個類 Constructor
* 普通方法通過一個類 Method

* 首先獲取到Class類
- // 獲取Class類
Class clazz1 = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("cn.itcast.test09.Person");
* 比如： 要對一個類進行實例化，可以new，不使用new，怎么獲取？
- //得到Class
Class c3 = Class.forName("cn.itcast.test09.Person");
//得到Person類的實例
Person p = (Person) c3.newInstance();
* 代碼
//操作無參數(shù)的構造方法
@Test
public void test1() throws Exception {
//得到Class
Class c3 = Class.forName("cn.itcast.test09.Person");
//得到Person類的實例
Person p = (Person) c3.newInstance();
//設置值
p.setName("zhangsan");
System.out.println(p.getName());
}

//操作有參數(shù)的構造方法
@Test
public void test2() throws Exception {
//得到Class
Class c1 = Class.forName("cn.itcast.test09.Person");
//使用有參數(shù)的構造方法
//c1.getConstructors();//獲取所有的構造方法
//傳遞是有參數(shù)的構造方法里面參數(shù)類型，類型使用class形式傳遞
Constructor cs = c1.getConstructor(String.class,String.class);
//通過有參數(shù)的構造方法設置值
//通過有參數(shù)的構造方法創(chuàng)建Person實例
Person p1 = (Person) cs.newInstance("lisi","100");
System.out.println(p1.getId()+" "+p1.getName());
}

* //操作name屬性
@Test
public void test3() {
try {
//得到Class類
Class c2 = Class.forName("cn.itcast.test09.Person");
//得到name屬性
//c2.getDeclaredFields();//表示得到所有的屬性
//得到Person類的實例
Person p11 = (Person) c2.newInstance();
//通過這個方法得到屬性，參數(shù)是屬性的名稱
Field f1 = c2.getDeclaredField("name");
//操作的是私有的屬性，不讓操作，需要設置可以操作私有屬性setAccessible(true),可以操作私有屬性
f1.setAccessible(true);
//設置name值 set方法，兩個參數(shù)：第一個參數(shù)類的實例，第二個參數(shù)是設置的值
f1.set(p11, "wangwu"); //相當于 在 p.name = "wangwu";
System.out.println(f1.get(p11)); //相當于 p.name
}catch(Exception e) {
e.printStackTrace();
}
}

* 使用Method類表示普通方法
* 代碼
//操作普通方法 ，比如操作 setName
@Test
public void test4() throws Exception {
//得到Class類
Class c4 = Class.forName("cn.itcast.test09.Person");
//得到Person實例
Person p4 = (Person) c4.newInstance();
//得到普通方法
//c4.getDeclaredMethods();//得到所有的普通方法
//傳遞兩個參數(shù)：第一個參數(shù)，方法名稱；第二個參數(shù)，方法里面參數(shù)的類型
Method m1 = c4.getDeclaredMethod("setName", String.class);
//讓setName方法執(zhí)行 ，執(zhí)行設置值
//使用invoke(p4, "niuqi");傳遞兩個參數(shù)：第一個參數(shù)，person實例；第二個參數(shù)，設置的值
//執(zhí)行了invoke方法之后，相當于，執(zhí)行了setName方法，同時通過這個方法設置了一個值是niuqi
m1.invoke(p4, "niuqi");
System.out.println(p4.getName());
}
* //操作的私有的方法 ，需要設置值是true
* //m1.setAccessible(true);
* 當操作的方法是靜態(tài)的方法時候，因為靜態(tài)方法調用方式是 類名.方法名，不需要類的實例
* 使用反射操作靜態(tài)方式時候，也是不需要實例
* 在invokie方法的第一個參數(shù)里面，寫一個 null
- m1.invoke(null, "niuqi");