節點1：環境搭建，Java基礎語法

1. 環境搭建

版本：
J2SE、J2EE、J2ME
下載並安裝JDK
JDK(Java Develop Kit):開發工具包
JRE(Java Runtime Environment):運行時環境
配置環境變量
右鍵—>計算機—>選擇“屬性”—>點擊“高級系統設置”—>打開“系統屬性”窗口—>點擊“環境變量”
（1）新建“JAVA_HOME”環境變量，值設置爲：JDK的安裝目錄
（2）修改“Path”環境變量，添加“;%JAVA_HOME%\bin;”
（3） Classpath(可選)
驗證是否安裝成功：
打開“運行”—>輸入cmd—>在命令提示符窗口，輸入java –version,如果能夠出現如下界面，則安裝成功！

2. 第一個Java程序

創建文件名爲HelloWorld.java的源文件：

//定義一個公共類，類名HelloWorld
public class HelloWorld{
	//類體-main方法
	public static void main(String[] args){
		//方法體
		System.out.print("Hello World!");
	}
}

運行Java程序：
（1）打開“運行”，輸入cmd，打開命令提示符窗口
（2）切換目錄
a) 切換盤符： e:
b) 切換目錄： cd billfox（cd—change directory）
c) 編譯程序： javac HelloWorld.java（編譯源文件，獲得class字節碼文件）
d) 運行程序： java HelloWorld（運行字節碼文件）

3. 開發工具的安裝使用

安裝版.exe
解壓版

4. 使用Eclipse創建Java項目

包名：反域名制（com.taobao.projectName）
類名：所有單詞首字母要大寫！(UpperCamelCase駝峯命名法 StudentCount)
變量名,方法名，參數名：(lowerCamelCase駝峯命名法 studentCount)
常量：所有字母大寫，每個單詞之間用下劃線隔開。 MAX_STOCK_COUNT

命名規範：由字母，數字，下劃線和$組成，不能以數字開頭。
比如：num1 num_1 $num

5. Java編程基礎

1) 變量

語法：數據類型變量名 [= 值];
例子：int count = 10;
float studentWeight;

標識符和關鍵字
標識符：是用來表示變量名、類名、方法名、數組名和文件名的有效字符序列。
關鍵字：是Java語言中被賦予特定含義的一些單詞。

變量的作用域

public class Demo01 {
	public static void main(String[] args) {
		//變量的作用域
		int x = 10;
		
		{
			//代碼塊
			int y = 20;
			System.out.println(y);
			System.out.println(x);
		}
		
		System.out.println(y);//報錯，超出了y的作用範圍
		System.out.println(x);
	}
}

2) 數據類型( 四類8種)

（1）整數型
a) 字節型byte 1個字節（8位） -27 ~27-1
b) 短整型short 2個字節（16位） -215 ~215-1
c) 整型int 4個字節（32位） -231 ~231-1
d) 長整型long 8個字節（64位） -263 ~263-1
（2）浮點數類型
a) 單精度浮點 float 4個字節
b) 雙精度浮點 double 8個字節
（3）布爾型 boolean (true,false)
（4）字符型 char

數據類型轉換
（1）自動類型轉換（小轉大）
byte–>short–>char–>int–>long–>float–>double
例子：
int num = 20;
float f1 = num;
（2）強制類型轉換（大轉小）
例子：
float f2 = 2.5f;
int num2 = (int)f2;//有可能損失精度或者溢出
（3）字符串型數據和整型數據相互轉換 “10” 10
a) 字符串轉數字 int num = Integer.parseInt(“10”);
b) 數字轉字符串 String str = 10 + “”;

3) 輸入輸出

輸出：
System.out.print(輸出的內容); //不換行
System.out.println(輸出的內容); //輸出內容後換行
輸入：
Scanner sc = new Scanner(System.in);//簡易的文本掃描器
int I = sc.nextInt();//獲取輸入的整數
float f = sc.nextFloat();//獲取輸入的單精度浮點數
double d = sc.nextDouble();//獲取輸入的雙精度浮點數
String s = sc.next();//獲取輸入的字符串

代碼提示配置
參考https://www.cnblogs.com/zgqys1980/p/5067337.html
主動觸發代碼提示的快捷鍵：Alt + /
字體大小配置
Window->preferences->搜索”font”->選擇”Colors and Fonts”->選擇右側列表中Basic下的Text Font,然後點擊編輯（Edit）按鈕，修改你想要的字體大小即可。

4) 常量

符號常量：final double PI = 3.1415926;
字面常量：10、2.5、’a’

5) 運算符

1. 算術運算符

+、-、*、/、%、++（前/後）、–（前/後）

注意：
/ 當兩個運算數爲整數時，爲取整運算。
/ 當兩個運算符不全爲整數時，爲除法運算。

c = a++;//先把a的值賦給c,然後a再自增
c = ++a;//先把a的值自增，然後把a賦給c

2. 關係運算符

、<、>=、<=、==、!=

由關係運算符構成的關係表達式，返回值爲布爾值，即true/false.

3. 邏輯運算符

&&（短路與）、||（短路或）、!、&（非短路與）、|（非短路或）、^（異或）

邏輯運算符，用於連接關係表達式（boolean），最終的結果，也是布爾值（boolean）。

4. 位運算符

5. 賦值運算符

=、+=、-=、*=、/=、%=

a += 10；// 等價於 a = a + 10;

6. 條件運算符

表達式1?表達式2：表達式3;

“表達式1”是一個結果爲布爾值的邏輯表達式。也就是返回值爲true/false
運算規則：
如果表達式1返回true,則整個表達式的返回值爲表達式2；否則返回表達式3；

7. 字符串運算符

其實就是對字符串進行拼接。

8. 運算符的優先級

