JavaWeb基本教程之Java基本增強版。本站提示廣大學習愛好者：（JavaWeb基本教程之Java基本增強版）文章只能為提供參考，不一定能成為您想要的結果。以下是JavaWeb基本教程之Java基本增強版正文
1、myeclipse的裝置和應用
* 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 application
debug as java application
2、debug的調試形式（斷點調試形式）
* 應用這類形式，調試法式（看到法式外面數據的變更） * 應用debug第一步須要設置一個斷點（讓法式運轉停滯在這一行） - 顯示出來行號 - 雙擊右邊，湧現一個圓點，表現設置了一個斷點 * 應用debug as方法，運轉法式 - 提醒能否進入到調試界面，yes - 在斷點那一個，有一個綠色條，表現法式停滯在這一行，沒有向下運轉 * 可讓法式向下履行， - 應用 step over 快捷鍵是 F6（單步履行） - resume F8：表現調試停止，直接向下運轉 ** 好比以後的斷點以後還有斷點，跳到下一個斷點， ** 假如以後斷點前面沒有斷點，法式直接運轉停止 * debug別的一個用處 ** 檢查法式的源代碼 ** F5 step into：進入到辦法 ** F7 step return :前往
3、myeclipse的快捷鍵的應用
* 代碼提醒 alt / * 疾速導包 ctrl shift o * 單行正文 ctrl / * 去失落單行正文 ctrl / * 多行正文 ctrl shift / * 去失落多行正文 ctrl shift \ * 刪除行 ctrl d
4、junit的應用
* 單位測試
* 測試對象是 是一個類中的辦法
* juint不是javase的一部門，想要應用導入jar包
** 然則，在myeclipse中自帶了junit的jar包
* 起首junit版本 3.x 4.x
* 單位測試辦法時刻，辦法定名規矩 public void 辦法名() {}
* 應用注解方法運轉測試辦法, 在辦法的下面
** @Test：表現辦法停止單位測試
--- @Test
public 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、泛型的簡介
* 為何要應用泛型？
- 普通應用在聚集上
** 好比如今把一個字符串類型的值放入到聚集外面，這個時刻，這個值放入到聚集以後，掉去本領的類型，只能是object類型，
這個時刻，好比想要對這個值停止類型轉換，很輕易湧現類型轉換毛病，怎樣處理這個成績，可使用泛型來處理
* 在聚集上若何應用泛型
- 經常使用聚集 list set map
- 泛型語法 聚集<String> 好比 List<String>
* 在泛型外面寫是一個對象，String 不克不及寫根本的數據類型 好比int (****)
** 寫根本的數據類型對應包裝類
byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char -- Character
boolean -- Boolean
* 在list上應用泛型
list的三種完成 ArrayList linkedList Vector
代碼：
@Test
public 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("=================");
//應用加強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());
}
* 功課1： ArrayList linkedList Vector 這三個差別
* 在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);
}
}
6、泛型應用在辦法上
* 界說一個數組，完成指定地位上數組元素的交流
* 辦法邏輯雷同，只是數據類型分歧，這個時刻應用泛型辦法
* /*
* 應用泛型辦法 須要界說一個類型 應用年夜寫字母表現 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、泛型在類上的應用（懂得）
* 在一個類上界說一個類型，這個類型可以在類外面直接應用
* public class TestDemo04<T> {
//在類外面可以直接應用T的類型
T aa;
public void test11(T bb) {}
//寫一個靜態辦法 在類下面界說的泛型，不克不及再靜態辦法外面應用
public static <A> void test12(A cc) {}
}
8、列舉的簡介
* 甚麼是列舉？
** 須要在必定的規模內取值，這個值只能是這個規模內裡的隨意率性一個。
** 實際場景：交通訊號燈，有三種色彩，然則每次只能亮三種色彩外面的隨意率性一個
* 應用一個症結字 enum
** enum Color3 {
RED,GREEN,YELLOW;
}
* 列舉的結構辦法也是公有的
* 特別列舉的操作（懂得）
** 在列舉類外面有結構辦法
** 結構辦法外面有參數，須要在每一個實例下面都寫參數
** 在列舉類外面有籠統辦法
** 在列舉的每一個實例外面都重寫這個籠統辦法
9、列舉的api的操作
** name() ：前往列舉的稱號
** ordinal() ：列舉的下標，下標從0開端
** valueOf(Class<T> enumType, String name) ：獲得列舉的對象
** 還有兩個辦法，都是這兩個辦法不在api外面，編譯的時刻生成兩個辦法
*** valueof(String name) 轉換列舉對象
*** values() 取得一切列舉對象數組
* 演習：列舉對象、列舉對象下標、列舉對象稱號表現之間的轉換
- //曉得列舉的對象，獲得列舉稱號和下標
@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();
//依據下標獲得對象
Color100 c12 = cs[idx2];
//獲得列舉的稱號
String name = c12.name();
System.out.println(name);
}
10、靜態導入(懂得)
* 可以在代碼外面，直接應用靜態導入方法，導入靜態辦法或許常量 * import static XX.XX.xxx * import static java.lang.System.out; import static java.util.Arrays.sort; ** 好比如今完成一個盤算器 在Math類外面
11、主動拆裝箱
* 裝箱
** 把根本的數據類型轉換成包裝類
* 拆箱
** 把包裝類轉換成根本的數據類型
** //主動裝箱
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輪回（*****）
* 語法 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）演習：完成一個泛型辦法，接收隨意率性類型的數組，倒置數組中一切元素
代碼
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、可變參數
* 可變參數可以運用在甚麼場景：
** 完成兩個數的相加，完成三個數的相加 四個數的相加
-- 假如完成的多個辦法，這些辦法外面邏輯根本雷同，獨一分歧的是傳遞的參數的個數，可使用可變參數
* 可變參數的界說辦法 數據類型...數組的稱號
* 懂得為一個數組，這個數組存儲傳遞過去的參數
- 代碼
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、反射的道理（********懂得********）
* 運用在一些通用性比擬高的代碼 中 * 前面學到的框架，年夜多半都是應用反射來完成的 * 在框架開辟中，都是基於設置裝備擺設文件開辟 ** 在設置裝備擺設文件中設置裝備擺設了類，可以經由過程反射獲得類中的 一切內容，可讓類中的某個辦法來履行 * 類中的一切內容：屬性、沒有參數的結構辦法、有參數的結構辦法、通俗辦法 * 繪圖剖析反射的道理 * 起首須要把java文件保留到當地硬盤 .java * 編譯java文件，成.class文件 * 應用jvm，把class文件經由過程類加載加載到內存中 * 萬事萬物都是對象，class文件在內存中應用Class類表現 * 當應用反射時刻，起首須要獲得到Class類，獲得了這個類以後，便可以獲得class文件外面的一切內容 - 包括屬性 結構辦法 通俗辦法 * 屬性經由過程一個類 Filed * 結構辦法經由過程一個類 Constructor * 通俗辦法經由過程一個類 Method
16、應用反射操作類外面的無參數的結構辦法（**會寫**）
* 起首獲得到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();
* 代碼
//操作無參數的結構辦法
@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());
}
17、應用反射操作有參數的結構辦法（**會寫**）
//操作有參數的結構辦法
@Test
public void test2() throws Exception {
//獲得Class
Class 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、應用反射操作屬性（**會寫**）
* //操作name屬性
@Test
public 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、應用泛型操作通俗辦法（**會寫**）
* 應用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();//獲得一切的通俗辦法
//傳遞兩個參數：第一個參數，辦法稱號；第二個參數，辦法外面參數的類型
Method m1 = c4.getDeclaredMethod("setName", String.class);
//讓setName辦法履行 ，履行設置值
//應用invoke(p4, "niuqi");傳遞兩個參數：第一個參數，person實例；第二個參數，設置的值
//履行了invoke辦法以後，相當於，履行了setName辦法，同時經由過程這個辦法設置了一個值是niuqi
m1.invoke(p4, "niuqi");
System.out.println(p4.getName());
}
* //操作的公有的辦法 ，須要設置值是true
* //m1.setAccessible(true);
* 當操作的辦法是靜態的辦法時刻，由於靜態辦法挪用方法是 類名.辦法名，不須要類的實例
* 應用反射操作靜態方法時刻，也是不須要實例
* 在invokie辦法的第一個參數外面，寫一個 null
- m1.invoke(null, "niuqi");
以上所述是小編給年夜家引見的JavaWeb基本教程之Java基本增強版，願望對年夜家有所贊助，假如年夜家有任何疑問請給我留言，小編會實時答復年夜家的。在此也異常感激年夜家對網站的支撐！
