1、myeclipse的安裝和使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
* eclipse：是一個免費的開發工具* myeclipse：是一個收費的插件，破解myeclipse，** 安裝目錄的要求： 不能有中文和空格** 安裝完成之后，選擇一個工作空間 ，這個工作空間不能有中文和空格* 破解myeclipse** 運行run.bat文件，但是運行之前，必須要安裝jdk，通過配置環境變量* myeclipse的使用* 創建一個工程 - 類型 java project web project- 選擇依賴的jdk，可以使用myeclipse自帶的jdk，或者可以使用安裝的jdk* 創建包 package- cn.itcast.test XX.XX.XX* 在包里面創建一個類- 類的命名規范：** 首字母要大寫比如： TestDemo1 UserManager* 在類里面創建方法public void test1(參數列表) {方法體或者返回值;} - 方法的命名規范首字母小寫 比如：addNum()* 定義變量- 變量的命名規范** 首字母小寫，第二個單詞的首字母要大寫 ，比如 userName* 這些命名還有一種方式** 使用漢語拼音命名 yonghuming mima** 不能把漢語拼音和英文字母混合使用userMing* 命名的最基本的原則：看到名字知道是什么含義* 代碼需要有縮進* 運行程序 run as java applicationdebug as java application |
2、debug的調試模式（斷點調試模式）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
* 使用這種模式，調試程序（看到程序里面數據的變化）* 使用debug第一步需要設置一個斷點（讓程序運行停止在這一行）- 顯示出來行號- 雙擊左邊，出現一個圓點，表示設置了一個斷點* 使用debug as方式，運行程序- 提示是否進入到調試界面，yes- 在斷點那一個，有一個綠色條，表示程序停止在這一行，沒有向下運行* 可以讓程序向下執行，- 使用 step over 快捷鍵是 F6（單步執行）- resume F8：表示調試結束，直接向下運行** 比如當前的斷點之后還有斷點，跳到下一個斷點，** 如果當前斷點后面沒有斷點，程序直接運行結束* debug另外一個用途** 查看程序的源代碼** F5 step into：進入到方法** F7 step return :返回 |
3、myeclipse的快捷鍵的使用
|
1
2
3
4
5
6
7
|
* 代碼提示 alt /* 快速導包 ctrl shift o* 單行注釋 ctrl /* 去掉單行注釋 ctrl /* 多行注釋 ctrl shift /* 去掉多行注釋 ctrl shift \* 刪除行 ctrl d |
4、junit的使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
* 單元測試* 測試對象是 是一個類中的方法* juint不是javase的一部分，想要使用導入jar包** 但是，在myeclipse中自帶了junit的jar包* 首先junit版本 3.x 4.x* 單元測試方法時候，方法命名規則 public void 方法名() {}* 使用注解方式運行測試方法, 在方法的上面** @Test：表示方法進行單元測試--- @Testpublic void testAdd1() {TestJunit test01 = new TestJunit();test01.testAdd(2, 3);}- 選中方法名稱，右鍵運行 點擊run as --- junit test- 當出現綠色條，表示方法測試通過- 當出現了紅棕色條，表示方法測試不通過--- 要運行類中的多個測試方法，點擊類中的其他位置，run as --- junit test** @Ignore ：表示這個方法不進行單元測試** @Before: 在每個方法執行運行** @After：在每個方法之后運行** 斷言（了解）- Assert.assertEquals("測試期望的值", "方法運行的實際的值")jdk5.0新特性jdk 1.1 1.2 1.4 5.0** 泛型、枚舉、靜態導入、自動拆裝箱、增強for、可變參數** 反射 |
5、泛型的簡介
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
* 為什么要使用泛型？- 一般使用在集合上** 比如現在把一個字符串類型的值放入到集合里面，這個時候，這個值放入到集合之后，失去本事的類型，只能是object類型，這個時候，比如想要對這個值進行類型轉換，很容易出現類型轉換錯誤，怎么解決這個問題，可以使用泛型來解決* 在集合上如何使用泛型- 常用集合 list set map- 泛型語法 集合<String> 比如 List<String>* 在泛型里面寫是一個對象，String 不能寫基本的數據類型 比如int (****)** 寫基本的數據類型對應包裝類byte -- Byteshort -- Shortint -- Integerlong -- Longfloat -- Floatdouble -- Doublechar -- Characterboolean -- Boolean* 在list上使用泛型list的三種實現 ArrayList linkedList Vector代碼：@Testpublic void testList() {List<String> list = new ArrayList<String>();list.add("aaa");list.add("bbb");list.add("ccc");//遍歷list集合 有幾種方式 三種//普通for循環 迭代器 增強for//普通for循環for(int i=0;i<list.size();i++) {String s = list.get(i);System.out.println(s);}System.out.println("=================");//使用增強forfor (String s1 : list) {System.out.println(s1);}System.out.println("=================");//使用迭代器遍歷Iterator<String> it = list.iterator();while(it.hasNext()) {System.out.println(it.next());}* 作業1： ArrayList linkedList Vector 這三個區別* 在set上使用泛型代碼：//泛型使用set集合上@Testpublic 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上使用泛型@Testpublic 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的關系//使用第一種方式遍歷//獲取所有的keySet<String> sets = map.keySet();//遍歷所有key返回的setfor (String key : sets) {//通過key得到valueString value = map.get(key);System.out.println(key+" : "+value);}System.out.println("==============");//得到key和value的關系Set<Entry<String, String>> sets1 = map.entrySet();//遍歷sets1for (Entry<String, String> entry : sets1) {//entry是key和value關系String keyv = entry.getKey();String valuev = entry.getValue();System.out.println(keyv+" : "+valuev);}} |
6、泛型使用在方法上
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
* 定義一個數組，實現指定位置上數組元素的交換* 方法邏輯相同，只是數據類型不同，這個時候使用泛型方法* /** 使用泛型方法 需要定義一個類型 使用大寫字母表示 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;}** 作業2： 實現一個泛型方法，接受任意一個數組，顛倒數組中所有元素 |
7、泛型在類上的使用（了解）
|
1
2
3
4
5
6
7
8
|
* 在一個類上定義一個類型，這個類型可以在類里面直接使用* public class TestDemo04<T> {//在類里面可以直接使用T的類型T aa;public void test11(T bb) {}//寫一個靜態方法 在類上面定義的泛型，不能再靜態方法里面使用public static <A> void test12(A cc) {}} |
8、枚舉的簡介
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
* 什么是枚舉？** 需要在一定的范圍內取值，這個值只能是這個范圍內中的任意一個。** 現實場景：交通信號燈，有三種顏色，但是每次只能亮三種顏色里面的任意一個* 使用一個關鍵字 enum** enum Color3 {RED,GREEN,YELLOW;}* 枚舉的構造方法也是私有的* 特殊枚舉的操作（了解）** 在枚舉類里面有構造方法** 構造方法里面有參數，需要在每個實例上面都寫參數** 在枚舉類里面有抽象方法** 在枚舉的每個實例里面都重寫這個抽象方法 |
9、枚舉的api的操作
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
** name() ：返回枚舉的名稱** ordinal() ：枚舉的下標，下標從0開始** valueOf(Class<T> enumType, String name) ：得到枚舉的對象** 還有兩個方法，都是這兩個方法不在api里面，編譯的時候生成兩個方法*** valueof(String name) 轉換枚舉對象*** values() 獲得所有枚舉對象數組* 練習：枚舉對象、枚舉對象下標、枚舉對象名稱表示之間的轉換- //知道枚舉的對象，得到枚舉名稱和下標@Testpublic void test1() {//得到枚舉對象Color100 c100 = Color100.RED;//枚舉名稱String name = c100.name();//枚舉的下標int idx = c100.ordinal();System.out.println(name+" "+idx);}- //知道枚舉的名稱，得到枚舉的對象和下標@Testpublic void test2() {String name1 = "GREEN";//得到對象Color100 c1 = Color100.valueOf(name1);//枚舉下標int idx1 = c1.ordinal();System.out.println(idx1);}- //知道枚舉的下標，得到枚舉的對象和名稱@Testpublic void test3() {int idx2 = 2;//得到枚舉的對象Color100[] cs = Color100.values();//根據下標得到對象Color100 c12 = cs[idx2];//得到枚舉的名稱String name = c12.name();System.out.println(name);} |
10、靜態導入(了解)
|
1
2
3
4
5
|
* 可以在代碼里面，直接使用靜態導入方式，導入靜態方法或者常量* import static XX.XX.xxx* import static java.lang.System.out;import static java.util.Arrays.sort;** 比如現在實現一個計算器 在Math類里面 |
11、自動拆裝箱
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
* 裝箱** 把基本的數據類型轉換成包裝類* 拆箱** 把包裝類轉換成基本的數據類型** //自動裝箱Integer i = 10;//自動拆箱int m = i;** 在jdk1.4里面如何實現裝箱和拆箱- //在jdk1.4里面實現拆裝箱public void test1() {//裝箱Integer m = new Integer(10); //拆箱 int a = m.intValue();}** jdk是會向下兼容- 比如 jdk1.4里面寫的代碼，這個時候到5.0里面也可以運行** 練習：向下兼容== 執行的結果是會調用 doSomething(double m)== 首先在jdk1.4里面肯定調用這個方法，如果調用下面的方法，需要類型轉換，但是jdk1.4不能實現自動拆裝箱== 由于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.....");}** 記住：八種基本的數據類型對應的包裝類* int --- Integer* char--- Character |
12、增強for循環（*****）
|
1
2
3
4
5
6
7
8
9
10
|
* 語法 for(遍歷出來的值 : 要遍歷的集合) {}- for(String s : list) {System.out.println(s);}* 使用場景： 數組；實現Iterable接口的集合 可以使用增強for循環* 在集合上使用增強for循環遍歷list set 實現了Iterator接口，所以可以使用增強for循環map不能使用增強for循環，沒有實現Iterator接口，所以不能使用增強for循環* 增強for循環出現目的：為了替代迭代器** 增強for底層就是迭代器實現的 |
13、內容補充
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
（1）泛型擦除* 首先泛型只是出現在源代碼階段，當編譯之后泛型不存在了（2）練習：實現一個泛型方法，接受任意類型的數組，顛倒數組中所有元素代碼public static <T> void reverses(T[] arr1) {/** 基本思想：把第一個元素和最后一個元素交換位置，把第二個元素和倒數第二個元素交換位置。。。。* 交換 長度/2* *///遍歷數組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;}} |
14、可變參數
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
* 可變參數可以應用在什么場景：** 實現兩個數的相加，實現三個數的相加 四個數的相加-- 如果實現的多個方法，這些方法里面邏輯基本相同，唯一不同的是傳遞的參數的個數，可以使用可變參數* 可變參數的定義方法 數據類型...數組的名稱* 理解為一個數組，這個數組存儲傳遞過來的參數- 代碼public static void add1(int...nums) {//nums理解為一個數組，這個數組存儲傳遞過來的參數//System.out.println(nums.length);int sum = 0;//遍歷數組for(int i=0;i<nums.length;i++) {sum += nums[i];}System.out.println(sum);}* 注意的地方（1）可變參數需要寫在方法的參數列表中，不能單獨定義（2）在方法的參數列表中只能有一個可變參數（3）方法的參數列表中的可變參數，必須放在參數最后- add1(int a,int...nums) |
15、反射的原理（********理解********）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
* 應用在一些通用性比較高的代碼 中* 后面學到的框架，大多數都是使用反射來實現的* 在框架開發中，都是基于配置文件開發** 在配置文件中配置了類，可以通過反射得到類中的 所有內容，可以讓類中的某個方法來執行* 類中的所有內容：屬性、沒有參數的構造方法、有參數的構造方法、普通方法* 畫圖分析反射的原理* 首先需要把java文件保存到本地硬盤 .java* 編譯java文件，成.class文件* 使用jvm，把class文件通過類加載加載到內存中* 萬事萬物都是對象，class文件在內存中使用Class類表示* 當使用反射時候，首先需要獲取到Class類，得到了這個類之后，就可以得到class文件里面的所有內容- 包含屬性 構造方法 普通方法* 屬性通過一個類 Filed* 構造方法通過一個類 Constructor* 普通方法通過一個類 Method |
16、使用反射操作類里面的無參數的構造方法（**會寫**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
* 首先獲取到Class類- // 獲取Class類Class clazz1 = Person.class;Class clazz2 = new Person().getClass();Class clazz3 = Class.forName("cn.itcast.test09.Person");* 比如： 要對一個類進行實例化，可以new，不使用new，怎么獲??？- //得到ClassClass c3 = Class.forName("cn.itcast.test09.Person");//得到Person類的實例Person p = (Person) c3.newInstance();* 代碼//操作無參數的構造方法@Testpublic void test1() throws Exception {//得到ClassClass c3 = Class.forName("cn.itcast.test09.Person");//得到Person類的實例Person p = (Person) c3.newInstance();//設置值p.setName("zhangsan");System.out.println(p.getName());} |
17、使用反射操作有參數的構造方法（**會寫**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//操作有參數的構造方法@Testpublic void test2() throws Exception {//得到ClassClass c1 = Class.forName("cn.itcast.test09.Person");//使用有參數的構造方法//c1.getConstructors();//獲取所有的構造方法//傳遞是有參數的構造方法里面參數類型，類型使用class形式傳遞Constructor cs = c1.getConstructor(String.class,String.class);//通過有參數的構造方法設置值//通過有參數的構造方法創建Person實例Person p1 = (Person) cs.newInstance("lisi","100");System.out.println(p1.getId()+" "+p1.getName());} |
18、使用反射操作屬性（**會寫**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
* //操作name屬性@Testpublic void test3() {try {//得到Class類Class c2 = Class.forName("cn.itcast.test09.Person");//得到name屬性//c2.getDeclaredFields();//表示得到所有的屬性//得到Person類的實例Person p11 = (Person) c2.newInstance();//通過這個方法得到屬性，參數是屬性的名稱Field f1 = c2.getDeclaredField("name");//操作的是私有的屬性，不讓操作，需要設置可以操作私有屬性setAccessible(true),可以操作私有屬性f1.setAccessible(true);//設置name值 set方法，兩個參數：第一個參數類的實例，第二個參數是設置的值f1.set(p11, "wangwu"); //相當于 在 p.name = "wangwu";System.out.println(f1.get(p11)); //相當于 p.name}catch(Exception e) {e.printStackTrace();}} |
19、使用泛型操作普通方法（**會寫**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
* 使用Method類表示普通方法* 代碼//操作普通方法 ，比如操作 setName@Testpublic void test4() throws Exception {//得到Class類Class c4 = Class.forName("cn.itcast.test09.Person");//得到Person實例Person p4 = (Person) c4.newInstance();//得到普通方法//c4.getDeclaredMethods();//得到所有的普通方法//傳遞兩個參數：第一個參數，方法名稱；第二個參數，方法里面參數的類型Method m1 = c4.getDeclaredMethod("setName", String.class);//讓setName方法執行 ，執行設置值//使用invoke(p4, "niuqi");傳遞兩個參數：第一個參數，person實例；第二個參數，設置的值//執行了invoke方法之后，相當于，執行了setName方法，同時通過這個方法設置了一個值是niuqim1.invoke(p4, "niuqi");System.out.println(p4.getName());}* //操作的私有的方法 ，需要設置值是true* //m1.setAccessible(true);* 當操作的方法是靜態的方法時候，因為靜態方法調用方式是 類名.方法名，不需要類的實例* 使用反射操作靜態方式時候，也是不需要實例* 在invokie方法的第一個參數里面，寫一個 null- m1.invoke(null, "niuqi"); |
以上所述是小編給大家介紹的JavaWeb基礎教程之Java基礎加強版，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