. [] ()
算術運算符
關係運算符
邏輯運算符
條件運算符
賦值運算符

6) 流程控制語句

1. 順序結構

2. 分支結構

單分支if
雙分支if…else…
多分支
a) If…else if…else if…else
b) Switch(表達式){case 值1：break; default:break;}
分支結構嵌套

3. 循環結構

While
Do…while
For
Foreach增強for循環

4. 跳轉語句

break;//結束循環
continue;//退出本次循環，進入下一次
return;//退出方法

7) 數組

1. 數組的定義

	（1）int[] scores;//聲明
	     scores = new int[45];//初始化
	
	（2）int[] scores = new int[45];//聲明數組的同時初始化
	
	（3）靜態初始化
		int[] arr = new int[] {1,2,3,4,5,6};
		int[] arr =  {1,2,3,4,5,6};

2. 數組的賦值

		scores[0] = 10;
		scores[1] = 15;

3. 數組的常用操作

	數組遍歷
	數組最值（最大值，最小值）
	數組排序（冒泡排序，選擇排序）
	數組元素的刪除，修改

4. Arrays

	排序 sort
	查詢 binarySearch
	複製 copyOf
	轉字符串 toString
	填充 fill

8) 方法

1. 方法的定義

[修飾符] 返回值類型方法名([參數類型參數名1，參數類型參數2…]){
//方法體
}

例子：

public static void printStar(int line,int column) {
		
		for(int i = 0;i < line;i++) {
			//打印第i行： 
			//打印j個星號
			for(int j=0;j<column;j++) {
				System.out.print("*");
			}
			//打印換行
			System.out.println();
		}
}

2. 方法的分類

（1）無返回值無參數

public class Demo02 {
	public static void main(String[] args) {
		welcome();
	}
	
	public static void welcome() {
		System.out.println("**************");
		System.out.println("***  歡迎光臨   ***");
		System.out.println("**************");
	}
}

（2）無返回值有參數

public class Demo03 {
	public static void main(String[] args) {
		welcome("Hello");
	}
	
	public static void welcome(String content) {
		System.out.println("**************");
		System.out.println("***  "+content+"  ***");
		System.out.println("**************");
	}
}

（3）有返回值無參數

public class Demo04 {
	public static void main(String[] args) {
		int num = getNum();
		//System.out.println(num);
		
	}
	
	//有返回值
	public static int getNum() {
		//創建隨機類
		Random rad = new Random();
		//int n = rad.nextInt(); //獲得一個隨機數
		int n = rad.nextInt(); //獲得一個bound範圍之內的隨機數， 10   [0,10)   n>=0  n<10
		return n;
	}
}

（4）有返回值有參數

public class Demo05 {
	public static void main(String[] args) {
		int sum = add(8, 5);
		System.out.println(sum);
	}
	
	//加法
	public static int add(int n1,int n2) {
		int result = n1 + n2;
		return result;
	}
}

節點2：Java面向對象編程

面向對象編程思想
與面向過程編程思想的區別：
可以拿生活中的實例來理解面向過程與面向對象，例如五子棋，面向過程的設計思路就是首先分析問題的步驟：1、開始遊戲，2、黑子先走，3、繪製畫面，4、判斷輸贏，5、輪到白子，6、繪製畫面，7、判斷輸贏，8、返回步驟2，9、輸出最後結果。把上面每個步驟用不同的方法來實現。

如果是面向對象的設計思想來解決問題。面向對象的設計則是從另外的思路來解決問題。整個五子棋可以分爲1、黑白雙方，這兩方的行爲是一模一樣的，2、棋盤系統，負責繪製畫面，3、規則系統，負責判定諸如犯規、輸贏等。第一類對象（玩家對象）負責接受用戶輸入，並告知第二類對象（棋盤對象）棋子佈局的變化，棋盤對象接收到了棋子的變化就要負責在屏幕上面顯示出這種變化，同時利用第三類對象（規則系統）來對棋局進行判定。
2. 類和對象的概念：
• 對象：對象是類的一個實例（對象不是找個女朋友），有狀態和行爲。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行爲有：搖尾巴、叫、吃等。（具體）
• 類：類是一個模板，它描述一類對象的行爲和狀態。（抽象）
3. 類的設計

類的構成：
1）成員變量
2）成員方法
3）構造方法
 特點：
1.構造方法的方法名必須和類名一致。
2.沒有返回值類型。
4）類成員
 類變量（靜態變量）訪問：類名.類變量
 類方法（靜態方法）訪問：類名.類方法()
 靜態代碼塊
/*

類的設計
1）成員變量
2）成員方法
3）構造方法
4）類成員
a.類變量
b.類方法
c.靜態代碼塊
類,其實一種用戶自定義的數據類型。
編碼規範：駝峯命名法
*/
public class Student {

//1.成員變量
String name;
String sex;
int age;

//2.成員方法
public void study() {
System.out.println(name+“在學Java,在”+school);//成員方法可以訪問類變量，但類方法不能訪問成員變量。
}

public void playGame() {
System.out.println(name+“在玩王者榮耀”);
}

//3.構造方法
/*
- 特點：
- 1.構造方法的方法名要和類名一致。
- 2.沒有返回值類型。
- —3.一般情況下，用public來修飾。
  */
  public Student() {
  System.out.println("–構造方法執行–");
  count++;
  }
////////////////////////////////////////////////////////////////////////////////

//4.類變量(靜態變量)
static String school;
static int count;//當前類的對象個數

//5.類方法（靜態方法）
public static void count() {
System.out.println(“學校共有”+ count+“個學生。”);
}

//6.靜態代碼塊
static {
//對類進行初始化
count = 0;
System.out.println("–學校構建完成。–");
}
}

參數的傳遞（值傳遞）
基本數據類型：變量值
引用數據類型：內存值

