javaweb筆記分享

時間 2019-11-13

標籤 javaweb 筆記分享欄目 Java 简体版

原文原文鏈接

Lesson 1

1、eclipse工具的使用

1. java代碼的位置

1) 選擇工做空間 workspace 選擇一個文件夾存放程序(代碼) 不要用中文和空格javascript

2) 新建一個java 工程(Project)css

3) 建包建類html

2. 快捷鍵

alt + / ：代碼自動補齊，須要配置的java

打開preferences(首選項), 搜keys，打開快捷鍵配置面板mysql

搜 alt+/ ，取消綁定程序員

搜 content assist ，取消原先的綁定，配置成alt+/web

ctrl+1: 錯誤自動修復，注意，放行的紅叉是可修復的，圓形的是不可修復的面試

導包的三種方式：ajax

1）將類名敲完整，按下alt+/ 進行補齊，會自動導包算法

2) ctrl+1,修正錯誤

3) ctrl+shift+o 整理包，導入須要的包，去掉多餘的導包語句

ctrl+shift+f : 代碼格式化

ctrl+2,L 自動聲明變量

shift+enter 光標直接進入下一行

ctrl+alt+方向鍵(向上向下) 複製行

alt+ 方向鍵(向上向下) 移動當前行

3. 斷點調試

1) 能夠對程序進行調試

在行的開頭雙擊左鍵打斷點，用debug方式來運行程序，程序就會停留在斷點位置

F5 跳入(step into) 跳入方法內部 F6 跳過，讓當前行運行 F7跳出返回上一層程序

resume 直接運行到下一個斷點

2) 查看源代碼建議使用斷點調試的方式，注意當前運行環境須要包含源碼

4. junit單元測試

1) 寫一個java類，聲明測試方式

修飾符爲 public void ,

在方法前面加註解，(@Test)

此方法就能夠進行測試了(交給junit運行)

2) 須要在測試方法前作初始化工做

寫一個靜態方法 public static void init()

在方法前加註解 @BeforeClass

3) 須要在測試後釋放資源

寫一個靜態方法

在方法前加註解 @AfterClass

2、jdk5新特性

1. 靜態導入

1) 導入類的靜態屬性

import static java.lang.System.out;

out.println("haha");

2) 導入類的靜態方法

import static java.lang.Math.*; // 導入Math類的全部靜態成員

int num = abs(-10);

2. 加強for循環

1) 做用：對存儲對象的容器進行迭代

2) jdk5之前怎麼迭代

3) 加強for循環迭代數組

String [] arr = {"a", "b", "c"}; //數組的靜態定義方式，只試用於數組首次定義的時候

// 傳統方式

for(int i=0; i<arr.length; i++) {

// i依次表示數組的角標

String s = arr[i];

System.out.println(s);

}

System.out.println("-------------------------------------");

// 在jdk5中咱們可使用加強for循環迭代

// 加強for循環括號裏寫兩個參數，第一個是聲明一個變量，變量類型必須是數組元素的類型

// 第二個就是須要迭代的容器

// for循環會循環容器的length次, 每次都將容器的第n-1個元素賦值給聲明的變量

for(String s : arr) {

// 循環體，執行arr.length

// 每次都將arr中的第n-1個元素給s

System.out.println(s); //

}

3. 基本數據類型的包裝類

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

1) Integer x = 1; x = x + 1; 經歷了什麼過程？裝箱à 拆箱 à 裝箱

2) 爲了優化，虛擬機爲包裝類提供了緩衝池， Integer池的大小 -128~127 一個字節的大小

3) String池

Java爲了優化字符串操做提供了一個緩衝池

面試題：

String s = 「abc」和 String s = new String(「abc」) 的區別

String s = new String(「abc」) 建立了幾個對象

String s = 「a」 + 「b」 + 「c」 + 「d」建立了幾個對象

String s1 = 「a」 String s2 = 「b」 String s3 = s1 + s2; s3==」ab」?

