Java基礎加強
Java基礎加強html
二、debug的調試模式（斷點調試模式）
使用這種模式，調試程序（看到程序裏面數據的變化）api
使用debug第一步須要設置一個斷點（讓程序運行中止在這一行）
- 顯示出來行號
- 雙擊左邊，出現一個圓點，表示設置了一個斷點
使用debug as方式，運行程序
- 提示是否進入到調試界面，yes
- 在斷點那一個，有一個綠色條，表示程序中止在這一行，沒有向下運行數組
可讓程序向下執行，
- 使用 step over 快捷鍵是 F6（單步執行）
- resume F8：表示調試結束，直接向下運行
好比當前的斷點以後還有斷點，跳到下一個斷點，若是當前斷點後面沒有斷點，程序直接運行結束。
debug另一個用途
** 查看程序的源代碼
** F5 step into：進入到方法
** F7 step return :返回框架
三、junit的使用
單元測試 測試對象是 是一個類中的方法，juint不是javase的一部分，想要使用導入jar包，可是，在myeclipse中自帶了junit的jar包eclipse
* 首先juint版本 3.x 4.x
* 單元測試方法時候，方法命名規則 public void 方法名() {}
* 使用註解方式運行測試方法, 在方法的上面
** @Test：表示方法進行單元測試jvm
@Test
public void testAdd1() {
TestJunit test01 = new TestJunit();
test01.testAdd(2, 3);
}
- 選中方法名稱，右鍵運行 點擊run as --- junit test
- 當出現綠色條，表示方法測試經過
- 當出現了紅棕色條，表示方法測試不經過ide
--- 要運行類中的多個測試方法，點擊類中的其餘位置，run as --- junit test
** @Ignore ：表示這個方法不進行單元測試單元測試
** @Before: 在每一個方法執行運行
** @After：在每一個方法以後運行測試
** 斷言（瞭解）
- Assert.assertEquals("測試指望的值", "方法運行的實際的值")
JDK5.0新特性
jdk版本： 1.1 1.2 1.4 5.0
** 泛型、枚舉、靜態導入、自動拆裝箱、加強for、可變參數
** 反射
四、泛型的簡介
爲何要使用泛型？通常使用在集合上。
好比如今把一個字符串類型的值放入到集合裏面，這個時候，這個值放入到集合以後，失去自己的類型，只能是object類型，這個時候，好比想要對這個值進行類型轉換，很容易出現類型轉換錯誤，怎麼解決這個問題，可使用泛型來解決。
在集合上如何使用泛型
- 經常使用集合 list set map
- 泛型語法 集合<String> 好比 List<String>
在泛型裏面寫是一個對象，String 不能寫基本的數據類型 好比int (****)
* 基本的數據類型對應包裝類
在集合上使用泛型【list、set、map】
在list上使用泛型【list的三種實現 ArrayList linkedList Vector】
在set上使用泛型【特色：無序的遍歷、不能有重複元素】
在map上面使用泛型
- map結構：key-valu形式
e-code【TestDemo2.java集合上的泛型】
1 package boom.test03; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.HashSet; 6 import java.util.Iterator; 7 import java.util.List; 8 import java.util.Map; 9 import java.util.Map.Entry; 10 import java.util.Set; 11 12 import org.junit.Ignore; 13 import org.junit.Test; 14 15 /** 16 * 泛型在集合上使用 17 * @author Administrator 18 * 19 */ 20 public class TestDemo2 { 21 /** 22 * 三、泛型在map上使用 23 */ 24 @Test 25 public void testMap(){ 26 Map<String, String> map = new HashMap<String, String>(); 27 map.put("Java", "001"); 28 map.put("JavaScript", "002"); 29 map.put("Python", "003"); 30 // 遍歷map 31 /*遍歷方式*/ 32 // 一、獲取全部的key，經過key獲得value 使用get方法 33 // 獲取全部的key 34 Set<String> sets = map.keySet(); 35 // 遍歷全部的key返回set 36 for (String key : sets) { 37 // 經過key獲得value 38 String value = map.get(key); 39 System.out.println(key + ":" + value); 40 } 41 System.out.println("-----------"); 42 43 // 二、獲取key和value的關係*/ 44 Set<Entry<String, String>> set1 = map.entrySet(); 45 // 遍歷set1 46 for (Entry<String, String> entry : set1) { 47 // entry是key和value的關係 48 String key = entry.getKey(); 49 String value = entry.getValue(); 50 System.out.println(key+":"+value); 51 } 52 53 } 54 55 /** 56 * 二、泛型在set上的使用[特色：無序的遍歷、不能有重複元素] 57 */ 58 @Ignore 59 public void testSet(){ 60 Set<String> set = new HashSet<String>(); 61 set.add("Java"); 62 set.add("Python"); 63 set.add("JavaScript"); 64 // 遍歷set集合 [迭代器、加強for] 65 // 一、加強for 66 for (String s2 : set) { 67 System.out.println(s2); 68 } 69 System.out.println("---------------"); 70 71 // 二、迭代器 72 Iterator<String> it = set.iterator(); 73 while (it.hasNext()) { 74 System.out.println(it.next()); 75 } 76 77 } 78 79 /** 80 * 一、泛型在list上的使用 81 */ 82 @Ignore 83 public void testList(){ 84 List<String> list = new ArrayList<String>(); 85 list.add("小喜慶01"); 86 list.add("小喜慶02"); 87 list.add("小喜慶03"); 88 // 遍歷list集合[普通遍歷、迭代器遍歷、加強for] 89 // 一、 普通for 90 for (int i = 0; i < list.size(); i++) { 91 String s = list.get(i); 92 System.out.println(s); 93 } 94 System.out.println("-------------"); 95 96 // 二、 加強for 97 for (String s1 : list) { 98 System.out.println(s1); 99 } 100 System.out.println("-------------"); 101 102 // 三、迭代器 103 Iterator<String> it = list.iterator(); 104 while (it.hasNext()) { 105 System.out.println(it.next()); 106 } 107 108 } 109 110 }
五、泛型使用在方法上
方法邏輯相同，只是數據類型不一樣，這個時候使用泛型方法
* 使用泛型方法 須要定義一個類型 使用大寫字母表示 T :這個T表示任意的類型
* 寫在返回值以前 void以前 <T>，表示定義了一個類型 這個類型是 T，在下面就可使用這個類型了 T
e-code【TestDemo3.java】
1 package boom.test03; 2 3 import java.util.Arrays; 4 5 /** 6 * 泛型使用在方法上 7 * 定義一個數組，實現指定位置上數組元素的交換[11和13] 8 * @author Administrator 9 * 10 */ 11 public class TestDemo3 { 12 public static void main(String[] args) { 13 Integer[] arr1 = { 10, 11, 12, 13, 14, 15 }; 14 System.out.println("原始數據："+Arrays.toString(arr1)); 15 swap1(arr1,1,3); 16 System.out.println("轉換後數據:"+Arrays.toString(arr1)); 17 18 String[] arr2 = { "aa", "bb", "cc", "dd" }; 19 System.out.println("原始數據："+Arrays.toString(arr2)); 20 swap1(arr2,1,3); 21 System.out.println("轉換後數據："+Arrays.toString(arr2)); 22 23 } 24 /** 25 * 使用泛型方法 須要定義一個類型 使用大寫字母表示 T :這個T表示任意的類型 26 */ 27 public static <T> void swap1(T[] arr,int i,int j){ 28 T temp = arr[i]; 29 arr[i] = arr[j]; 30 arr[j] = temp; 31 } 32 33 /* private static void swap1(String[] arr2, int i, int j) { 34 String temp1 = arr2[i]; 35 arr2[i] = arr2[j]; 36 arr2[j] = temp1; 37 } 38 private static void swap1(int[] arr1, int i, int j) { 39 // 定義中間變量進行值得轉換 40 int temp = arr1[i]; 41 arr1[i] = arr1[j]; 42 arr1[j] = temp; 43 44 }*/ 45 46 }
六、泛型在類上的使用（瞭解）
e-code【TestDemo4.java】
七、枚舉的簡介
什麼是枚舉？
須要在必定的範圍內取值，這個值只能是這個範圍內中的任意一個。
現實場景：交通訊號燈，有三種顏色，可是每次只能亮三種顏色裏面的任意一個
* 使用一個關鍵字 enum
** enum Color3 {
RED,GREEN,YELLOW;
}
e-code【TestEnum1.java】
1 package boom.test04; 2 3 public class TestEnum1 { 4 // 傳統的方式 5 private int color; 6 7 // 第二種方式 8 private Color2 color1; 9 10 // 第三種方式JDK5.0新特性 枚舉 11 private Color3 color3; 12 13 public void test() { 14 this.color = Color1.RED; 15 this.color1 = Color2.RED; 16 this.color3 = Color3.RED; 17 } 18 } 19 // 使用枚舉 20 enum Color3{ 21 RED,GREEN,YELLOW; 22 } 23 class Color2 { 24 // 實用化構造方法 25 private Color2(){} 26 public static final Color2 RED = new Color2(); 27 public static final Color2 GREEN = new Color2(); 28 public static final Color2 YELLOW = new Color2(); 29 } 30 class Color1 { 31 public static final int RED = 1; 32 public static final int GREEN = 2; 33 public static final int YELLOW = 3; 34 }
* 枚舉的構造方法也是私有的
* 特殊枚舉的操做（瞭解）
** 在枚舉類裏面有構造方法
* 構造方法裏面有參數，須要在每一個實例上面都寫參數
** 在枚舉類裏面有抽象方法
* 在枚舉的每一個實例裏面都重寫這個抽象方法
八、枚舉的api的操做
** name() ：返回枚舉的名稱
** ordinal() ：枚舉的下標，下標從0開始
** valueOf(Class<T> enumType, String name) ：獲得枚舉的對象
** 還有兩個方法，都是這兩個方法不在api裏面，編譯的時候生成兩個方法
*** valueof(String name) 轉換枚舉對象
*** values() 得到全部枚舉對象數組
* 枚舉對象、枚舉對象下標、枚舉對象名稱表示之間的轉換
e-code【TestEnum2.java】
1 package boom.test04; 2 3 import org.junit.Test; 4 5 public class TestEnum2 { 6 // 三、經過枚舉的下標，獲得枚舉的對象和名稱 7 @Test 8 public void test3(){ 9 int idx = 2; 10 // 獲得枚舉的對象 11 Color[] cs = Color.values(); 12 // 根據下標獲得對象 13 Color c = cs[idx]; 14 // 獲得枚舉的名稱 15 String name = c.name(); 16 System.out.println(name); 17 18 } 19 // 二、經過枚舉的名稱，獲得枚舉的對象和下標 20 @Test 21 public void test2(){ 22 String name = "RED"; 23 // 獲得枚舉對象 24 Color c = Color.valueOf(name); 25 // 枚舉的下標 26 int idx = c.ordinal(); 27 System.out.println(idx); 28 } 29 // 一、經過枚舉對象，獲得枚舉名稱和下標 30 @Test 31 public void test1() { 32 // 獲得枚舉的對象 33 Color c = Color.GREEN; 34 // 獲得枚舉名稱 35 String name = c.name(); 36 // 獲得枚舉的下標 37 int idx = c.ordinal(); 38 System.out.println(name+":"+idx); 39 } 40 41 } 42 // 建立枚舉類 43 enum Color{ 44 RED,GREEN,YELLOW; 45 }
九、靜態導入(瞭解)
* 能夠在代碼裏面，直接使用靜態導入方式，導入靜態方法或者常量
* import static XX.XX.xxx
* import static java.lang.System.out;
import static java.util.Arrays.sort;
** 好比如今實現一個計算器 在Math類裏面
e-image
十、自動拆裝箱
裝箱： 把基本的數據類型轉換成包裝類
拆箱：把包裝類轉換成基本的數據類型
自動裝箱：Integer i = 10; 自動拆箱：int m = i;
- //在jdk1.4裏面實現拆裝箱
public void test1() {
//裝箱
Integer m = new Integer(10);
//拆箱
int a = m.intValue();
}
** jdk是會向下兼容
- 好比 jdk1.4裏面寫的代碼，這個時候到5.0裏面也能夠運行
e-code【TestDemo2.java】
1 package boom.test05; 2 3 public class TestDemo2 { 4 5 /**自動拆裝箱 6 * @param args 7 */ 8 public static void main(String[] args) { 9 Integer i =8; // 自動裝箱 10 int m= i; // 自動拆箱 11 doSomething(10);// 調用double m 12 13 } 14 public static void doSomething(double m){ 15 System.out.println("double......"); 16 } 17 public static void doSomething(Integer a){ 18 System.out.println("Integer......"); 19 } 20 }
a. 執行的結果是會調用 doSomething(double m)
b. 首先在jdk1.4裏面確定調用這個方法，若是調用下面的方法，須要類型轉換，可是jdk1.4不能實現自動拆裝箱
c. 因爲jdk是向下兼容，因此，在jdk1.4調用這個方法，在jdk5.0裏面仍是會調用這個方法
十一、加強for循環（*****）
語法 for(遍歷出來的值 : 要遍歷的集合) {}
- for(String s : list) {
System.out.println(s);
}
使用場景： 數組；實現Iterable接口的集合 可使用加強for循環
在集合上使用加強for循環遍歷
list set 實現了Iterator接口，因此可使用加強for循環
map不能使用加強for循環，沒有實現Iterator接口，因此不能使用加強for循環
加強for循環出現目的：爲了替代迭代器(底層就是迭代器實現的)
十二、內容補充
（1）泛型擦除
* 首先泛型只是出如今源代碼階段，當編譯以後泛型不存在了
（2）練習：實現一個泛型方法，接受任意類型的數組，顛倒數組中全部元素
e-code【TestDemo5.java】
1 package boom.test05; 2 3 import java.util.Arrays; 4 5 public class TestDemo5 { 6 7 /** 8 * 實現一個泛型方法，接受任意類型的數組，逆序數組中全部元素 9 * @param args 10 */ 11 public static void main(String[] args) { 12 Integer[] arr1 = {12,34,65,67,341,23}; 13 System.out.println("原始數據："+Arrays.toString(arr1)); 14 reverses(arr1); 15 System.out.println("交換數據："+Arrays.toString(arr1)); 16 17 System.out.println("--- 分割線 ---"); 18 19 String[] arr2 = {"a","b","c","d","e","f","g"}; 20 System.out.println("原始數據："+Arrays.toString(arr2)); 21 reverses(arr2); 22 System.out.println("交換數據："+Arrays.toString(arr2)); 23 24 25 } 26 27 public static <T> void reverses(T[] arr1) { 28 /** 29 * 基本思想：把第一個元素和最後一個元素交換位置，把第二個元素和倒數第二個元素交換位置 30 * 交換 長度/2 31 */ 32 // 遍歷數組 33 for(int i = 0;i<arr1.length/2;i++) { 34 /*int temp = arr[0]; 35 arr[0] = arr[arr.length-1];*/ 36 T temp = arr1[i]; 37 arr1[i] = arr1[arr1.length - i - 1]; 38 arr1[arr1.length - i - 1] = temp; 39 40 } 41 } 42 43 }
1三、可變參數
* 可變參數能夠應用在什麼場景：實現兩個數的相加，實現三個數的相加 四個數的相加.........
-- 若是實現的多個方法，這些方法裏面邏輯基本相同，惟一不一樣的是傳遞的參數的個數，可使用可變參數
* 可變參數的定義方法 數據類型...數組的名稱
* 理解爲一個數組，這個數組存儲傳遞過來的參數
e-code【TestDemo3.java】
1 package boom.test05; 2 3 public class TestDemo3 { 4 5 /** 6 * 可變參數 7 * 實現兩個數，三個數，四個數......相加 8 * @param args 9 */ 10 public static void main(String[] args) { 11 add(10,33); 12 add(10,33,45); 13 add(10,33,45,43); 14 add(10,33,45,43,34); 15 } 16 // 可變參數寫法 17 public static void add(int ...nums){ 18 // nums理解爲一個數組，這個數組存儲傳遞過來的參數 19 // 測試nums長度 20 // System.out.println(nums.length); 21 int sum = 0; 22 // 遍歷數組 23 for (int i = 0; i < nums.length; i++) { 24 sum += nums[i]; 25 } 26 System.out.println("sum=" + sum); 27 28 } 29 30 /*public void add(int a,int b){ 31 int sum = a+b; 32 System.out.println(sum); 33 } 34 public void add(int a,int b,int c){ 35 int sum = a+b+c; 36 System.out.println(sum); 37 } 38 public void add(int a,int b,int c,int d){ 39 int sum = a+b+c+d; 40 System.out.println(sum); 41 }*/ 42 43 }
* 注意的地方
（1）可變參數須要寫在方法的參數列表中，不能單獨定義
（2）在方法的參數列表中只能有一個可變參數
（3）方法的參數列表中的可變參數，必須放在參數最後
- add1(int a,int...nums)
1四、反射的原理（********理解********）
應用在一些通用性比較高的代碼中，後面學到的框架，大多數都是使用反射來實現的，在框架開發中，都是基於配置文件開發。
在配置文件中配置了類，能夠經過反射獲得類中的 全部內容，可讓類中的某個方法來執行，類中的全部內容：屬性、沒有參數的構造方法、有參數的構造方法、普通方法。
畫圖分析反射的原理
* 首先須要把java文件保存到本地硬盤 .java
* 編譯java文件，成.class文件
* 使用jvm，把class文件經過類加載器加載到內存中
* 萬事萬物都是對象，class文件在內存中使用Class類表示
* 當使用反射時候，首先須要獲取到Class類，獲得了這個類以後，就能夠獲得class文件裏面的全部內容
- 包含屬性 構造方法 普通方法
* 屬性經過一個類 Filed
* 構造方法經過一個類 Constructor
* 普通方法經過一個類 Method
1五、使用反射操做：屬性、沒有參數的構造方法、有參數的構造方法、普通方法的操做
* 首先獲取到Class類
- // 獲取Class類
Class clazz1 = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("所在類的包名+類名路");// 複製 選擇類名 ==> Copy Qualified Name
好比： 要對一個類進行實例化，能夠new。不使用new，怎麼獲取(反射)？
//獲得Class
Class class1 = Class.forName("boom.test06.Person");
// 獲得Person實例(須要強轉)
Person p = (Person) class1.newInstance();
// 設置值
e-code【Person.java】
1 package boom.test06; 2 3 public class Person { 4 private String name; 5 private String id; 6 7 // 無參構造方法 8 public Person(){ 9 10 } 11 // 有參的構造方法 12 public Person(String name, String id) { 13 super(); 14 this.name = name; 15 this.id = id; 16 } 17 // 普通方法 18 public String getName() { 19 return name; 20 } 21 public void setName(String name) { 22 this.name = name; 23 } 24 public String getId() { 25 return id; 26 } 27 public void setId(String id) { 28 this.id = id; 29 } 30 31 }
e-code【TestDemo1.java】
1 package boom.test06; 2 3 import java.lang.reflect.Constructor; 4 import java.lang.reflect.Field; 5 import java.lang.reflect.Method; 6 7 import org.junit.Test; 8 9 public class TestDemo1 { 10 public static void main(String[] args) throws Exception { 11 // 獲取Class(三種方式) 12 /*Class class1 = Person.class; 13 Class class2 = new Person().getClass(); 14 Class class3 = Class.forName("boom.test06.Person");*/ 15 16 } 17 18 19 // 四、操做普通方法 操做setName 20 @Test 21 public void test4() throws Exception{ 22 // 獲得Class類 23 Class class4 = Class.forName("boom.test06.Person"); 24 // 獲得Person實例 25 Person p4 = (Person) class4.newInstance(); 26 // 獲得普通方法 27 Method m1 = class4.getDeclaredMethod("setName", String.class); 28 // 執行setName,設置值 29 m1.invoke(p4, "小明"); 30 System.out.println(p4.getName()); 31 } 32 33 // 三、反射操做屬性 34 @Test 35 public void test3(){ 36 try { 37 // 獲得Class類 38 Class class3 = Class.forName("boom.test06.Person"); 39 // 獲得name屬性 40 // class3.getDeclaredFields();//表示獲得全部的屬性 41 42 // 獲得Person類的實例 43 Person p1 = (Person) class3.newInstance(); 44 // 經過這個方法獲得屬性，參數是屬性的名稱 45 Field f1 = class3.getDeclaredField("name"); 46 // 操做的是私有的屬性，不讓操做，須要設置能夠操做私有屬性setAccessible(true),能夠操做私有屬性 47 f1.setAccessible(true); 48 // 設置name值 set方法，兩個參數：第一個參數類的實例，第二個參數是設置的值 49 f1.set(p1, "wangwu"); // 至關於 在 p.name = "wangwu"; 50 System.out.println(f1.get(p1)); // 至關於 p.name 51 }catch(Exception e) { 52 e.printStackTrace(); 53 } 54 } 55 56 // 二、操做有參數構造方法 57 @Test 58 public void test2() throws Exception{ 59 // 獲得Class 60 Class class2 = Class.forName("boom.test06.Person"); 61 // 傳遞有參的構造方法裏面的參數類型，類型使用class形式想傳遞 62 Constructor cs = class2.getConstructor(String.class,String.class); 63 // 經過有參的構造方法設置值 64 // 經過有參數的構造方法建立Person實例 65 Person p1 = (Person) cs.newInstance("lisi","101"); 66 System.out.println(p1.getId()+" "+p1.getName()); 67 68 } 69 70 // 一、操做無參數構造方法 71 @Test 72 public void test1() throws Exception { 73 // 獲得Class 74 Class class1 = Class.forName("boom.test06.Person"); 75 // 獲得Person實例(須要強轉) 76 Person p = (Person) class1.newInstance(); 77 // 設置值 78 p.setName("小喜慶"); 79 p.setId("1001"); 80 System.out.println(p.getName()+" "+p.getId()); 81 82 } 83 }
- 1. Java基礎加強---枚舉
- 2. 基礎加強
- 3. c#基礎加強
- 4. Java基礎加強第四講 註解
- 5. Java基礎加強第五講 泛型
- 6. Java基礎之加強for循環
- 7. Java基礎——加強for循環（foreach）
- 8. 23、Java Web之基礎加強
- 9. java基礎加強_補充筆記
- 10. Java基礎增強
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • ☆基於Java Instrument的Agent實現
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 外部其他進程嵌入到qt FindWindow獲得窗口句柄 報錯無法鏈接的外部符號 [email protected] 無法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的應用-TOPK問題
- 6. 實例演示ElasticSearch索引查詢term,match,match_phase,query_string之間的區別
- 7. 數學基礎知識 集合
- 8. amazeUI 復擇框問題解決
- 9. 揹包問題理解
- 10. 算數平均-幾何平均不等式的證明,從麥克勞林到柯西
- 1. Java基礎加強---枚舉
- 2. 基礎加強
- 3. c#基礎加強
- 4. Java基礎加強第四講 註解
- 5. Java基礎加強第五講 泛型
- 6. Java基礎之加強for循環
- 7. Java基礎——加強for循環（foreach）
- 8. 23、Java Web之基礎加強
- 9. java基礎加強_補充筆記
- 10. Java基礎增強