瞭解：InstanceOf:判斷某個對象是否是某個類的對象。 S1 instanceof Student

方法重載
方法重載的特點：

在同一個類中
方法名相同
參數的個數或者類型不同
public class Actor {
String name;

//表演
public void act() {
System.out.println(“唱歌”);
}

public void act(String instrument) {
System.out.println(“邊彈” + instrument +“邊唱”);
}

public void act(int n) {
System.out.println(“循環唱” + n +“次”);
}
}

方法重載，包括：
成員方法重載
構造方法重載。
public class Actor {
//成員變量
String name;
String sex;
int age;

//成員方法重載
public void act() {
System.out.println(“唱歌”);
}

public void act(String instrument) {
System.out.println(“邊彈” + instrument +“邊唱”);
}

public void act(int n) {
System.out.println(“循環唱” + n +“次”);
}

//構造方法重載
public Actor() {
}

public Actor(String actorName) {
name = actorName;
}

public Actor(String actorName,String actorSex) {
name = actorName;
sex = actorSex;
}

public Actor(String actorName,String actorSex,int actorAge) {
name = actorName;
sex = actorSex;
age = actorAge;
}
}

補充：可變參數
//求整數的和(可變參數)
public int add(int… nums) {
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
return sum;
}

this
this指當前類的對象
public Actor(String name,String sex,int age) {
this.name = name;//當前要創建的對象的name屬性 = name參數;
this.sex = sex;
this.age = age;
}
通過this關鍵字
1.可以調用當前類的成員變量。
2.可以調用當前類的成員方法。
3.可以調用當前類的構造方法。
public class Student {
String name;
String sex;

public void study() {
System.out.println(this.name+“在學習”);//1.通過this調用成員變量
}

public void race() {
this.study();//2.通過this調用成員方法
System.out.println(“參加比賽！”);
}

public Student() {

}

public Student(String name){
this();//3.通過this調用無參構造
this.name = name;
}
}

節點3：封裝，繼承，多態

```
 封裝
```

實現步驟：
(1)屬性私有化 (2)提供公共的getter,setter方法
自動生成get,set方法：右鍵—>Source—>Generate Getters and Setters

public class Actor {
//成員變量
private String name;
private String sex;
private int age;

//提供公共的get,set方法
public void setName(String name) {
	this.name = name;
}

public String getName() {
	return this.name;
}

public void setSex(String sex) {
	if (sex.equals("男") || sex.equals("女")) {
		this.sex = sex;
	}else {
		System.out.println("您設置的性別有誤！");
	}
}

public String getSex() {
	return this.sex;
}

public void setAge(int age) {
	if (age < 0 || age > 130) {
		System.out.println("您設置的年齡有誤！");
	}else {
		this.age = age;
	}
	
}

public int getAge() {
	return this.age;
}

//成員方法 重載
public void act() {
	System.out.println("唱歌");
}

public void act(String instrument) {
	System.out.println("邊彈" + instrument +"邊唱");
}

public void act(int n) {
	System.out.println("循環唱" + n +"次");
}

//構造方法  重載
public Actor() {
}

public Actor(String name) {
	this.name = name;
}

public Actor(String name,String sex) {
	this.name = name;
	this.sex = sex;
}

public Actor(String name,String sex,int age) {
	this.name = name;
	this.sex = sex;
	this.age = age;
}

}
2. 繼承

繼承的概念：
可以基於已經存在的類構造一個新類。繼承已經存在的類就可以複用這些類的方法和域。在此基礎上，可以添加新的方法和域，從而擴充了類的功能。

繼承的關鍵字：extends

繼承的特點：

可以實現代碼的複用—子類擁有父類非私有的屬性和方法。
子類可以對父類進行擴展—子類可以擁有自己的屬性和方法。
方法重寫—子類可以用自己的方式去實現父類的方法。
單繼承，可以多重繼承
缺點：提高了代碼的耦合度。

例子：
定義父類：
public class Animal {
//父類定義子類共有的屬性和行爲
String name;
String sex;
int age;
String color;

public void eat() {
	System.out.println(name + "吃東西");
}

}
定義子類-Cat：
public class Cat extends Animal{
//貓類特有的行爲
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}
}
定義子類-Dog：
public class Dog extends Animal {
//狗類特有的行爲
public void guard() {
System.out.println(name + “看家”);
}

}
3) 修飾符
（1）訪問修飾符
a) public:所有類都可以訪問。 (當前類，同一個包中的不同類，不同包的類)
b) protected：包的訪問權限+不同包的子類 (當前類，同一個包中的不同類,不同包的子類)
c) 缺省:包的訪問權限。 (當前類，同一個包中的不同類)
d) private:當前類 (當前類)

（2）非訪問修飾符
a) static
i. 修飾成員變量，則成員變量變爲類變量。static String school = “萊職”;
ii. 修飾成員方法，則成員方法變爲類方法。
iii. 修飾代碼塊，則代碼塊變爲靜態代碼塊。特點：是在main方法之前運行，而且只運行一次。其實就是在類加載時運行。
b) final
i. 修飾變量，則變量變成不可改變的量，即常量。 final int num = 10;
ii. 修飾方法，則方法變爲不可重寫的方法。
iii. 修飾類，則類變爲不可繼承的類。
c) abstract 抽象
4) 方法重寫
特點：
1.要有繼承，重寫發生在兩個類之間，子類去重寫父類的同名的方法
2.子類的方法名要和父類的方法名相同，而且參數（個數，類型）也要完全一致。
3.子類對方法的修飾，只能擴大，不能縮小。

父類：
public class Animal {
//域（成員變量）
String name;
String sex;
int age;
String color;

//方法（成員方法）
public void eat() {
	System.out.println(name + "吃東西");
}

}
子類：
public class Cat extends Animal{
//特有的行爲（擴展）
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}