/*1. String s = "abc"，虛擬機首先會檢查String池裏有沒有"abc"對象(經過equals方法)

// 若是有，直接返回引用，若是沒有，會在池裏建立一個「abc」對象，並返回引用

String s1 = "abc";

String s2 = "abc";

System.out.println(s1==s2); // result: true

/* 2. String str = new String("abc");

無論緩衝池是否有"abc", 都會在堆內存建立一個"abc"對象，返回引用

// 此時，負責檢查並維護緩衝池，其實堆內存的對象是緩衝池中"abc"對象的一個拷貝

String s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1==s2); // result: false

/* 3. String s = "a" + "b" + "c" + "d"; java編譯器有個合併已知量的優化功能

// 在編譯階段就把"a" + "b" + "c" + "d" 合併爲」abcd「

String s = "a" + "b" + "c" + "d";

// String s = "abcd";

System.out.println(s=="abcd");// result: true

/* 4. String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;

// String是常量，不能相加的，java如何實現的？

StringBuilder sb = new StringBuidler(s1);

sb.append(s2);

s3 = sb.toString();

也就是說實際上s3是方法返回的String對象

凡是方法返回的字符串對象都是在堆內存的

String s1 = "a";

String s2 = "b";

String s3 = s1 + s2; // 堆內存的對象

System.out.println(s3=="ab");// result: false

4) 單列集合 Collection

List list = new ArrayList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

// 傳統方式1

/* 1.得到迭代器

Iterator iter = list.iterator();

// 2.循環判斷迭代器是否有下一個

while(iter.hasNext()) {

String str = (String) iter.next(); // 將迭代器的指針移向下一個，並將迭代當前指向的元素返回

System.out.println(str);

}

// 傳統方式2

for(Iterator iter=list.iterator(); iter.hasNext(); ) {

String s = (String) iter.next();

System.out.println(s);

}

System.out.println("--------------------------------");

// 加強for循環, 沒有使用泛型的集合能不能使用加強for循環迭代？能

for(Object obj : list) {

String s = (String) obj;

System.out.println(s);

}

5) 雙列集合 Map

Map map = new HashMap();

map.put("a", "aaa");

map.put("b", "bbb");

map.put("c", "ccc");

// 傳統方式迭代1

// 1. 得到全部的key

Set keys = map.keySet();

// 2.迭代keys得到全部的key

Iterator iter = keys.iterator();

while(iter.hasNext()) {

String key = (String) iter.next(); // a b c

// 3.根據key得到對應的value

String value = (String) map.get(key);

System.out.println(key + "=" + value);

}

System.out.println("---------------------------------");

// 傳統方式2，必須掌握這種方式

// 1.得到全部的鍵值對Entry對象

Set entrys = map.entrySet();

// 2.迭代出全部的entry

iter = entrys.iterator();

while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

// 分別得到key和value

String key = (String) entry.getKey();

String value = (String) entry.getValue();

System.out.println(key + "=" + value);

}

System.out.println("-------------------------------------");

System.out.println("加強for循環迭代，");

// 加強for循環迭代，

// 原則上map集合是沒法使用加強for循環來迭代的，

// 由於加強for循環只能針對實現了Iterable接口的集合進行迭代

// Iterable是jdk5中新定義的接口，就一個方法iterator方法

// 只有實現了Iterable接口的類，才能保證必定有iterator方法

// java有這樣的限定是由於加強for循環內部仍是用迭代器實現的

// 而實際上，咱們能夠經過某種方式來使用加強for循環

for(Object obj : map.entrySet()) {

// obj 依次表示Entry

Map.Entry entry = (Entry) obj;

System.out.println(entry.getKey() + "=" + entry.getValue());

}

6）集合迭代注意問題

// 在使用迭代器迭代集合的過程當中，不能對集合進行增刪操做

@Test

public void test4() {

List list = new ArrayList();

list.add("wangwu");

list.add("zhangsan");

list.add("lisi");

Iterator iter = list.iterator();

while(iter.hasNext()) {

String name = (String) iter.next();

if("wangwu".equals(name)) {

// 從集合中刪掉

//list.remove(name);

// 迭代過程當中刪除元素須要調用迭代器的方法

iter.remove(); // 刪除我迭代的集合被我迭代的最後一個元素

}

// 1 2 4

System.out.println(list.size());

}

@Test

public void test5() {

List list = new ArrayList();

list.add("aa");

list.add("bb");

// 使用ListIterator迭代器

ListIterator listIterator = list.listIterator();

while(listIterator.hasNext()) {

listIterator.next();

// 迭代過程當中增長元素

listIterator.add("cc");

}

System.out.println(list.size());

}

7) 加強for循環注意問題

//在使用加強for循環時，不能對元素進行賦值

int[] arr = {1,2,3};

for(int num : arr) {

num = 0;

}

System.out.println(arr[1]);

4. 可變參數

1) jdk5中方法的形參能夠定義爲可變參數，傳入實參個數可變

// 設計一個方法求n個數的和

public static int getSum(int... arr) {

// 可變參數在方法中仍被看作一個數組

int sum = 0;

for(int num : arr)

sum += num;

return sum;

}

2)Arrays.asList爲例演示傳入不一樣參數的狀況

// list長度爲3

List list = Arrays.asList("a","b","c");

// list長度爲1，由於考慮1.4語法

String[] arr = {"a","b","c"};

List list = Arrays.asList(arr);

// 同時符合1.4和1.5的語法,此時會優先考慮1.4的語法

// 緣由是有了新功能要保證之前的代碼不出錯，向後兼容

// 如今就須要將arr做爲一個元素存入集合

Object obj = arr;

List list2 = Arrays.asList(obj); // 此時只符合1.5的語法，不符合1.4的語法，沒有歧義

List list3 = Arrays.asList(new Object[]{arr}); // 優先考慮1.4，因此數組會拆開

//System.out.println(list3.size());

// 基本數據類型數組只符合1.5的語法

int[] nums = {1,2,3};

list = Arrays.asList(nums);

System.out.println(list.size());

5. 枚舉

問題：對象的某個屬性的值不能是任意的，必須爲固定的一組取值其中的某一個

解決辦法：

1）在setGrade方法中作判斷，不符合格式要求就拋出異常

2）直接限定用戶的選擇，經過自定義類模擬枚舉的方式來限定用戶的輸入

寫一個Grade類，私有構造函數，對外提供5個靜態的常量表示類的實例

3) jdk5中新定義了枚舉類型，專門用於解決此類問題

4) 枚舉就是一個特殊的java類，能夠定義屬性、方法、構造函數、實現接口、繼承類

//枚舉類就是一個java類，也能夠聲明屬性，方法，構造函數

public enum Grade4 {

A("90-100"),B("80-89"),C("70-79"),D("60-69"),E("0-59");

private String value;

private Grade4(String value) {

this.value = value;

}

public String getValue() {

return value;

}

//枚舉類就是一個java類, 也能夠繼承抽象和實現接口

public enum Grade5 {

// 抽象類不能建立實例對象

A("90-100"){

// new了一個Grade5的子類實例