//子類可以重寫從父類繼承而來的方法
public void eat() {
	System.out.println(name+"吃魚");
}

}

Super
Super:指的是當前對象的父類
public class Dog extends Animal {
//特有的行爲（擴展）
public void guard() {
System.out.println(name + “看家”);
}

//方法重寫 — 註解
@Override
public void eat() {
super.eat();//調用超類（父類）的eat方法
System.out.println(super.name+“啃骨頭”);//調用超類（父類）的name屬性
}
}
通過super關鍵字
1.可以調用父類的成員變量 super.property;
2.可以調用父類的成員方法 super.method();
3.可以調用父類的構造方法 super();

注意：子類默認會調用父類的無參構造，如果顯式的調用了父類的有參構造，則不會再調用父類的無參構造。

多態
多態的三個必要條件：
1．繼承
2．重寫
3．父類引用指向子類對象（上轉型對象）

節點4：抽象類和接口

抽象類

定義抽象類：
abstract class Person{
//可以包含抽象方法
}

class Student extends Person{
//子類繼承抽象類，要去重寫父類的抽象方法。
}

特點：
1.抽象類不一定包含抽象方法，但包含抽象方法的類，一定是抽象類。

抽象類中的抽象方法只是聲明，不包含方法體，就是不給出方法的具體實現也就是方法的具體功能。
3.抽象類不能實例化。
4.抽象類只能作爲子類的超類（父類），被用來創建繼承層級裏子類的模板。
5.Java中只有單繼承。
構造方法，類方法（用 static 修飾的方法）不能聲明爲抽象方法。
抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。
抽象類存在的意義，就是被繼承。
接口

語法：
[可見度] interface 接口名稱 [extends 其他的接口名] {
// 聲明變量
// 抽象方法
}

示例：
/*

1.普通類
只能包含非抽象方法。
*/
public class Student {
//屬性
String name;
String sex;
int age;
//方法
public void study() {
System.out.println(“學習”);
}
}

2.抽象類
可以包含抽象方法，非抽象方法，也可以不包含任何方法。
*/
public abstract class Animal {
//屬性
String name;
//方法
public abstract void eat();

public void bark() {
	System.out.println("叫。。。");
}

}

3.接口
只能有抽象方法。
*/
public interface Work {
//屬性(默認用public static final修飾)
int count = 0;//注意：接口中的靜態常量，一定要賦初值。
//方法（默認用public abstract修飾）
void work();//抽象方法前的public abstract修飾符可以省略
public abstract void earnMoney();
}

接口的實現：
public class Teacher implements Work {

@Override
public void work() {
System.out.println(“上課”);
}

@Override
public void earnMoney() {
System.out.println(“拿課時費”);
}

}
3) 特點：
抽象類是一種特殊的類。接口是一種特殊的抽象類。
接口是一個抽象方法的集合。、
Java中，對於類來說，只有單繼承，但對於接口來說，可以多繼承。
定義接口的關鍵字：interface

標記接口
標記接口是沒有任何方法和屬性的接口.它僅僅表明它的類屬於一個特定的類型,供其他代碼來測試允許做一些事情。
標記接口作用：簡單形象的說就是給某個對象打個標（蓋個戳），使對象擁有某個或某些特權。
示例：
package java.util;
public interface EventListener {}

節點5：Object類和常用API

Object
Object類是所有類的父類。

常用方法：
（1） hashcode() 返回哈希值
（2） equals() 判斷對象是否相等
自動生成方式：在代碼中，右鍵，選擇”source”->”Genareate hashcode() and equals()”
（3） getClass() 返回此Object的運行時類。
（4） toString() 返回對象的字符串形式
自動生成方式：在代碼中，右鍵，選擇”source”->”Genareate toString() ”

String（不可變性）

創建字符串（構造方法）
（1） String str0 = “Hello”;//字符串常量
（2） String str1 = new String(“Hello”);//通過String構造方法
（3） String str2 = new String(char[] cs);//通過字符數組構造字符串
瞭解String的11種構造方法
操作字符串（常用方法）
（1） charAt(int index) 返回指定索引處的字符
（2） indexOf(String s) 查找字符在字符串中第一次出現的位置
（3） lastIndexOf(String) 查找字符在字符串中最後一次出現的位置
（4） contains(String s) 判斷是否包含字符序列
（5） substring(int beginIndex)
從beginIndex位置截取子字符串，一直擴展到字符串末尾
（6） substring(int beginIndex,int endIndex) [begin,end)
從beginIndex位置截取子字符串，一直到endIndex位置，不包括endIndex.
（7） trim() 去除前後空格！
（8） replace(char oldChar,char newChar) 替換
（9） split(String s) 字符串分割
（10） equals() 判斷字符串內容是否相同
（11） equalsIgnoreCase() 忽略大小寫判斷相等
（12） matches(正則表達式)
（13） length() 返回字符串的字符數（長度）
（14） isEmpty() 判斷字符串是否爲空字符串
（15） static valueOf(各種數據類型) 返回各種數據類型的字符串形式
（16） toCharArray() 字符串轉字符數組
（17） getBytes() 字符串轉字節
（18） toLowerCase() 轉小寫
（19） toUpperCase() 轉大寫
（20） concat() 字符串拼接 +
（21） format() 格式化字符串 %f %d %s
正則表達式
（1）匹配位置
^ 匹配字符串開始的位置。
$ 匹配字符串結束的位置。
（2）匹配字符
.(點號) 匹配任意一個字符
\ 將下一字符標記爲特殊字符
\s 匹配任意空白字符（空格，\f換頁符\n換行符\r回車符\t製表符\v垂直製表符）
\S 匹配任意非空白字符
\d 匹配任意數字
\D 匹配非數字
\w 匹配任何字類字符。等價於[A-Za-z0-9_]
\W 匹配任何非字類字符。等價於[^A-Za-z0-9_]
（3）匹配字符範圍
x|y 匹配x或y.
[xyz] 匹配包含的任一字符。
[^xyz] 匹配未包含的任一字符。
[a-z] 匹配字符範圍。
[^a-z] 匹配反向範圍字符
（4）匹配次數
- ```
   匹配前面的字符1-n次
```
- ```
   匹配前面的字符0-n次
```
? 匹配前面的字符0-1次
{n} 匹配前面的字符正好n次
{n,} 匹配前面的字符至少n次
{n,m} 匹配前面的字符至少n次，至多m次。

總結：正則表達式，可以用於匹配matches()，替換replace()和分割split()。
StringBuffer 、StringBuilder
StringBuffer sBuffer = new StringBuffer(“Hello”);
System.out.println(sBuffer);
sBuffer.append(“World!”); //在末尾追加字符 //0123456789
System.out.println(sBuffer); //HelloWorld!
sBuffer.delete(3, 5); //刪除多個字符（指定範圍） [3,5)
System.out.println(sBuffer); //HelWorld!
sBuffer.deleteCharAt(0);//刪除單個字符（指定位置）
System.out.println(sBuffer);//elWorld!
sBuffer.insert(2, “123456”);//在指定位置，插入內容
System.out.println(sBuffer);//el123456World!
sBuffer.reverse();//倒序
System.out.println(sBuffer);
sBuffer.setCharAt(0, ‘A’);//修改指定位置的字符
System.out.println(sBuffer);
StringBuffer中包含很多自己特有方法，也包含一些類似String類中的方法。比如（subString,indexOf,charAt）
StringBuilder和StringBuffer的方法，基本完全相同。

總結：
　　String：適用於少量的字符串操作的情況
　　StringBuilder：適用於單線程下在字符緩衝區進行大量操作的情況
　　StringBuffer：適用多線程下在字符緩衝區進行大量操作的情況

日期時間類

Date
Date date = new Date();//獲取當前時間
SimpleDateFormat
(1)Date轉String
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 hh時mm分ss秒 SSS E D”);
String strDate = sdf.format(date);
System.out.println(strDate);
(2)String轉Date
String str = “2018年10月01日 10:30:30”;
SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日 hh:mm:ss”);
Date date2 = sdf2.parse(str);//異常
System.out.println(date2);

獲得系統時間的毫秒數
long start = System.currentTimeMillis( );
long end = date.getTime();

//修改Calendar的時間
//c.set(2009, 6-1, 12);

//獲取日期的部分信息--年份
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH));
System.out.println(c.get(Calendar.DAY_OF_MONTH));


System.out.println(c.get(Calendar.DAY_OF_WEEK));

System.out.println(c.get(Calendar.HOUR));
System.out.println(c.get(Calendar.HOUR_OF_DAY));

//單獨設置屬性值
c.set(Calendar.YEAR, 2009);

c.add(Calendar.YEAR, 5);
c.add(Calendar.MONTH, 2);

System.out.println(c.get(Calendar.YEAR));//2014
System.out.println(c.get(Calendar.MONTH));//5

//判斷閏年
GregorianCalendar gc = new GregorianCalendar();
System.out.println(gc.isLeapYear(1900));

包裝類
//包裝類（Byte,Short,Integer,Long Float,Double Character Boolean）
//基本數據類型（byte,short,int,long float,double char boolean）

//面向對象編程
int num0 = 10;//數字
Integer num1 = new Integer(20);//對象

//Student student = new Student();

//封箱（基本數據類型--->包裝類）比如：int-->Integer
Integer num2 = new Integer(num0);
Integer num3 = Integer.valueOf(num0);

//拆箱（包裝類--->基本數據類型）比如：Integer-->int
int num4 = num1.intValue();

//自動封箱，拆箱
Integer num6 = 10;
int num5 = new Integer(10);

//數值字符串   轉成   基本數據類型   例子： "10"  -->  10
String str = "10";
System.out.println(str + 1);
int num7 = Integer.parseInt(str);
System.out.println(num7 + 1);

String str2 = "2.5";
System.out.println(str2 + 1);
float f = Float.parseFloat(str2);
System.out.println(f + 1);

數學類
//數學類
System.out.println(Math.E);
System.out.println(Math.PI);

System.out.println(Math.abs(-10.25));//絕對值
System.out.println(Math.sin(Math.PI/6));
System.out.println(Math.cos(Math.PI/3));

System.out.println(Math.ceil(2.5));//天花板
System.out.println(Math.floor(2.5));//地板
System.out.println(Math.round(2.26));//近似值

System.out.println(Math.sqrt(9));//開平方根
System.out.println(Math.cbrt(8));//開立方根
System.out.println(Math.pow(3, 4));// 求冪

System.out.println(Math.max(10, 8));//最大值
System.out.println(Math.min(10, 8));//最小值

System.out.println(Math.toDegrees(Math.PI/6));//弧度 轉 角度
System.out.println(Math.toRadians(30));//角度 轉 弧度

System.out.println(Math.random());//隨機數   0<=x<1

System.out.println(Math.multiplyExact(2, 3));//乘法
System.out.println(Math.negateExact(10));//取反

System和Runtime
System.out.println(“Hello”);
System.err.println(“Hello”);
Scanner sc = new Scanner(System.in);
//系統環境變量
Map<String, String> map = System.getenv();
for (String string : map.keySet()) {
System.out.print(string+"😊;
System.out.println(map.get(string));
}
System.out.println("===============");
//系統屬性
Properties properties = System.getProperties();
System.out.println(properties);
System.out.println("------------------");
```
Runtime runtime = Runtime.getRuntime();
System.out.println("處理器的數量：" + runtime.availableProcessors());
System.out.println("總內存數：" + runtime.totalMemory());

//runtime.exec("C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\QQScLauncher.exe");
runtime.exec("notepad.exe");
```

節點6：泛型、集合應用技術
爲什麼要學習集合？
集合相比數組而言，集合的長度是可變的，但是數組是不可變的。

Collection-單列集合

List-列表（有序，可重複）
數組：靜態數組
（1）ArrayList:動態數組（線程不同步，查詢效率更高）

//int[] arr = new int[10];
//1.創建一個ArrayList(動態數組-可以自動擴展)
ArrayList list = new ArrayList();
//在沒有指定泛型的時候，集合中可以添加任意類型的元素。
list.add(1);
list.add(2.5);
list.add('A');
list.add("Hello");
list.add(new Student());
list.add(6);
list.add(7);
list.add(8);
list.add(9);
list.add(10);
//集合是永遠都填不滿的，也就是可以自動擴展.
list.add(11);
list.add(12);
list.add(13);

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

//2.泛型（參數化類型）
ArrayList<String> iList = new ArrayList<String>();

//3.ArrayList的常用方法
//3.1添加元素到末尾
iList.add("tom");
iList.add("jack");
iList.add("rose");
iList.add("Kitty");
iList.add("Lufy");
//3.2在指定位置添加元素
iList.add(2, "Zoro");
System.out.println(iList);
//3.3刪除指定位置的元素
iList.remove(0);
System.out.println(iList);
//3.4修改元素
iList.set(2, "Bluck");
System.out.println(iList);
//3.5獲取元素
String s = iList.get(2);
System.out.println(s);

//3.6獲取集合元素個數
System.out.println(iList.size());
//3.7判斷集合是否爲空
System.out.println(iList.isEmpty());
//3.8判斷集合是否包含指定元素
System.out.println(iList.contains("Tomcat"));
//3.9查找元素在集合中的位置
int index = iList.indexOf("Lufy");
System.out.println("Lufy在集合的"+index+"號位置");
//3.10清空集合
iList.clear();
System.out.println(iList);
System.out.println("集合是否爲空："+iList.isEmpty());
System.out.println("---ArrayList的遍歷--方式一：");
//ArrayList的遍歷--方式一
for (int i = 0; i < iList.size(); i++) {
	System.out.println(iList.get(i));
}
System.out.println("---ArrayList的遍歷--方式二：");
//ArrayList的遍歷--方式二
for (String string : iList) {
	System.out.println(string);
}
System.out.println("---ArrayList的遍歷--方式三：");
//ArrayList的遍歷--方式三（迭代器）
Iterator<String> iter = iList.iterator();//獲取List的迭代器
while(iter.hasNext()) {//通過迭代器，判斷是否有下一個元素
	String string = iter.next();//獲取下一個元素
	System.out.println(string);
}

（2）Vector:（線程同步）[瞭解]
（3）LinkedList:鏈表（修改效率更高）
常用方法跟ArrayList基本相同。
不同之處：在性能方面。ArrayList適用於查詢，LinkedList適用於增刪改
2) Set-集合（無序，不可重複）
（1）HashSet:
//1.創建集合HashSet
HashSet hs = new HashSet();
System.out.print(“s1 equals s2:”);
System.out.println(s1.equals(s2));//true
//System.out.println(“String”.equals(“String”));
hs.add(1);
hs.add(2.5);
hs.add(‘A’);
hs.add(“String”);
hs.add(s1);
hs.add(s2);
hs.add(1);
hs.add(“String”);
//無序,不可重複
System.out.println(hs);

	//2.常用方法 和 泛型
	HashSet<String> sHashSet = new HashSet<String>();
	//2.1 添加
	sHashSet.add("tom");
	sHashSet.add("cat");
	sHashSet.add("rose");
	sHashSet.add("jack");
	System.out.println(sHashSet);
	//2.2刪除
	sHashSet.remove("tom");
	System.out.println(sHashSet);
	//2.3判斷是否包含某元素
	System.out.println(sHashSet.contains("jack"));
	//2.4獲取集合的長度
	System.out.println(sHashSet.size());
	
	System.out.println("HashSet的遍歷(迭代器):");
	//HashSet的遍歷(迭代器)
	Iterator<String> iter = sHashSet.iterator();
	while(iter.hasNext()) {
		String string = iter.next();
		System.out.println(string);
	}

在HashSet類中，如果添加自定義類的對象，要求不可重複，需要在自定義類中重寫hashCode()和equals()方法。
自動生成equals()方法的方式：右鍵SourceGenarate hashcode() and equals()…
2. Map-雙列集合

HashMap（線程不安全）
////////////////////創建HashMap雙列集合///////////////////////////
HashMap hm = new HashMap();//初始容量16 0.75
hm.put(1, “張三”);
hm.put(“102”, 6);
hm.put(2.5, 1);
hm.put(101,new Student());

//////////////////////////////使用泛型//////////////////////////////
HashMap<Integer, Student> hmStudents = new HashMap<Integer, Student>();

Student s1 = new Student();
s1.setId(101);
s1.setName("張三");
Student s2 = new Student();
s2.setId(102);
s2.setName("李四");
Student s3 = new Student();
s3.setId(103);
s3.setName("王五");
Student s4 = new Student();
s4.setId(104);
s4.setName("趙六");
/////////////////////////////一、增刪改查/////////////////////////////////////
//1.添加元素
hmStudents.put(101, s1);
hmStudents.put(102, s2);

//4.獲取元素
Student s = hmStudents.get(103);
System.out.println(s);

//2.刪除元素
s = hmStudents.remove(102);
System.out.println(s);

//3.替換（修改）元素
s = hmStudents.replace(101, s2);
System.out.println(s);

s = hmStudents.get(101);
System.out.println(s);

hmStudents.put(102, s1);
hmStudents.put(103, s3);
hmStudents.put(104, s4);
//////////////////////////////二、獲取集合//////////////////////////////////////////
//獲取key的集合（第一列的集合）
Set<Integer> set = hmStudents.keySet();
System.out.println(set);
//獲取value的集合（第二列的集合）
Collection<Student> cs = hmStudents.values();
System.out.println(cs);
//獲取entry的集合（兩個列的集合）
Set<Entry<Integer, Student>> entries = hmStudents.entrySet();
System.out.println(entries);
//////////////////////////////三、判斷包含及其他////////////////////////////////////////
//判斷是否包含某個key
boolean b = hmStudents.containsKey(102);
System.out.println(b);
//判斷是否包含某個value
boolean b2 = hmStudents.containsValue(s3);
System.out.println(b2);
//判斷集合是否爲空
hmStudents.isEmpty();
//清空集合
//hmStudents.clear();

/////////////////////////////四、遍歷（綜合應用）///////////////////////////////////////
//HashMap的遍歷
System.out.println("遍歷方法一：");
Set<Integer> sIntegers = hmStudents.keySet();//獲取第一列的集合
Iterator<Integer> iterator = sIntegers.iterator();//獲取第一列集合的迭代器
while (iterator.hasNext()) {
	Integer key = (Integer) iterator.next();
	System.out.print(key+"=");//打印key
	Student stu = hmStudents.get(key);//根據key,獲取value
	System.out.println(stu);
}

Hashtable（線程安全，用法跟HashMap相同）

Collections-工具類
排序 sort
查詢 binarySearch
複製 copy
隨機排列 shuffle
反轉（逆序）reverse
交換 swap
填充 fill
查找子列表 indexOfSubList()、lastIndexOfSubList()
節點7：異常和IO技術
異常

概念：
異常是程序中的一些錯誤，但並不是所有的錯誤都是異常，並且錯誤有時候是可以避免的。
異常發生的原因：
瞭解（物理錯誤，程序錯誤，用戶錯誤）
異常的分類：
（1）檢查性異常：（在編譯時，不能被忽略，不可避免，必須處理）
java.io.FileNotFoundException 文件未找到異常
（2）運行時異常：（在編譯時被忽略，是可能被程序員避免的異常，可以避免，可以不處理，發生時修改代碼）
java.lang.ArithmeticException 算術運算異常
java.lang.ArrayIndexOutOfBoundsException 數組下標越界異常

異常的類圖

異常處理：
（1）積極處理-捕獲處理
try{
//可能發生異常的代碼
}catch(發生異常的類型異常對象名){
//處理異常的代碼
}finally{
//釋放資源（無論是否發生異常，都會執行）
}
注意：異常的默認處理方式是，會終止程序。導致程序不能繼續運行！！

異常對象的常用方法
void printStackTrace()
將此throwable和其追溯打印到標準錯誤流。
String
getMessage()
返回此throwable的詳細消息字符串。

多個catch語句
（1）一個try語句塊，可以跟多個catch語句，捕獲多種異常。
（2）在catch語句中，異常類的父類Exception要放在後面。異常類的子類，放在前面。

（2）消極處理
拋出異常 throw:手動拋出異常
throw 異常對象；
聲明拋出異常 throws:一般用於聲明方法，可能會發生異常！
public static void divide() throws Exception{
…
}

自定義異常
瞭解：繼承Exception
2. IO技術

File類
概念：
文件和目錄路徑名的抽象表示。

常用方法：
（1）創建：
1）文件 createNewFile()
2）目錄 mkdir()：創建單級目錄 mkdirs()：創建多級目錄
（2）刪除：delete()
（3）獲取文件或文件夾屬性
exists()：測試此抽象路徑名錶示的文件或目錄是否存在。
getAbsolutePath()
getName()
getParent()
getPath()
isDirectory()
isFile()
isHidden()
lastModified()
list()
（4）文件或文件夾操作
renameTo(File dest)
2) 字節流
（1）字節輸出流（寫）：OutputStream
實現類：

FileOutputStream
構造方法：
FileOutputStream(String name)
FileOutputStream(File file)
FileOutputStream(String name, boolean append):append爲true,則表示追加文本
FileOutputStream(File file, boolean append) append爲true,則表示追加文本

注意：如果追加文本，需要換行。Window操作系統中要用”\r\n”
常用方法：

write(int b)寫一個字節
write(byte[] b)寫一個字節數組
write(byte[] b,int off,int len)寫一個字節數組的一部分
close() 關閉流
BufferedOutputStream
構造方法

常用方法

ObjectOutputStream
PrintStream
構造方法

常用方法

（2）字節輸入流（讀）：InputStream
實現類：

FileInputStream
構造方法：
FileInputStream(String name)
通過打開與實際文件的連接來創建一個 FileInputStream ，該文件由文件系統中的路徑名 name命名。
FileInputStream(File file)
通過打開與實際文件的連接創建一個 FileInputStream ，該文件由文件系統中的 File對象 file命名。
常用方法：
available()
返回從此輸入流中可以讀取（或跳過）的剩餘字節數的估計值，而不會被下一次調用此輸入流的方法阻塞。
read()
從該輸入流讀取一個字節的數據。
read(byte[] b)
從該輸入流讀取最多 b.length個字節的數據爲字節數組。
read(byte[] b, int off, int len)
從該輸入流讀取最多 len字節的數據爲字節數組。
close()
關閉此文件輸入流並釋放與流相關聯的任何系統資源。
BufferedInputStream
構造方法

常用方法
3. ObjectInputStream

字符流
（1）字符輸出流（寫）:Writer
實現類：
OutputStreamWriter:轉換流（字符流字節流）

FileWriter
BufferedWriter
PrintWriter

（2）字符輸入流（讀）:Reader
實現類：
InputStreamReader：轉換流（字節流字符流）

FileReader
BufferedReader

節點8：JDBC

JDBC基本步驟

什麼是JDBC?
JDBC原理
JDBC核心類
參考網址：https://www.cnblogs.com/qlqwjy/p/8227665.html

有：DriverManager、Connection、Statement，和ResultSet！
（1）DriverManger（驅動管理器）的作用有兩個：
　　l 註冊驅動： DriverManager.registerDriver(new Driver());
　　l 獲取Connection： DriverManager.getConnection(String url,String user,String password)
（2）Connection對象表示連接，與數據庫的通訊都是通過這個對象展開的：
l Connection最爲重要的一個方法就是用來獲取Statement對象；
（1） Statement createStatement()
（2） PreparedStatement prepareStatement(sql);
（3）Statement是用來向數據庫發送SQL語句的，這樣數據庫就會執行發送過來的SQL語句
　　l void executeUpdate(String sql)：執行更新操作（insert、update、delete等）；
　　l ResultSet executeQuery(String sql)：執行查詢操作，數據庫在執行查詢後會把查詢結果，查詢結果就是ResultSet；
（4）ResultSet對象表示查詢結果集，只有在執行查詢操作後纔會有結果集的產生。結果集是一個二維的表格，有行有列。操作結果集要學習移動ResultSet內部的“行光標”，以及獲取當前行上的每一列上的數據：
　　l boolean next()：使“行光標”移動到下一行，並返回移動後的行是否存在；
　　l XXX getXXX(int col)：獲取當前行指定列上的值，參數就是列數，列數從1開始，而不是0。
2. JDBC-CRUD（Statement）
void executeUpdate(String sql)—執行增刪改
ResultSet executeQuery(String sql)—執行查詢
3. PreparedStatement
優點：（1）防止SQL注入。（2）效率更高。

【結論】：實際開發中，推薦使用PreparedStatement！！！
4. 自定義工具類
package com.ambow.dbwork;
import java.sql.;
/
JDBC連接數據庫的工具類—自定義工具類【瞭解，自己能寫】
//1. 獲取數據庫連接
//2. 釋放資源
*/
public class JDBCUtils {
private static String DRIVERNAME = “com.mysql.jdbc.Driver”;
private static String URL = “jdbc:mysql://localhost:3306/db_book”;
private static String USER = “root”;
private static String PWD = “root”;

//1. 獲取數據庫連接
public static Connection getConnection(){
    Connection conn = null;
    //1.加載驅動
    try {
        Class.forName(DRIVERNAME);
        //2.獲取數據庫連接
        conn = DriverManager.getConnection(URL, USER, PWD);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}
//2. 釋放資源
public static void closeAll(Connection conn, Statement stmt, ResultSet rs){
    if (rs != null){
        try {
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (stmt != null){
        try {
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (conn != null){
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

}

數據庫連接池
（1） c3p0
參考網址：https://blog.csdn.net/HeiSeHuoEr/article/details/89537080
（2） druid-阿里【推薦】
參考網址：https://blog.csdn.net/Dear_UU/article/details/89370491
package com.ambow.jdbc;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class DruidUtils {
//Druid德魯伊,據說是魔獸世界中的一個角色,森林女神
public static DruidDataSource dataSource;//數據庫連接池

//1.初始化Druid連接池
static {
    //第二種方式:使用軟編碼通過配置文件初始化
    try {
        Properties properties = new Properties();
        //通過類加載器加載配置文件
        InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(inputStream);
        //創建連接池
        dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

//2.獲取連接
public static Connection getConnection() {
    try {
        return dataSource.getConnection();//從連接池中獲取連接
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

//3.釋放資源
public static void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
    //釋放resultSet
    try {
        if (resultSet != null) {
            resultSet.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    //釋放Statement
    try {
        if (statement != null) {
            statement.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    //釋放Connection
    try {
        if (connection != null) {
            connection.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

}
6. Apache DBUtils工具類/Spring JDBCTemplate
參考網址：https://blog.csdn.net/HeiSeHuoEr/article/details/85157546

JDK8新特性：
lambda表達式
https://www.liaoxuefeng.com/article/001411306573093ce6ebcdd67624db98acedb2a905c8ea4000
全新的Stream API
https://www.liaoxuefeng.com/article/001411309538536a1455df20d284b81a7bfa2f91db0f223000
JDK11新特性解讀
https://www.liaoxuefeng.com/article/0015419379727788f4e146b6fb1409dbaa7ad35db2560fc000

廖雪峯SQL教程
https://www.liaoxuefeng.com/wiki/001508284671805d39d23243d884b8b99f440bfae87b0f4000

Java總結-2019.10

節點1：環境搭建，Java基礎語法

1. 環境搭建

2. 第一個Java程序

3. 開發工具的安裝使用

4. 使用Eclipse創建Java項目

5. Java編程基礎

1) 變量

2) 數據類型( 四類8種)

3) 輸入輸出

4) 常量

5) 運算符

1. 算術運算符

2. 關係運算符

3. 邏輯運算符

4. 位運算符

5. 賦值運算符

6. 條件運算符

7. 字符串運算符

8. 運算符的優先級

6) 流程控制語句

1. 順序結構

2. 分支結構

3. 循環結構

4. 跳轉語句

7) 數組

1. 數組的定義

2. 數組的賦值

3. 數組的常用操作

4. Arrays

8) 方法

1. 方法的定義

2. 方法的分類

節點2：Java面向對象編程