java基礎(必會有這一篇就夠了有練習)-講解到ArrayList的內容

總複習

一.day01內容

注：如有侵權，請聯繫刪除
 

1.JVM,JRE,JDK的關係

JVM: java虛擬機,用來運行java程序的,JVM本身是不誇平臺的,每個操作系統都需要安裝針對本操作系統的JVM

所以: java通過jvm的不誇平臺實現了java的跨平臺

JRE:java運行環境,包含jvm和核心類庫

JDK:java開發工具包,包含開發工具和JRE

三者關係： JDK > JRE > JVM

2.常用DOS命令

操作	說明
盤符名稱:	盤符切換。E:回車，表示切換到E盤。
dir	查看當前路徑下的內容。
cd 目錄	進入單級目錄。cd itheima
cd 目錄1\目錄2…	進入多級目錄。cd itheima\JavaSE
cd …	回退到上一級目錄。
cd \	回退到盤符目錄。
cls	清屏。
exit	退出命令提示符窗口。

3.JAVA_HOME環境變量的配置

目的: 在所有目錄下都可以運行java命令

題目一

系統已安裝JDK，位置如下

D:\DevelopTools\Java\jdk-9.0.1

請問，環境變量JAVA_HOME的值正確配置爲：

A：D:\DevelopTools\Java\jdk-9.0.1\bin

B：D:\DevelopTools\Java\jdk-9.0.1

C：D:\DevelopTools\Java

D：%JAVA_HOME%\bin

題目二

系統已正確配置環境變量JAVA_HOME，請問，將 JAVA_HOME 配置到環境變量path中的正確做法爲：

A：$JAVA_HOME$; 其他配置項...

B：%JAVA_HOME%; 其他配置項...

C：%JAVA_HOME%\bin; 其他配置項...

D：$JAVA_HOME$\bin; 其他配置項...

4.程序開發步驟

Java程序開發三步驟：**編寫**、**編譯**、**運行**。

(1)程序員編寫的java程序的文件,稱爲源文件,擴展名是.java

(2)必須使用javac命令編譯,生產字節碼文件,擴展名是.class

javac HelloWorld.java      注意編譯javac命令後面帶擴展名

(3)必須使用java命令運行

java HelloWorld		     注意運行java命令後面不帶擴展名

注意: 源文件的名稱必須和類名保持一致

5.註釋

概念: 解釋程序中的內容,不參與編譯,不影響程序的運行效率,是給程序員看的

分類:

	單行註釋: //

	多行註釋: /* ...*/

	文檔註釋: /** ... */

6.常量

概念: 是指在Java程序中固定不變的數據。

注意:

	(1)字符常量: 必須使用單引號''引起來,內部只能寫一個字符,不能寫多個,也不能不寫

	(2)字符串常量: 必須使用雙引號""引起來,內部可以寫多個字符(0個,1個...)

	(3)布爾常量: 只能有兩個true,或者false,注意不用加""

	(4)整數默認爲int類型,小數默認爲double類型,要表示long類型後面加L,要表示float類型後面加F

7.關鍵字

概念: 是指在程序中，Java已經定義好的單詞，具有特殊含義。

能認出java中的關鍵字---容易出現單選題或者多選題目

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-Ryb7PNvo-1582722650202)(C:\Users\hjx\Desktop\img\01_關鍵字.png)]

二.day02內容

1.變量

(1)概念: 常量是固定不變的數據，那麼在程序中可以變化的量稱爲變量。

(2)數據類型:

	(1)整數類型
		byte類型		1個字節			-128到127
		short類型		2個字節			正負3萬多			
		int類型			4個字節			正負21億		整數默認就是int類型
		long類型		8個字節			大概19位數字
			表示long類型的數據,後面建議添加L
			
	(2)小數類型				
		float類型		4個字節			採用科學計數法,雖然佔4個字節,但是取值範圍遠遠超過long類型
			表示float類型的數據,後面建議添加F
		double類型		8個字節			小數默認就是double類型	
	
	(3)其它
		char類型		2個字節			
		boolean類型		1個字節	
		
	目的: 每種類型的字節數不同,它的取值範圍就不同,需要根據需求做出選擇

(3)定義格式

	格式一: 先挖坑,再種蘿蔔
		數據類型 變量名稱;(先挖坑)
		變量名稱 = 數據值;(再種蘿蔔)

	格式二:挖坑的同時種蘿蔔
		數據類型 變量名稱 = 數據值;	

		=: 代表賦值的,把數據放到坑中

(4)變量定義的注意事項

	變量名稱：在同一個大括號範圍內，變量的名字不可以相同。

	變量賦值：定義的變量，不賦值不能使用。

	定義long類	型的變量時，需要在整數的後面加L（大小寫均可，建議大寫）。因爲整數默認是int類型，整數太大可能超出int範圍。

	定義float類型的變量時，需要在小數的後面加F（大小寫均可，建議大寫）。因爲浮點數的默認類型是double， double的取值範圍是大於float的，類型不兼容。

2.類型轉換

2.標識符

**命名規則：硬性要求`**

	標識符可以包含`英文字母26個(區分大小寫)`、`0-9數字` 、`$（美元符號）`和`_（下劃線）`。

	標識符不能以數字開頭。

	標識符不能是關鍵字。

**命名規範：`軟性建議`**

	類名規範：首字母大寫，後面每個單詞首字母大寫（大駝峯式）。

	方法名規範： 首字母小寫，後面每個單詞首字母大寫（小駝峯式）。

	變量名規範：首字母小寫，後面每個單詞首字母大寫（小駝峯式）。

3.數據類型轉換

自動類型轉換: 取值範圍小的數據或者變量 可以 直接賦值給取值範圍大的變量 (小蘿蔔可以直接放在大坑中)

特點:
	(1)是自動完成的,不需要代碼的干預
	(2)byte/short/char 類型 只要參加運算,會自動轉換爲int類型
	(3)轉換規則
		byte、short、char-->int-->long-->float-->double			
	注意:
		自動類型轉換,就是在數據前面按照要求補充若干字節的0

public static void main(String[] args) {
    int i = 1;
    byte b = 2;
  	// byte x = b + i; // 報錯
    //int類型和byte類型運算，結果是int類型
    int j = b + i;
    System.out.println(j);
}

強制類型轉換: 取值範圍大的數據或者變量,不能直接賦值給取值範圍小的變量(大蘿蔔不能直接放入小坑中)
	必須進行強制類型轉換
強制類型轉換格式:
	轉後類型 變量名稱 = (轉後類型)轉前的數據或者變量;
	
	注意:
		強制類型轉換,根據要求砍掉數據前面的若干字節,如果被砍掉的字節都是0,對數據沒有影響
		只要被砍掉的數據中包含1,對數據沒有影響

public static void main(String[] args) {
     //short類型變量，內存中2個字節
     short s = 1;
     /*
       出現編譯失敗
       s和1做運算的時候，1是int類型，s會被提升爲int類型
       s+1後的結果是int類型，將結果在賦值會short類型時發生錯誤
       short內存2個字節，int類型4個字節
       必須將int強制轉成short才能完成賦值
     */
     s = s + 1；//編譯失敗
     s = (short)(s+1);//編譯成功
}

4.ASCII碼錶

char和int是相互可以轉換的	

public class Demo06Convert {
	public static void main(String[] args) {
		char ch = 'a';
		System.out.println(ch);//'a'
		//char + int --> int + int --> int  如何把char類型轉換爲int類型呢? 查看ASCII碼錶
		System.out.println(ch+1);//98
		//如何把int類型轉換爲char類型呢? 查看ASCII碼錶
		System.out.println((char)(ch+1));//'b'
		System.out.println("=========================");
		
		
		char ch2 = 'A';
		System.out.println(ch2);//'A'
		System.out.println(ch2+1);//66
		
		System.out.println((char)(ch2+1));
		
		//如何把char轉成int呢? 查看ASCII碼錶
		int num = ch2;
		System.out.println(num);//65
	}
}

5.算數運算符+,-,*,/

public class Demo07Operator {
	public static void main(String[] args) {
		//定義2個int變量
		int a = 20;
		int b = 10;
		System.out.println(a + b);//20 + 10: 30
		System.out.println(a - b);//20 - 10: 10
		System.out.println(a * b);//20 * 10: 200
		System.out.println(a / b);//20 /10: 2
		System.out.println(a*1.0 / b);//2.0
	}
}

6.取模運算%

/*
	%:
		取模運算(取餘數)，兩個數字相除取餘數
		數學中:
				被除數/除數 = 商(/: 求的就是商) ..... 餘數(%: 求的就是餘數)
				
	%的作用:
		1.判斷數字的奇偶性:
			偶數: 數字%2 結果  0
			奇數: 數字%2 結果  1
			
		2.判斷一個數字能否被另外一個數字整除
		
		3.使用/和% 可以 求出某個數字的每一位上的數字
		
			比如:
				1234
				個位: 4
				十位: 3
				百位: 2
				千位: 1
				
*/
public class Demo08Operator {
	public static void main(String[] args) {
		System.out.println(6%2);//0  說明6是偶數
		System.out.println(11%2);//1  說明1是奇數
		System.out.println(100%25);//0  說明100可以被25整除
		System.out.println(101%25);//1  說明101不可以被25整除
		System.out.println("---------------------");//1  說明101不可以被25整除
		
		//定義int變量
		int num = 1234;
		
		//個位
		int ge = num%10;
		
		//十位
		//System.out.println(123%10);//如何獲取123?
		//System.out.println(1234/10);//123
		int shi = num/10%10;
		
		//百位
		//System.out.println(1234/100);//12
		//System.out.println(1234/100%10);
		int bai = num/100%10;
		
		//千位
		int qian = num/1000%10;
		
		System.out.println(ge);
		System.out.println(shi);
		System.out.println(bai);
		System.out.println(qian);
	}
}

7.+的特殊用法,字符串拼接

/*
	+:
		1.在數學運算中,代表的是加法運算
		2.+符號在字符串中的作用在遇到字符串的時候，表示連接、拼接的含義。
*/
public class Demo09Operator {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
		System.out.println("Hello"+"World");//+: 字符串的連接
		//從左向右運算
		//第一步:"5+5="+5: "5+5=5"
		//第二步:"5+5=5"+5 "5+5=55"
		System.out.println("5+5="+5+5);//5+5=55
		
		//先計算()中的式子的結果: 5+5 結果10
		//"5+5="+10: 結果5+5=10
		System.out.println("5+5="+(5+5));//5+5=10
		
		
		int a = 18,b = 19;
		//要求輸出:18+19=37
		System.out.println(a+"+"+b+"="+(a+b));
	}
}

8.自增自減運算符

/*
	自增(++)自減(--)運算符
		1.作用:
			讓變量的值增加(++)或者減少(--)1
		
		2.使用格式:
			(1)可以寫在變量的前面:	++a,--a
			(2)可以寫在變量的後面:	a++,a--							最常用的
			
		3.使用特點:
			(1)單獨使用: 沒有其它的運算參與
				前++/-- 或者 後++/--: 作用相同,都是讓變量的值增加1或者減少1
				
			(2)混合使用: 和其它運算符(賦值/打印)一起進行運算
				有重大區別
				前++/--: 先給變量++/--,然後再使用變量
				後++/--: 先使用變量,後給變量++/--
				
		最常用的:
			a++:	a的值增加1
			a--:	a的值減少1
*/
public class Demo12Operator {
	public static void main(String[] args) {
		int a = 2;
		//單獨使用
		a++;//a = a + 1
		System.out.println(a);//3
		
		int b = 2;
		++b;//b = b + 1
		System.out.println(b);
		System.out.println("--------------------------");
		
		
		int c = 5;
		//因爲++在c的後面,所以先使用c的值(5)賦值給變量d,這樣d的值就是5,然後c的值再+1,c變成6
		int d = c++;
		System.out.println(c);//6
		System.out.println(d);//5
		
		System.out.println("--------------------------");
		
		
		int e = 10;
		//因爲++在e的前面,所以先給e的值+1,e變成11,然後把11賦值給f,這樣f的值11
		int f = ++e;
		System.out.println(e);//11
		System.out.println(f);//11
		
		
		int g = 6;
		/*
			從左向右計算
			先計算++g: 因爲++在前面,所以先給g的值+1,g變成7,在使用g的值和後面的表達式進行運算
			7 + (g++):
			(g++): 因爲++在後面,先使用g的值(7)和前面的數字7進行運算 7+7 = 14,把14賦值給變量h ,最後g的值再+1,g變成8
		*/
		int h = (++g) + (g++);
		System.out.println(h);//14
		System.out.println(g);//8
		
		
	}
}

9.賦值運算符

/*
	擴展賦值運算符的特點
		+=,-=,/=,*=,%=:
			如果左右兩側的數據類型不一致,隱藏進行強制類型轉換
			
		byte/short/char 只要參加運算,會自動轉換爲int類型
*/
public class Demo11Operator {
	public static void main(String[] args) {
		short s = 2;
		//short + int --> int + int --> int  結果int類型(4個字節) 不能直接賦值給左側 short類型(2個字節)的變量
		//s = s + 1;
		
		//需要強制類型轉換
		//s = (short)(s + 1);
		
		s += 1;//s = (short)(s + 1);
		
		System.out.println(s);
	}
}

三.day03內容

1.關係運算符

符號	說明
==	a==b，判斷a和b的值是否相等，成立爲true，不成立爲false
!=	a!=b，判斷a和b的值是否不相等，成立爲true，不成立爲false
>	a>b，判斷a是否大於b，成立爲true，不成立爲false
>=	a>=b，判斷a是否大於等於b，成立爲true，不成立爲false
<	a<b，判斷a是否小於b，成立爲true，不成立爲false
<=	a<=b，判斷a是否小於等於b，成立爲true，不成立爲false

public class Demo01GuanXi {
	public static void main(String[] args){
		//定義2個int類型的變量
		int a = 10;
		int b = 20;
		
		//定義boolean類型的變量,接收關係運算符的結果
		boolean result = (a > b);
		System.out.println(result);//false
		
		System.out.println(a == b);//10 == 20	false
		System.out.println(a != b);//10 != 20	true
		System.out.println(a > b);//10 > 20		false
		System.out.println(a >= b);//10 >= 20	false
		System.out.println(a < b);//10 < 20		true
		System.out.println(a <= b);//10 <= 20	true
		
		System.out.println("-----------------------");
		System.out.println(a = b);//=是賦值的操作,先把b的值賦值給a,然後再打印a的值: 20
		
		
	}
}

2.邏輯運算符

注意: 邏輯表達式的最終結果爲boolean類型true或者false,而且連接的表達式也必須是布爾類型的

符號	作用	說明
&	邏輯與	a&b，a和b都是true，結果爲true，否則爲false
|	邏輯或	a|b，a和b都是false，結果爲false，否則爲true
^	邏輯異或	a^b，a和b結果不同爲true，相同爲false
!	邏輯非	!a，結果和a的結果正好相反

/*
	邏輯運算符:
		用來連接布爾表達式的,最終的結果也是一個boolean類型,要麼是true,要麼是false
		
			必須北京有房,而且還得有車
		&【有false，則false】: 邏輯與	並且	多個條件都爲true,結果才爲true
		
		
			北京有房也行,有車也行	
		|【有true，則true】: 邏輯或	或者	多個條件中只要有一個爲true,結果就爲true
		
		^: 邏輯異或		相同爲false,不同爲true					
		
		!: 取反			!true: false	!false: true

*/

public class Demo02LuoJi {
	public static void main(String[] args){
		//定義3個int類型變量
		int a = 10,b = 20,c = 30;
		
		System.out.println((a>b) & (a>c));//10 > 20 & 10 > 30 ==> false & false ==> false
		System.out.println((a<b) & (a<c));//10 < 20 & 10 < 30 ==> true & true ==> true
		System.out.println((a>b) & (a<c));//10 > 20 & 10 < 30 ==> false & true ==> false
		System.out.println((a<b) & (a>c));//10 < 20 & 10 > 30 ==> true & false ==> false
		
		System.out.println("--------------------");
		
		System.out.println((a>b) | (a>c));//10 > 20 | 10 > 30 ==> false | false ==> false
		System.out.println((a<b) | (a<c));//10 < 20 | 10 < 30 ==> true | true ==> true
		System.out.println((a>b) | (a<c));//10 > 20 | 10 < 30 ==> false | true ==> true
		System.out.println((a<b) | (a>c));//10 < 20 | 10 > 30 ==> true | false ==> true
		
		System.out.println("--------------------");
		
		System.out.println((a>b) ^ (a>c));//10 > 20 ^ 10 > 30 ==> false ^ false ==> false
		System.out.println((a<b) ^ (a<c));//10 < 20 ^ 10 < 30 ==> true ^ true ==> false
		System.out.println((a>b) ^ (a<c));//10 > 20 ^ 10 < 30 ==> false ^ true ==> true
		System.out.println((a<b) ^ (a>c));//10 < 20 ^ 10 > 30 ==> true ^ false ==> true
		
		System.out.println("--------------------");
		
		boolean flag = true;
		System.out.println(flag);//true
		System.out.println(!flag);//false
		System.out.println(!!flag);//true
	}
}

符號	作用	說明
&&	短路與	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

/*
	短路邏輯運算符			以後都使用&& 和 ||
	&&: 邏輯與
		運算結果和 & 是一樣的 但是 && 有短路的效果
		特點: 左側爲false,右側不再計算
		
	||: 邏輯或
		運算結果和 | 是一樣的 但是 || 有短路的效果
		特點: 左側爲true,右側不再計算
*/
public class Demo03DuanLu {
	public static void main(String[] args){
		int a = 5;
		int b = 6;
		/*
			從左向右計算
			先計算: a > 6 ==> 5 > 6 --> false 左側是false,已經決定了&&的最終結果是false
			不管&&右側的結果是true或者false,都無法影響整個表達式的最終結果
			所以不需要計算右邊的表達式 b++ > 5
		*/
		System.out.println((a > 6) && (b++ > 5));//false
		System.out.println(a);//5
		System.out.println(b);//6
		
		int x = 5;
		int y = 6;
		/*
			從左向右計算
			先計算: x < 6 ==> 5 < 6 --> true 左側是true,已經決定了||的最終結果是true
			不管||右側的結果是true或者false,都無法影響整個表達式的最終結果
			所以不需要計算右邊的表達式 y++ > 5
		*/
		System.out.println((x < 6) || (y++ > 5));//true
		System.out.println(x);//5
		System.out.println(y);//6
	}
}

3.三元運算符

格式: 布爾表達式 ? 表達式1 : 表達式2;

執行流程:

(1)計算布爾表達式的結果看是true,還是false

(2)如果布爾表達式的結果爲true,計算表達式1的結果作爲三元運算符的結果

(3)如果布爾表達式的結果爲false,計算表達式2的結果作爲三元運算符的結果

注意: 三元運算符的結果必須被使用

/*
	三元運算符
		1.格式:
			數據類型 變量名稱 = 關係表達式1 ? 表達式2 : 表達式3;
			
		2.執行流程:
			(1)計算關係表達式1的結果,看是true還是false
			(2)如果關係表達式1的結果爲true,把表達式2的結果賦值給左側的變量
			(3)如果關係表達式1的結果爲false,把表達式3的結果賦值給左側的變量
			
		3.注意:
			第一個表達式: 關係表達式1,不管寫的多麼複雜或者多麼簡單,要求結果必須是true或者false
		
		4.練習:
			求兩個int數據的最大值
			
			實現步驟:
				1.定義2個int變量,並進行初始化
				2.使用三元運算符求出最大值,保存int變量max
				3.輸出結果
*/
public class Demo04SanYuan {
	public static void main(String[] args){
		
		//1.定義2個int變量,並進行初始化
		int a = 30;
		
		int b = 20;		
		
		//2.使用三元運算符求出最大值,保存int變量max
		int max = a > b ? a : b;
		
		//3.輸出結果
		System.out.println("最大值: "+max);
		
		
	}
}

/*
	需求：
		一座寺廟裏住着三個和尚，已知他們的身高分別爲150cm、210cm、165cm，
		請用程序實現獲取這三個和尚的最高身高。
		
	分析:
		1.定義3個int變量h1,h2,h3,分別代表三個和尚的身高
		2.使用三元運算符先求出h1和h2的最大值,保存int變量temp中
		3.再使用三元運算符先求出temp和h3的最大值,保存int變量max中
		4.最後max中的值就是3個int數據的最大值,直接打印輸出
*/
public class Demo07SanYuan {
	public static void main(String[] args){
		//1.定義3個int變量h1,h2,h3,分別代表三個和尚的身高
		int h1 = 150, h2 = 210, h3 = 165;
		
		//2.使用三元運算符先求出h1和h2的最大值,保存int變量temp中
		int temp = h1 > h2 ? h1 : h2;
		
		//3.再使用三元運算符先求出temp和h3的最大值,保存int變量max中
		
		int max = temp > h3 ? temp : h3;
		
		//4.最後max中的值就是3個int數據的最大值,直接打印輸出
		System.out.println("最大值: "+max);
	}
}

4.鍵盤錄入Scanner

import java.util.Scanner;//只要在我們的代碼中加上這句話,就可以使用Scanner類
/*
	數據輸入: 獲取到鍵盤錄入的數據,到程序當中
		java中的鍵盤錄入功能,被放在了java.util包中的Scanner
	
	數據類型: 
		基本類型: 四類八種
		引用類型: 除了基本類型,剩餘的都是引用類型
		
		Scanner也是一個引用類型
	引用類型: 有自己的固有的使用的格式
	
	Scanner使用的步驟:							目前是固定的步驟,先記住
		1.導包: 告訴JVM我們要使用的東西在哪裏
			import 路徑.類名;
			import java.util.Scanner;
			
		2.創建對象
			Scanner sc = new Scanner(System.in);
			
		3.使用
			sc.nextInt()方法: 獲取鍵盤錄入的int數字		
*/
public class Demo08Scanner {
	public static void main(String[] args){
		//2.創建對象
		Scanner sc = new Scanner(System.in);
		System.out.println("哥們,請您輸入一個整數: ");
		
		//3.使用: 獲取用戶從鍵盤錄入的數據
		int num = sc.nextInt();//10000
		
		System.out.println("哥們您輸入的數據是: "+num);
		
	}
}

/*
	需求：
		一座寺廟裏住着三個和尚，他們的身高要求從鍵盤錄入，
		請用程序實現獲取這三個和尚的最高身高。
		
	分析:
		1.導包: import java.util.Scanner;
		2.創建對象: Scanner sc = new Scanner(System.in);
		3.獲取鍵盤錄入的三個int數據,並分別保存int變量h1,h2,h3中
		4.使用三元運算符先求出h1和h2的最大值,保存int變量temp中
		5.再使用三元運算符先求出temp和h3的最大值,保存int變量max中
		6.最後max中的值就是3個int數據的最大值,直接打印輸出
*/
public class Demo08SanYuan {
	public static void main(String[] args){
		//1.導包: import java.util.Scanner;
		//2.創建對象: Scanner sc = new Scanner(System.in);
		Scanner sc = new Scanner(System.in);
		
		//3.獲取鍵盤錄入的三個int數據,並分別保存int變量h1,h2,h3中
		System.out.println("請輸入第一個和尚的身高: ");
		int h1 = sc.nextInt();//180
		
		System.out.println("請輸入第二個和尚的身高: ");
		int h2 = sc.nextInt();//210
		
		System.out.println("請輸入第三個和尚的身高: ");
		int h3 = sc.nextInt();//165
		
		//4.使用三元運算符先求出h1和h2的最大值,保存int變量temp中
		int temp = h1 > h2 ? h1 : h2;//210
		
		//5.再使用三元運算符先求出temp和h3的最大值,保存int變量max中
		int max = temp > h3 ? temp : h3;//210
		
		//6.最後max中的值就是3個int數據的最大值,直接打印輸出
		System.out.println("三個和尚的最大身高: "+max);
	}
}

四.day04內容

1.if語句的第一種格式

package com.itheima01_fuxi;
/*
    if語句的第一種格式          if: 如果
        1.格式:
            if(關係表達式){
                語句體;
            }
            其它語句;

        2.執行流程
            (1)首先計算關係表達式的結果,看是true,還是false
            (2)如果關係表達式的結果是true,執行語句體,接着繼續執行其它語句
            (3)如果關係表達式的結果是false,不執行語句體,直接執行其它語句

        3.練習:
            (1)需求：判斷a和b的值是否相等，如果相等，就在控制檯輸出：a等於b
            (2)需求：判斷a和c的值是否相等，如果相等，就在控制檯輸出：a等於c

        4.注意:
            (1)if語句的第一種格式: 只適用於有一個條件的情況  理解爲: 有 和  無的情況
            (2)語句體要麼執行,要麼不執行,由()中的關係表達式的結果決定
            (2){}中如果只有一條語句,那麼{}可以省略     建議初學者: 保留{}
 */
public class Demo02If {
    public static void main(String[] args) {
        System.out.println("main...start....");
        //定義2個int變量
        int a = 10, b = 20;

        //判斷a和b的值是否相等
        if(a == b){
            //如果相等，就在控制檯輸出：a等於b
            System.out.println(a+"等於"+b);
        }

        //定義1個int變量
        int c = 10;

        //判斷a和c的值是否相等
        if(a == c){
            //如果相等，就在控制檯輸出：a等於c
            System.out.println(a+"等於"+c);
        }

        System.out.println("main...end....");
    }
}

2.if語句的第二種格式

/*
    if語句的第二種格式:
        1.格式:           if: 如果      else: 否則
            if(關係表達式) {
                語句體1;
            } else {
                語句體2;
            }
            其它語句;

        2.執行流程:
            (1)首先計算關係表達式的結果,看是true,還是false
            (2)如果關係表達式的結果是true,執行語句體1,繼續執行其它語句
            (3)如果關係表達式的結果是false,執行語句體2,繼續執行其它語句

        3.練習(鍵盤錄入):

            需求：判斷a是否大於b，如果是，在控制檯輸出：a的值大於b，否則，在控制檯輸出：a的值不大於b
                分析:
                    (1)導包: import java.util.Scanner;
                    (2)創建: Scanner sc = new Scanner(System.in);
                    (3)使用: sc.nextInt()獲取鍵盤錄入的整數
                    (4)使用if-else 對鍵盤錄入的兩個int數字進行判斷,並輸出對應的結果

        4.注意:
            (1)if-else語句: 適用於有兩個條件的情況
            (2)語句體1和語句體2,只(必須)有一個會被執行
 */
public class Demo03IfElse {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //(2)創建:
        Scanner sc = new Scanner(System.in);

        //(3)獲取鍵盤錄入的兩個整數
        System.out.println("請輸入第一個整數: ");
        int a = sc.nextInt();//5

        System.out.println("請輸入第二個整數: ");
        int b = sc.nextInt();//5

        //(4)使用if-else 對鍵盤錄入的兩個int數字進行判斷,並輸出對應的結果
        if(a == b) {//true
            System.out.println(a+"等於"+b);
        } else {
            System.out.println(a+"不等於"+b);
        }

        System.out.println("main...end...");
    }
}

3.if語句的第三種格式

/*
    if語句的第三種格式:
        1.格式:
            if(關係表達式1) {
                語句體1;
            } else if(關係表達式2) {
                語句體2;
            }
            ...
            else if(關係表達式n) {
                語句體n;
            } else {
                語句體n+1;
            }
            其它語句;

        2.執行流程:
            (1)首先計算關係表達式1的值
            (2)如果值爲true就執行語句體1；如果值爲false就計算關係表達式2的值
            (3)如果值爲true就執行語句體2；如果值爲false就計算關係表達式3的值
            (4)…
            (5)如果沒有任何關係表達式爲true，就執行語句體n+1。

        3.注意:
            (1)適用於有多種(2種以上)條件的情況
            (2)語句體1到語句體n+1,只有一條語句會被執行
            (3)最後一個else作用: 做收尾工作,如果所有的條件都不成立(false),執行最後一個else中的語句體
            (4)最後一個else,是沒有寫if的
        
        4.if語句第三種格式練習
        	需求:
            	鍵盤錄入一個星期數(1,2,...7)，輸出對應的星期一，星期二，...星期日

        	輸出格式:
            	輸入 1    輸出 星期一
           		輸入 2    輸出 星期二
            	輸入 3    輸出 星期三
            	輸入 4    輸出 星期四
            	輸入 5    輸出 星期五
            	輸入 6    輸出 星期六
            	輸入 7    輸出 星期日
            	輸入      其它數字 輸出 數字有誤

        	實現步驟:
            	1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
            	2.獲取鍵盤錄入的整數,保存int變量week中
            	3.因爲week變量中的數據有7+1種情況,所以使用if語句的第三種格式對week的值進行判斷
                	並分別輸出不同的結果
 */
 public class Demo06IfElseWeek {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
        Scanner sc = new Scanner(System.in);

        //2.獲取鍵盤錄入的整數,保存int變量week中
        System.out.println("請您輸入一個1到7之間的整數: ");
        int week = sc.nextInt();//8

        // 3.因爲week變量中的數據有7+1種情況,所以使用if語句的第三種格式對week的值進行判斷
        // 並分別輸出不同的結果
        if(week ==1) {
            System.out.println("星期一");
        } else if(week == 2) {
            System.out.println("星期二");
        } else if(week == 3) {
            System.out.println("星期三");
        } else if(week == 4) {
            System.out.println("星期四");
        } else if(week == 5) {
            System.out.println("星期五");
        } else if(week == 6) {
            System.out.println("星期六");
        } else if(week == 7) {
            System.out.println("星期日");
        } else {//else: 上面的所有情況都不成立,就直接執行else當中的代碼
            System.out.println("您輸入的數據有誤,火星來的吧....");
        }

        System.out.println("main...end...");
    }
}

/*
    if語句第三種格式練習題目:

        需求:
            小明快要期末考試了，小明爸爸對他說，會根據他不同的考試成績，送他不同的禮物，假如你可以控制小明的得分，
            請用程序實現小明到底該獲得什麼樣的禮物，並在控制檯輸出。

        獎勵規則:
            95~100 山地自行車一輛  包含95 和 100
            90~94 遊樂場玩一次     包含90 和 94
            80~89 變形金剛玩具一個  包含80 和 89
            80以下 胖揍一頓         不包含80

        實現步驟:
            1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
            2.獲取鍵盤錄入的一個0到100之間的整數,保存到int變量score當中
            3.因爲變量score中的數據有4+1種情況,所以使用if語句的第三種格式進行判斷,並輸出對應的結果

 */
public class Demo07IfElseScore {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
        Scanner sc = new Scanner(System.in);

        //2.獲取鍵盤錄入的一個0到100之間的整數,保存到int變量score當中
        System.out.println("請輸入一個0到100之間的整數代表考試成績: ");
        int score = sc.nextInt();//50

        //3.因爲變量score中的數據有4+1種情況,所以使用if語句的第三種格式進行判斷,並輸出對應的結果
        if(score>=95 && score<=100){
            //95~100 山地自行車一輛
            System.out.println("山地自行車一輛");
        } else if(score>=90 && score<=94){
            //90~94 遊樂場玩一次
            System.out.println("遊樂場玩一次");
        } else if(score>=80 && score<=89) {
            //80~89 變形金剛玩具一個
            System.out.println("變形金剛玩具一個");
        } else if(score<0 || score>100){//<0 或者 >100的成績都是非法的成績
            System.out.println("您輸入的成績是非法的.....");
        } else {//只要進入這個else必然說明創建  score<80 並且 score>=0
            //80以下 胖揍一頓
            System.out.println("胖揍一頓");
        }
        System.out.println("main...end...");
    }
}

4.switch語句

注意:
(1)break: 用來結束switch語句的
(2)default: 如果所有的case後的常量值和switch()中的表達式的值都不匹配,直接執行default中的語句體
(3)switch後的()中的表達式的結果只能是以下數據類型:
基本類型: byte/short/char/int
引用類型: String類型/枚舉類型
(4)case的順序是可以顛倒的,前提,每個case後面都有break
(5)把switch後()中表達式的值: 理解爲 被檢測量

/*
    switch語句
        1.格式:
            switch(表達式) {
                case 常量值1:
                    語句體1;
                    break;
                case 常量值2:
                    語句體2;
                    break;
                ...
                case 常量值n;
                    語句體n+1;
                    break;
                default:
                    語句體n+;
                    break;
            }
            其它語句;
        2.執行流程:
            (1)首先計算出表達式的值
            (2)其次，和case依次比較，一旦有對應的值，就會執行相應的語句，在執行的過程中，遇到break就會結束。
            (3)最後，如果所有的case都和表達式的值不匹配，就會執行default語句體部分，然後程序結束掉。

        3.練習:
            根據不同的int數字,輸出字符串

        4.注意:
            (1)break: 用來結束switch語句的
            (2)default: 如果所有的case後的常量值和switch()中的表達式的值都不匹配,直接執行default中的語句體
            (3)switch後的()中的表達式的結果只能是以下數據類型:
                基本類型: byte/short/char/int
                引用類型: String類型/枚舉類型
            (4)case的順序是可以顛倒的,前提,每個case後面都有break
            (5)把switch後()中表達式的值: 理解爲 被檢測量


 */
public class Demo01Switch {
    public static void main(String[] args) {
        System.out.println("main....start....");
        int num = 1;
        switch (num) {

            case 1:
                System.out.println("你好!!!!");
                break;

            case 2:
                System.out.println("我好!!!!");
                break;

            case 3:
                System.out.println("大家好纔是真的好!!!!");
                break;

            default:
                System.out.println("他好,我也好!!!!");
                break;
        }
        System.out.println("main....end....");
    }
}

case穿透

/*
    switch語句練習-春夏秋冬(課後使用if語句第三種格式完成)

    需求：
        一年有12個月，分屬於春夏秋冬4個季節，鍵盤錄入一個月份，請用程序實現判斷該月份屬於哪個季節，並輸出。

    演示效果:
        輸入： 1、2、12 輸出：冬季
        輸入： 3、4、5 輸出：春季
        輸入： 6、7、8 輸出：夏季
        輸入： 9、10、11 輸出：秋季
        輸入：其它數字 輸出：數字有誤

    實現步驟:
        1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
        2.獲取鍵盤錄入的整數(代表月份),保存到int變量month中
        3.使用switch語句判斷month中值,並輸出對應的結果

    發現問題:
        多個case後面的代碼重複,可以進行優化

    解決方案:
        利用case穿透的原理?
        在switch語句中，如果case的後面不寫break，將出現穿透現象，
        也就是不會在判斷下一個case的值，直接向後運行，直到
        遇到break，或者整體switch結束。

        1.找到case的入口處
        2.後面就不再和case後面的值做匹配的操作

        
 */
public class Demo03SwitchMonth {
    public static void main(String[] args) {
        System.out.println("main....start....");
        //1.創建鍵盤錄入Scanner對象(1.導包 2.創建)
        Scanner sc = new Scanner(System.in);

        //2.獲取鍵盤錄入的整數(代表月份),保存到int變量month中
        System.out.println("請輸入一個整數(1到12之間)代表月份:");
        int month = sc.nextInt();//3

        //3.使用switch語句判斷month中值,並輸出對應的結果
        switch (month) {
            case 1:

            case 2:

            case 12:
                System.out.println("冬季");
                break;
            case 3://入口

            case 4:

            case 5:
                System.out.println("春季");
                break;
            case 6:

            case 7:

            case 8:
                System.out.println("夏季");
                break;
            case 9:

            case 10:

            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("您輸入的數字有誤~~~~~~~~~~~~~~~~");
                break;
        }
        System.out.println("main....end....");
    }
}

五.day05內容

1.循環的組成

/*
    循環結構
        1.概念: 重複的執行某段固定的代碼

        2.循環的組成:(手寫100次HelloWorld)
            (1)【初始化表達式1】準備工作:筆墨伺候,最優先唯一執行一次的操作
            (2)【循環條件2】條件判斷:每次書寫前,判斷一下,要不要寫
            (3)【循環體3】循環所要進行的操作:手寫一個HelloWorld案例
            (4)【步進表達式4】掃尾的工作:每寫一次HelloWorld,計數(+1)

        3.執行流程:
            (1),(2),(3),(4) --> (2),(3),(4) --> ... --> 直到循環條件2的結果爲false的時候,結束了循環了

        4.循環分類:
            (1)for循環:           最長用的
            (2)while循環:         一般常用的
            (3)do-while循環:      最不常用的
 */
public class Demo01Loop {
}

2.for循環語句

/*
    for循環
        1.格式:
            for( 初始化表達式1; 布爾表達式2; 步進表達式4 ) {
                循環體3;
            }
            其它語句;

        2.執行流程:
            1,2,3,4 --> 2,3,4 --> ... --> 直到布爾表達式2的結果爲false,結束for循環,執行for循環後面的其它語句

        3.注意:
            (1)在一個for循環結構中: 初始化表達式1只會執行一次
            (2)布爾表達式2: 結果必須爲true或者false
            (3)循環體3: 一條/多條語句

        4.練習:
            輸出10次HelloWorld

 */
public class Demo02For {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("------------------");

        //使用for循環
        /*
            第一次:
                i == 1 i<=3 1<=3 true 執行輸出 執行i++ i變成2

            第二次:
                i<=3 ==> 2<=3 ==> true 執行輸出 執行i++ i變成3

            第三次:
                i<=3 ==> 3<=3 ==> true 執行輸出 執行i++ i變成4

            第四次:
                i<=3 ==> 4<=3 ==> false 結束for循環,執行for循環後面的語句 輸出"main....end...."
         */
        for(int i = 1; i<=3;i++){

            System.out.println("HelloWorld...."+i);

        }

        System.out.println("main....end....");
    }
}

練習: 求和

/*
    練習:
        求1-100之間的所有數字之和,偶數和與奇數和，並分別打印結果在控制檯輸出

    實現步驟:
        1.定義3個int類型求和變量sum(所有數字之和),sum1(奇數數字之和),sum2(偶數數字之和)初始值0
        2.使用for循環獲取1-100之間的數字
        3.把當前數字累加到求和變量sum中,因爲sum用來求所有數字之和的
        4.判斷如果當前數字是偶數,把當前數字累加到求和變量sum2中,因爲sum2用來求所有數字偶數之和的
        5.判斷如果當前數字是奇數,把當前數字累加到求和變量sum1中,因爲sum1用來求所有數字奇數之和的
        6.打印輸出

 */
public class Demo06ForSum {
    public static void main(String[] args) {

        //1.定義3個int類型求和變量sum(所有數字之和),sum1(奇數數字之和),sum2(偶數數字之和)初始值0
        int sum = 0,sum1 = 0,sum2 = 0;

        //2.使用for循環獲取1-100之間的數字
        for (int i = 1; i <= 100; i++) {
            //3.把當前數字累加到求和變量sum中,因爲sum用來求所有數字之和的
            sum += i;

            if (i % 2 == 0) {
                //4.判斷如果當前數字是偶數,把當前數字累加到求和變量sum2中,因爲sum2用來求所有數字偶數之和的
                sum2 += i;
            } else {
                //5.判斷如果當前數字是奇數,把當前數字累加到求和變量sum1中,因爲sum1用來求所有數字奇數之和的
                sum1 += i;
            }

        }
        //6.打印輸出
        System.out.println("1-100之間所有數字之和: "+sum);
        System.out.println("1-100之間所有偶數數字之和: "+sum2);
        System.out.println("1-100之間所有奇數數字之和: "+sum1);
    }
}

練習: 水仙花數

/*
    練習: 計數器的思想
        統計“水仙花數”一共有多少個，並在控制檯輸出個數
        要求:
            定義一個方法,判斷數字是否是水仙花數字

    解釋：什麼是水仙花數？
            水仙花數，指的是一個三位數(100到999)，個位、十位、百位的數字立方和等於原數
            例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153

    實現步驟:
        1.定義int變量count,作用是用來計數的,初始值0
        2.使用for循環獲取所有的三位數字
        3.求出當前數字的個位,十位,百位 分別 保存到int變量 ge(個位),shi(十位),bai(百位)中
        4.求出當前數字的個位,十位,百位的立方和,保存到int變量sum當中
        5.判斷如果前數字的個位,十位,百位的立方和sum等於該數字本身,說明是水仙花數字
            5.1 計數器count加1
            5.2 打印水仙花數字
        6.for循環結束後,打印個數count中的內容
 */
public class Demo08ForWaterFlowers {
    public static void main(String[] args) {
        //1.定義int變量count,作用是用來計數的,初始值0
        int count = 0;

        //2.使用for循環獲取所有的三位數字
        for (int num = 100; num <= 999; num++) {
            //3.求出當前數字的個位,十位,百位 分別 保存到int變量 ge(個位),shi(十位),bai(百位)中
            int ge = num%10;
            int shi = num/10%10;
            int bai = num/100%10;

            //4.求出當前數字的個位,十位,百位的立方和,保存到int變量sum當中
            //5.判斷如果前數字的個位,十位,百位的立方和sum等於該數字本身,說明是水仙花數字
            if ((ge*ge*ge + shi*shi*shi + bai*bai*bai) == num) {
                //5.1 計數器count加1
                count++;

                //5.2 打印水仙花數字
                System.out.println(num);
            }

        }
        //6.for循環結束後,打印個數count中的內容
        System.out.println("以上水仙花數字總個數: "+count+" 個");
    }
}

練習: 按照要求打印符合條件的數字

/*
    練習:
        全國計算機等級考試三級的練習題目:
        1.打印所有四位數中 個位 + 千位 == 百位 + 十位 的數字
        2.打印要求5個一行,中間用空格隔開
        3.最後要打印符合條件的數字的總數量

    實現步驟:
        1.定義int變量count,初始值0
        2.使用for循環獲取所有的四位數字
        3.獲取當前四位數字的個位,十位,百位,千位,分別保存到變量ge,shi,bai,qian中
        4.使用if判斷當前四位數字如果滿足條件(個位 + 千位 == 百位 + 十位)
        4.1 計數器+1
        4.2 打印該數字(不換行)
        4.3 判斷如果當前打印的數字是這一行的第五個數字的話 打印換行
        5.for循環結束,打印計數器的值,就是符合條件的四位數的數量
 */
public class Demo05PrintNums {
    public static void main(String[] args) {
        //1.定義int變量count,初始值0
        int count = 0;

        //2.使用for循環獲取所有的四位數字
        for (int num = 1000; num <= 9999; num++) {
            //3.獲取當前四位數字的個位,十位,百位,千位,分別保存到變量ge,shi,bai,qian中
            int ge = num%10;//個位
            int shi = num/10%10;//十位
            int bai = num/100%10;//百位
            int qian = num/1000%10;//千位

            //4.使用if判斷當前四位數字如果滿足條件(個位 + 千位 == 百位 + 十位)
            if((ge + qian) == (shi + bai)) {
                //4.1 計數器+1
                count++;
                //4.2 打印該數字(不換行)
                System.out.print(num+" ");

                //4.3 判斷如果當前打印的數字是這一行的第五個數字的話 打印換行
                if (count % 5 == 0) {
                    System.out.println();
                }
            }

        }
        //5.for循環結束,打印計數器的值,就是符合條件的四位數的數量
        System.out.println("以上滿足條件的四位數總共有 "+count+" 個");
    }
}

3.while循環

/*
    while循環
        1.格式:
            初始化表達式1;
            while( 布爾表達式2 ) {
                循環體3;
                步進表達式4;
            }
            其它語句;

        2.執行流程:
            1,2,3,4 --> 2,3,4 --> ... --> 直到布爾表達式2的結果爲false,結束while循環,執行while循環後面的其它語句

        3.注意:
            (1)在一個while循環結構中: 初始化表達式1只會執行一次
            (2)布爾表達式2: 結果必須爲true或者false
            (3)循環體3: 一條/多條語句

        4.練習:
            while循環練習_輸出10次HelloWorld
 */
public class Demo01While {
    public static void main(String[] args) {
        //for循環
        for (int i = 1; i <= 10; i++) {
            System.out.println("HelloWorld....for..."+i);
        }

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

        //while循環
        int j = 1;

        while(j<=3) {
            System.out.println("HelloWorld....while..."+j);
            j++;
        }

        System.out.println("main....end......");

    }
}

練習: 珠穆拉瑪峯案例

/*
    while循環練習2：珠穆朗瑪峯
        需求：世界最高山峯是珠穆朗瑪峯(8844.43米=8844430毫米)，假如我有一張足夠大的紙，它的厚度是0.1毫米。
        請問，我摺疊多少次，可以折成珠穆朗瑪峯的高度?

        假設紙的高度: zh = 0.1;
        折一次:
            zh = zh *2;
            zh *=2;

    實現步驟:
        1.定義double變量paper,表示紙張的厚度,初始值0.1
        2.定義int變量zf,表示珠穆朗瑪峯的高度,初始值8844430
        3.定義int變量count,記錄摺疊紙的次數,初始值0
        4.使用while循環進行摺紙的操作: 循環條件 只要紙張的厚度 < 珠穆朗瑪峯的高度 就需要再折一次
            (1)折一次紙張
            (2)計數器+1
        5.while循環結束後,打印計數器count的值,就代表摺疊紙張的次數

 */
public class Demo02While {
    public static void main(String[] args) {
        //1.定義double變量paper,表示紙張的厚度,初始值0.1
        double paper = 0.1;

        //2.定義int變量zf,表示珠穆朗瑪峯的高度,初始值8844430
        int zf = 8844430;

        //3.定義int變量count,記錄摺疊紙的次數,初始值0
        int count = 0;

        //4.使用while循環進行摺紙的操作: 循環條件 只要紙張的厚度 < 珠穆朗瑪峯的高度 就需要再折一次
        while(paper < zf) {//paper > zf 或者 paper == zf: 結束while循環
            //(1)折一次紙張
            paper *= 2;//0.2,0.4,0.8,1.6,3.2...

            //(2)計數器+1
            count++;

        }
        //5.while循環結束後,打印計數器count的值,就代表摺疊紙張的次數
        System.out.println("總共摺疊的次數: "+count);
        System.out.println("摺疊後紙張的總厚度: "+paper);
    }
}

4.do-while循環

/*
    do-while
        1.格式:
            初始化表達式1;
            do {
                循環體3;
                步進表達式4;
            } while(布爾表達式2);
            其它語句;

        2.執行流程:
            1,3,4 --> 2,3,4 --> .... --> 直到布爾表達式2的結果爲false,結束do-while循環,執行do-while後面的其它語句


        3.練習:
            輸出10次HelloWorld

        4.注意:
            while的()後,必須寫分號 不寫報錯
 */
public class Demo02DoWhile {
    public static void main(String[] args) {

        int count  = 1;

        do {

            System.out.println("HelloWorld~~~~~~~"+count);

            count++;//2,3,4

        } while(count <=3 );//2<=3 true 回到do{}中  //3<=3 true 回到do{}中 //4<=3 false 結束do-while 執行後續其它語句

        System.out.println("main.....end....");

        System.out.println("count="+count);
    }
}

5.三種循環的區別

/*
    三種循環的區別總結
        1.建議使用的順序:for,while,do-while

        2.循環次數確定的話,建議使用for,循環次數不確定建議使用while(明天猜數字遊戲案例)

        3.do-while循環來講的話,至少執行一次

        4.while和do-while循環而言,循環結束後,初始化條件中定義的變量可以繼續使用,
            但是for循環的不能使用(在for循環內部定義初始化語句)

*/
public class Demo03LoopDiff {
    public static void main(String[] args) {
        //for: 可以一次都不執行(第一次計算布爾表達式的結果: false)
        //for循環上定義的變量i: 只在整個for循環內部有效
        for(int i = 1;i>2;i++) {
            System.out.println("Hello....for...."+i);
        }

        //System.out.println("for....end...."+i);//錯誤: i只能在for循環中使用
        System.out.println("for....end....");

        //while: 可以一次都不執行(第一次計算布爾表達式的結果: false)
        int j = 1;
        while (j > 2) {
            System.out.println("Hello....while...."+j);
            j++;
        }
        System.out.println("while....end...."+j);//...1



        //3.do-while循環來講的話,至少執行一次
        int k = 1;
        do {
            System.out.println("Hello...do...while..."+k);
            k++;
        } while(k>5);//2>5: false
        System.out.println("do...while....end....."+k);//....2

    }
}

6.死循環

/*
    死循環:
        也就是循環中的條件永遠爲true，死循環的是永不結束的循環。

    for循環的:
        死循環格式一: for芬芬
            for(;;){...}

        死循環格式二:                     -------------------推薦使用
            while(true) { ... }
 */
public class Demo04DeadLoop {
    public static void main(String[] args) {
        //for死循環
       /* for (;;) {//如果不寫布爾表達式: 默認就是true
            System.out.println("Hello");
        }*/
        System.out.println("-----------------------");

        //while死循環
        while (true) {
            System.out.println("Hello");
        }
    }
}

六.day06內容

1.循環控制語句:

(1)break:    直接結束所在的循環語句,繼續執行循環語句後面的其它語句
    a.不能單獨使用
    b. 可以使用在switch語句中
    c. 可以使用在循環語句中

(2)continue: 提前結束本次循環,繼續進行下次循環
    a. 不能單獨使用
    b. 只能使用在循環語句中

/*
    break的練習:
        循環控制語句:
        1.break:    直接結束所在的循環語句,繼續執行循環語句後面的其它語句
            (1) 不能單獨使用
            (2) 可以使用在switch語句中
            (3) 可以使用在循環語句中
 */
public class Demo03Break {
    public static void main(String[] args) {

        for (int i = 1; i <= 10; i++) {
            //當i的值是5時,i%5的結果是0,0==0的結果是true,執行break,
            //一旦執行break,直接結束break所在的for循環,執行for循環後面的其它語句 sout("main...end...")
            if (i % 5 == 0) {

                break;

            }

            System.out.println("HelloWorld....." + i);
        }

        System.out.println("main....end....");
    }
}

/*
    循環控制語句:
        1.continue: 提前結束本次循環,繼續進行下次循環
            (1) 不能單獨使用
            (3) 只能使用在循環語句中
 */
public class Demo05Continue {
    public static void main(String[] args) {

        for (int i = 1; i <= 10; i++) {
            /*
                當i的值是5,10 的時候,i%5==0 結果是true,執行continue
                一旦執行continue,結束本次循環(本次循環循環體中continue後面的代碼不再執行),
                繼續進行下次循環(步進表達式)
             */
            if (i % 5 == 0) {

                continue;

            }

            System.out.println("HelloWorld...." + i);
        }
    }
}

2.循環嵌套

/*
    循環嵌套
        1.概念:
            是指一個循環的循環體是另一個循環。比如for循環裏面還有一個for循環，就是嵌套循環。
            總共的循環次數=外循環次數*內循環次數

        2.格式:
            for(...;...;...) {
                for(...;...;...){

                }
            }
        3.練習:
            教練員安排運動員跑圈
            教練總共安排3次,每次讓運動員跑3圈

        4.注意事項:
            外層循環執行一次,內層循環執行完整的一遍
            (1)外層循環的初始化語句 int i = 1 執行幾次?   1次
            (2)內層循環的初始化語句 int j = 1 執行幾次?   3次
            (3)內層循環的輸出語句,總共執行藉此?
                3 * 3 = 9次
 */
public class Demo01ForFor {
    public static void main(String[] args) {
        /*
            執行流程:
                i = 1 1<=3 true
                    j: 1 2 3   最後j變成4,但是j<=3 ==> 4<=3 false 結束內層循環

                i = 2 2<=3 true
                    j: 1 2 3   最後j變成4,但是j<=3 ==> 4<=3 false 結束內層循環

                i = 3 3<=3 true
                    j: 1 2 3   最後j變成4,但是j<=3 ==> 4<=3 false 結束內層循環

                i = 4 4<=3 false 結束外層循環了
         */
        for(int i = 1;i<=3;i++) {   //外層循環



            System.out.println("教練員第"+i+"次安排運動員跑3圈: ");



            for(int j = 1;j<=3;j++) {//內層循環

                System.out.println("運動員跑第"+i+"次,第"+j+"圈");

            }



        }
    }
}

public static void main(String[] args) {
    int count = 0;
    for(int i = 1;i<5;i++) {//4次
        for(int j = 3;j<9;j++) {//6次
            count++;//執行24次
        }
    }
    System.out.println(count);
}

3.隨機數字

/*
    java.util.Random類:  是用於產生隨機數字的
        和Scanner一樣也是一種引用類型
        使用步驟和Scanner也是一樣的

    Scanner:
        1.導包: import java.util.Scanner;
        2.創建: Scanner sc = new Scanner(System.in);
        3.使用:
            int num = sc.nextInt();//獲取鍵盤錄入的整數
            double num = sc.nextDouble();//獲取鍵盤錄入的小數


    步驟:
        1.導包:   import java.util.Random;
        2.創建:   Random r = new Random();
        3.使用:
            int num = r.nextInt();
                作用: 產生一個int範圍(正負21億)內的隨機數字,賦值給int變量num

            int num = r.nextInt(int n);
                作用: 產生一個大於等於0並且小於等於n-1內的隨機數字,賦值給int變量num

            int num = r.nextInt(10);//產生0到9範圍的隨機數字(包含0和9的)[0,9]
                [0,9) 從0到9,包含0,不包含9

        4.練習:
            生成3個10以內的隨機整數的操作
            要求: 0到10,包含0但不能包含10
                r.nextInt(10)



 */
public class Demo01Random {
    public static void main(String[] args) {
        //創建隨機數Random類的對象
        Random r = new Random();


        //生產int範圍內的隨機數字
        int num = r.nextInt();

        System.out.println(num);

        //再產生3個 int範圍內的隨機數字
        for (int i = 0; i < 3; i++) {
            int num2 = r.nextInt();
            System.out.println(num2);
        }

        System.out.println("-----------------------");
        //生成3個10以內的隨機整數的操作
        //要求: 0到10,包含0但不能包含10
        for (int i = 0; i < 3; i++) {
            int num3 = r.nextInt(10);
            System.out.println(num3);
        }
    }

}

練習:猜數字遊戲

/*
    Random練習-猜數字

        1.需求：
            程序自動生成一個1-100之間(包含1和100)的數字，使用程序實現猜出這個數字是多少？

        2.效果：
            如果猜的數字比真實數字大，提示你猜的數據大了
            如果猜的數字比真實數字小，提示你猜的數據小了
            如果猜的數字與真實數字相等，提示恭喜你猜中了
            [1,100]
            [0,99] + 1
            r.nextInt(100) + 1

        3.使用的知識點
            (1)使用Random類
                nextInt(100)+1:   產生 1-100之間(包含1和100)的數字

            (2)創建鍵盤錄入Scanner對象
                nextInt(): 獲取整數
            (3)需要把用戶輸入的數字和產生的隨機數字進行比較,有三種情況,使用if語句的第三種格式
            (4)無法確定用戶多少次可以猜測正確: 循環次數不確定 while(true)
            (5)用戶猜對了,停止程序運行: break

        4.實現步驟:
            (1)創建產生隨機數的Random類的對象r(1.導包 2.創建)
            (2)產生一個1到100之間的隨機數字,保存到int變量guessNum中,以供用戶猜測
            (3)創建鍵盤錄入Scanner類的對象
            (4)獲取用戶從鍵盤錄入的整數數字,保存int變量inputNum中
            (5)用戶輸入的數字和產生的隨機數字進行比較: 有3種結果,所以使用if語句的第三種格式
                a.如果 用戶輸入的數字inputNum 大於 產生的 隨機數字 guessNum: 提示"你猜的數據大了"
                b.如果 用戶輸入的數字inputNum 小於 產生的 隨機數字 guessNum: 提示"你猜的數據小了"
                c.如果 用戶輸入的數字inputNum 等於 產生的 隨機數字 guessNum: 提示"恭喜你猜中了",使用break結束循環
            (6)以上步驟4-5是一個循環的過程,循環次數不確定,使用while(true)
 */
public class Demo03GuessNum {
    public static void main(String[] args) {
        //(1)創建產生隨機數的Random類的對象r(1.導包 2.創建)
        Random r = new Random();

        //(2)產生一個1到100之間的隨機數字,保存到int變量guessNum中,以供用戶猜測
        int guessNum = r.nextInt(100)+1;//[0,99]+1

        //(3)創建鍵盤錄入Scanner類的對象
        Scanner sc = new Scanner(System.in);

        //(6)以下步驟4-5是一個循環的過程,循環次數不確定,使用while(true)
        while(true) {
            //(4)獲取用戶從鍵盤錄入的整數數字,保存int變量inputNum中
            System.out.println("請輸入您猜測的數字(1-100之間的整數):");
            int inputNum = sc.nextInt();

            //(5)用戶輸入的數字和產生的隨機數字進行比較: 有3種結果,所以使用if語句的第三種格式
            if (inputNum > guessNum) {
                //a.如果 用戶輸入的數字inputNum 大於 產生的 隨機數字 guessNum: 提示"你猜的數據大了"
                System.out.println("您猜的數據"+inputNum+"大了");
            } else if (inputNum < guessNum) {
                //b.如果 用戶輸入的數字inputNum 小於 產生的 隨機數字 guessNum: 提示"你猜的數據小了"
                System.out.println("您猜的數據"+inputNum+"小了");
            } else {//不用寫 if(inputNum == guessNum)
                //c.如果 用戶輸入的數字inputNum 等於 產生的 隨機數字 guessNum: 提示"恭喜你猜中了"
                System.out.println("恭喜您猜對了");
                break;//結束while循環
            }
        }

    }
}

七.day07內容

1.數組變量的定義

/*
    變量中,只能存儲一個數據,新的數據進來,老的數據將被替換,如果要存儲多個數據,需要使用容器

    容器概念
        容器：是將多個數據存儲到一起，每個數據稱爲該容器的元素。
        生活中的容器：水杯，衣櫃，教室

    數組
        1.概念: java中的數組就是一個容器,可以存儲多個數據,但是多個數據的類型必須保持一致
        2.特點:
            (1)可以存儲多個數據
            (2)多個數據的類型必須保持一致
            (3)數組的長度(數組中可以存儲元素的數量)一旦確定,就不可以發生改變

        3.數組是一個引用類型,數組容器變量的定義格式:    記住
            數組是一個容器,數組變量是給該容器起名字的,通過這個名字方便找到這個容器
            數組理解爲教室
            數組變量名: 教室門牌號

            格式一:                                        推薦使用
                數據類型[] 數組名稱;        //理解爲 教室門牌號

            格式二:
                數據類型 數組名稱[];
 */
public class Demo01Array {
    public static void main(String[] args) {
        int num = 10;
        System.out.println(num);
        num = 10000;
        System.out.println(num);

        //80位同學參加考試,每個同學都有考試創建
        //可以定義80個int變量保存每個同學的創建
        int a = 100;
        int b = 90;
        int c = 50;

        //...
        //求總分
        int sum = a + b + c;//總共80個變量
        //求平均分
        int avg = sum/80;//總分/學生數量
        //求最大分和最小分
        System.out.println("-------------------------------------");

        //定義一個int類型的變量,變量名稱d,裏面只能存儲一個整數
        //數據類型 變量名稱;
        int d;
        //System.out.println(d);
        //定義一個存儲int類型數據的數組變量,名稱arrayA
        int[] arrayA;

        //定義一個存儲double類型數據的數組變量,名稱arrayB
        double arrayB[];
    }
}

2.數組的初始化方式一

/*
    數組的第一種初始化方式(動態初始化: 指定長度)
        1.格式:
            數據類型[] 數組名稱 = new 數據類型[長度];
            =號左側:
                數據類型[] 數組名稱; 教室的門牌號

            =號右側:
                new 數據類型[長度];  創建了一間教室

        2.格式解釋:
            (1)左側數據類型: 規定了數組中可以存儲的數據的具體類型,數組中可以存儲哪種類型的數據
            (2)左側[]: 代表是數組
            (3)數組名稱: 就是給數組容器起個名字,方便使用數組容器     教室的門牌號
            (4)new: 就是爲數組容器開闢內存空間的
            (5)右側數據類型: 和左側保持一致
            (6)右側[]中的長度: 規定了數組容器中可以存儲的數據的數量

 */
public class Demo02Array {
    public static void main(String[] args) {

        //1.創建一個int類型的數組,該數組名稱arrayA,可以存儲3個int數據
        int[] arrayA = new int[3];

        //2.創建一個char類型的數組,該數組名稱arrayB,可以存儲5個char數據
        char[] arrayB = new char[5];

        //3.創建一個boolean類型的數組,該數組名稱arrayC,可以存儲2個boolean數據
        boolean[] arrayC = new boolean[2];

        //4.創建一個String類型的數組,該數組名稱arrayD,可以存儲3個String數據
        String[] arrayD = new String[3];
    }
}

3.數組的初始化方式二

/*
    數組的第二種初始化方式(標準格式靜態初始化: 指定數組中的每個元素)
        1.格式:
            數據類型[] 數組名稱 = new 數據類型[]{元素1,元素2,元素3...};
            =號左側:
                數據類型[] 數組名稱; 教室的門牌號

            =號右側:
                new 數據類型[]{元素1,元素2,元素3...};  創建了一間教室,並安排了多個學生

        3.注意:
            右側[]中不用指定數組長度,會根據右側{}中的數組元素計算出數組的長度

 */
public class Demo03Array {
    public static void main(String[] args) {

        //1.創建一個int類型的數組,該數組名稱arrayA,存儲int數據    100,200,300
        int[] arrayA = new int[]{100,200,300};

        //2.創建一個char類型的數組,該數組名稱arrayB,存儲char數據  '真','的','好','想','你'
        char[] arrayB = new char[]{'真','的','好','想','你'};

        //3.創建一個boolean類型的數組,該數組名稱arrayC,存儲2boolean數據  false,true
        boolean[] arrayC = new boolean[]{false,true};

        //4.創建一個String類型的數組,該數組名稱arrayD,存儲String數據 "巖巖","冪冪","冰冰"
        String[] arrayD = new String[]{"巖巖","冪冪","冰冰"};
    }
}

4.數組的初始化方式三

/*
    數組的第三種初始化方式(簡化格式靜態初始化: 指定數組中的每個元素)      ----推薦使用
        1.格式:
            數據類型[] 數組名稱 = {元素1,元素2,元素3...};
            =號左側:
                數據類型[] 數組名稱; 教室的門牌號

            =號右側:
                {元素1,元素2,元素3...};  創建了一間教室,並安排了多個學生

        3.注意:
            (1)數組長度省略,根據{}中的元素計算出來
            (2)雖然沒有寫new,但是底層仍然有new的過程
            (3)動態初始化/標準格式的靜態初始化數組,可以分爲兩步完成
            (4)簡化格式的靜態態初始化數組,不可以分爲兩步完成

 */
public class Demo04Array {
    public static void main(String[] args) {

        //1.創建一個int類型的數組,該數組名稱arrayA,存儲int數據    100,200,300
        int[] arrayA = {100,200,300};

        //2.創建一個char類型的數組,該數組名稱arrayB,存儲char數據  '真','的','好','想','你'
        char[] arrayB = {'真','的','好','想','你'};

        //3.創建一個boolean類型的數組,該數組名稱arrayC,存儲2boolean數據  false,true
        boolean[] arrayC = {false,true};

        //4.創建一個String類型的數組,該數組名稱arrayD,存儲String數據 "巖巖","冪冪","冰冰"
        String[] arrayD = {"巖巖","冪冪","冰冰"};

        int a;//先定義變量
        a = 100;//後賦值
        a = 10000;//重新賦值

        System.out.println("-----------------------");
        //動態初始化數組,可以分爲兩步完成
        float[] arrA;
        arrA = new float[3];
        arrA = new float[30];

        //標準格式的靜態初始化數組,可以分爲兩步完成
        int[] arrB;
        arrB = new int[]{10,20};
        arrB = new int[]{100,200,300};
        //arrB = new double[]{100,200,300};//錯誤的,數據類型不匹配


        //簡化格式的靜態態初始化數組,不可以分爲兩步完成
        int[] arrC;
        //arrC = {1,2,3,5};//不允許

    }
}

5.標準/簡化格式靜態初始化數組的使用

/*
    標準/簡化格式靜態初始化數組的使用
        1.數組名: 代表數組容器在內存空間的地址值,是一個十六進制的數據
        2.數組中的每個元素都有一個唯一的編號: 稱爲索引,但是索引編號從0開始,索引編號的最大值(數組長度-1)
        3.數組元素的訪問:
            數組名[索引編號];
            array[2]: 數組array中索引編號爲2的元素

        4.獲取數組的長度(數組中存儲的元素的數量)
            數組有個屬性length,使用格式:
            int size = 數組名稱.length;

            注意:
                length是數組的屬性,所以使用時後面沒有()

            總結:
                數組元素的索引編號範圍:
                    從0開始,到最大索引(數組長度-1: 數組名稱.length)
 */
public class Demo01UseArray {
    public static void main(String[] args) {
        //定義int變量num,存儲100
        int num = 100;
        System.out.println(num);//100

        //創建int類型的數組,名稱爲array,存儲int數據 10,20,30
        int[] array = {10, 20, 30};//10的編號0,20的編號1,30的編號2

        System.out.println(array);//在內存空間的地址值: [I@1540e19d

        //打印10
        System.out.println(array[0]);//打印數組array中的索引編號爲0的元素值:10

        //打印20
        System.out.println(array[1]);//打印數組array中的索引編號爲1的元素值:20

        //打印30
        System.out.println(array[2]);//打印數組array中的索引編號爲2的元素值:30

        //把10 改成 100
        array[0] = 100;//把int數字100賦值給數組array中的索引爲0的元素中

        //把20 改成 200
        array[1] = 200;//把int數字200賦值給數組array中的索引爲1的元素中

        //把30 改成 300
        array[2] = 300;//把int數字300賦值給數組array中的索引爲2的元素中

        System.out.println(array);//在內存空間的地址值: [I@1540e19d


        //打印100
        System.out.println(array[0]);//打印數組array中的索引編號爲0的元素值:100

        //打印200
        System.out.println(array[1]);//打印數組array中的索引編號爲1的元素值:200

        //打印300
        System.out.println(array[2]);//打印數組array中的索引編號爲2的元素值:300

        //獲取數組的長度
        int count = array.length;
        System.out.println("數組中元素的個數: "+count);
    }
}

6.動態初始化(指定數組長度)初始化數組的使用

/*
    動態初始化(指定數組長度)初始化數組的使用
        1.數組名: 代表數組容器在內存空間的地址值,是一個十六進制的數據
        2.數組中的每個元素都有一個唯一的編號: 稱爲索引,但是索引編號從0開始,索引編號的最大值(數組長度-1)
        3.數組元素的訪問:
            數組名[索引編號];
            array[2]: 數組array中索引編號爲2的元素

        4.獲取數組的長度(數組中存儲的元素的數量)
            數組有個屬性length,使用格式:
            int size = 數組名稱.length;

            注意:
                length是數組的屬性,所以使用時後面沒有()

            總結:
                數組元素的索引編號範圍:
                    從0開始,到最大索引(數組長度-1: 數組名稱.length)
        5.注意:
            動態初始化數組,元素有默認值
            基本類型:
                整數 byte/short/int/long:     0
                小數 float/double:            0.0
                布爾 boolean:                 false
                字符 char:                    空白字符
            引用類型:
                默認值都是null
 */
public class Demo02UseArray {
    public static void main(String[] args) {
        //定義int類型的數組,名稱array,可以存儲3個int數據
        int[] array = new int[3];//該數組中有3個元素,編號爲0,1,2
        System.out.println(array);//數組在內存空間的地址值: [I@1540e19d

        System.out.println(array[0]);//打印數組array中索引編號爲0的元素值,默認值: 0
        System.out.println(array[1]);
        System.out.println(array[2]);

        //把100賦值給數組array中索引編號爲0的元素中
        array[0] = 100;

        //把200賦值給數組array中索引編號爲1的元素中
        array[1] = 200;

        //把300賦值給數組array中索引編號爲2的元素中
        array[2] = 300;

        System.out.println(array);//數組在內存空間的地址值: [I@1540e19d

        System.out.println(array[0]);//打印數組array中索引編號爲0的元素值: 100
        System.out.println(array[1]);
        System.out.println(array[2]);
    }
}

7.數組使用的常見問題

/*
    數組使用的常見問題:
        1.索引越界異常
            java.lang.ArrayIndexOutOfBoundsException
            (1)原因:
                使用了不存在的索引,獲取數組元素
                索引範圍: 從0開始到數組長度-1
            (2)解決方案:
                找到數組索引越界的地方,進行修改

        2.空指針異常
            java.lang.NullPointerException
            (1)原因:
                null是一個引用類型的常量,可以賦值給任意引用類型的變量,
                但是一旦引用類型的變量的值是null,則說明該引用類型的變量不再執行堆內存中的任何空間
                所以將不能再通過該引用類型變量來訪問堆內存空間中的數組元素

            (2)解決方案:
                a.找到引用變量的值是null的地方,進行修改不讓引用變量的值是null
                b.不通過值爲null的引用變量,訪問堆內存空間的內容
 */
public class Demo01ArrayProblems {
    public static void main(String[] args) {
        //創建int類型數組,名稱array,存儲int數據 10,20,30
        int[] array = {10,20,30};
        System.out.println(array);//地址值: [I@1540e19d
        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
        System.out.println(array[5]);//索引5,不存在,報出索引越界異常

        System.out.println("main....end....");

        array = null;
        System.out.println(array);//null

        //System.out.println(array[0]);//空指針異常

    }
}

8.求數組的最大值

/*
    獲取數組元素的最大值
        實現步驟:
            1.定義長度爲5的int數組,數組名array,存儲5個int數據,分別代表顏值
            2.假設數組中索引爲0的元素是最大的,把0索引元素值保存int變量max中
            3.使用for循環獲取後面的(從1索引開始)所有元素
            4.使用if進行判斷,如果數組當前元素值>假設的最大值(max中)
              把數組當前元素重新賦值給變量max
            5.打印max的值

    求最小值/和/平均值?
 */
public class Demo04ArrayMax {
    public static void main(String[] args) {
        //1.定義長度爲5的int數組,數組名array,存儲5個int數據,分別代表顏值
        int[] array = {5,15,2000,10000,100,4000};

        //2.假設數組中索引爲0的元素是最大的,把0索引元素值保存int變量max中
        int max = array[0];

        //3.使用for循環獲取後面的(從1索引開始)所有元素
        for (int i = 1; i < array.length; i++) {
            //4.使用if進行判斷,如果數組當前元素值>假設的最大值(max中)
            if(array[i] > max) {
                //把數組當前元素重新賦值給變量max
                max = array[i];
            }

        }
        //5.打印max的值
        System.out.println("數組元素的最大值: "+max);
    }
}

八.day08內容

1.方法詳解

方法
        1.概念:
            將一段代碼用{}括起來,起個名字,添加必要的修飾符,方便使用

        2.格式(通用/詳細的格式)
            修飾符  返回值類型   方法名稱(數據類型1 變量名稱1,數據類型2 變量名稱2...){
                功能代碼;
                return 返回值;
            }
            注意:
                (1)如果沒有返回值,那麼返回值類型 寫 void ,後面 return ; 可以省略
                (2)如果沒有參數,不用寫參數列表,但是必須要保留()

        3.格式解釋
            (1)修飾符: 目前固定寫法,public static
            (2)返回值類型: 方法功能代碼執行完畢後,返還給方法調用者的結果數據的具體類型
            (3)方法名稱: 給方法起個名字,方便使用,做到見名知意,必須符合標識符命名規則,建議小駝峯原則
            (4)參數列表:
                數據類型: 告訴方法的調用者,在調用方法時傳遞什麼類型的數據
                變量名稱: 用來接收方法調用者,調用方法時傳遞的具體數據的
            (5)功能代碼: 完成具體功能的代碼
            (6)return 返回值:
                作用1: 結束方法
                作用2: 把返回值,返還給方法的調用者

        4.方法的理解(工廠/機器)
            生產汽車的工廠
                原材料: 發動機,變速箱,輪胎                 方法參數
                產出物: BMW750Li, S600, ZT700            方法的返回值

            榨汁機:
                原材料: 水果,水,糖                        方法參數
                產出物: 果汁                              方法的返回值

            如果把生產汽車的工廠看成方法的話:
                原材料是進入工廠的東西,相當於調用方法時,傳遞給方法的具體數據
                產出物是從工廠中出來的東西,相當於調用方法後,方法返回的具體數據

        5.定義方法的三要素
            (1)方法名稱:
            (2)參數列表: 當方法需求中有不確定的因素,需要定義參數列表
            (3)返回值類型: 當方法內部需求中,明確規定"打印...",不需要返回值,也就不需要返回值類型,寫爲void

2.定義無參無返回值方法

/*
    無參數無返回值的方法練習
        定義一個方法，打印該方法內部的兩個數據(方法內部定義的變量)的最大值

    無參數: 方法名稱後()中不寫內容
    無返回值: 返回值類型寫爲void
 */
public class Demo05Method {
    public static void main(String[] args) {

        System.out.println("main....start....");

        //調用方法
        printMax();

        System.out.println("main....end....");
    }

    //定義一個方法，打印該方法內部的兩個數據(方法內部定義的變量)的最大值
    public static void printMax() {
        //求兩個int數據的最大值
        int a = 100;
        int b = 200;
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        System.out.println("最大值: "+max);
        return ;//結束方法,返回到方法的調用處,可以省略的
    }
}

3.帶參數無返回值的方法練習

/*
    帶參數無返回值的方法練習
        需求:
            定義一個方法用於打印兩個int數中的較大數，數據來自於方法參數

            參數列表: 當方法需求中有不確定的因素,需要定義參數列表
            返回值類型: 當方法內部需求中,明確規定"打印...",不需要返回值,也就不需要返回值類型,寫爲void

    三要素:
        1.方法名稱:     printMax
        2.參數列表:     int a,int b
        3.返回值類型:    void
 */
public class Demo04MethodParams {
    public static void main(String[] args) {
        System.out.println("main...start...");

        //調用方法: 傳遞常量
        printMax(88,66);
        //printMax(6.6,8.8);//錯誤,傳遞的實際參數和形式參數類型比匹配

        //調用方法: 傳遞變量
        int num1 = 50;
        int num2 = 75;
        printMax(num1,num2);

        System.out.println("main...end...");
    }

    /*
        定義一個方法用於打印兩個int數中的較大數，數據來自於方法參數
        三要素:
            1.方法名稱:     printMax
            2.參數列表:     int a,int b
            3.返回值類型:    void
     */
    public static void printMax(int a, int b) {
        //求2個int數據的較大值
        //三元運算符
        int max = (a > b) ? a : b;
        System.out.println("最大值: "+max);

        return ;

    }
}

4.有參數有返回值的方法練習

/*
    帶參數帶返回值的方法練習
        設計一個方法可以獲取兩個int數的較大值，數據來自於參數

        參數列表: 當方法需求中有不確定的因素,需要定義參數列表
        返回值類型:
            當方法內部需求中,明確規定"打印...",不需要返回值,也就不需要返回值類型,寫爲void
            當方法內部需求中,明確規定"獲取/返回/判斷...",需要有返回值,也就需要返回值類型

    三要素:
        1.方法名稱:     getMax
        2.參數列表:     int a,int b
        3.返回值類型:    int
 */
public class Demo03MethodReturn {
    public static void main(String[] args) {
        System.out.println("main...start...");

        //定義2個int變量
        int a = 100;
        int b = 50;

        //調用方法
        int max = getMax(a,b);

        System.out.println(a+"和"+b+"的最大值是: "+max);


        System.out.println("main...end...");
    }

    /*
        設計一個方法可以獲取兩個int數的較大值，數據來自於參數
        三要素:
            1.方法名稱:     getMax
            2.參數列表:     int a,int b
            3.返回值類型:    int
     */
    public static int getMax(int a, int b) {//形式參數
        if (a > b) {
            return a;
        } else {
            return b;
        }

    }
}

5.方法的注意事項

/*
    定義方法的注意事項
        1.方法不能嵌套定義(在定義的方法的內部,又定義了其它的方法)
        2.方法可以嵌套調用(在定義的方法內部,可以調用其它的方法)
        3.返回值類型，必須要和 return 語句返回的類型匹配，否則編譯失敗 。
        4.不能在 return 後面寫代碼， return 意味着方法結束，所有後面的代碼永遠不會執行，屬於無效代碼。
            只要方法有返回值類型,那麼方法內部有且僅有一條return語句會被執行

        5.void表示無返回值，可以省略return，也可以單獨的書寫return，後面不加數據
 */
public class Demo04MethodNotice {
    //定義main方法
    public static void main(String[] args) {

    }


    //只要方法有返回值類型,那麼方法內部有且僅有一條return語句會被執行
    public static int getMax(int a, int b) {
        if (a > b) {
            return a;
        }
        return b;
    }

    //4.不能在 return 後面寫代碼， return 意味着方法結束，所有後面的代碼永遠不會執行，屬於無效代碼。
    public static int getNum() {
        int a = 10;

        return a;//方法就結束了,就返回到方法的調用處了,後面代碼沒有機會執行

        //int b = 20;//錯誤,return後面不能繼續寫代碼

    }

    //3.返回值類型，必須要和 return 語句返回的類型匹配，否則編譯失敗
    public static double getDouble() {
        //return 6.6;
        //return 10;//int --> double
        //return 8.8F;//float --> double
        return 20L;//long --> double
        //return true;//錯誤,返回結果的數據類型和返回值類型不匹配
    }

    //定義method方法
    public static void method() {
        System.out.println("method...");
        /*
        //錯誤,方法內部不能再定義方法
        public static void show() {
            System.out.println("show...");
            return ;
        }*/
        //嵌套調用
        a();
        return ;
    }
    public static void a() {
        System.out.println("a....");
        return ;
    }
}

6.參數傳遞

/*
    基本數據類型作爲方法參數
    注意:
        1.基本類型作爲方法參數,傳遞的是具體的數據值

        2.基本類型作爲方法的形式參數時,形式參數的改變,不會影響實際參數

            基本類型作爲方法的形式參數時:
                change方法上定義的a和b
                就是形式參數

            不會影響實際參數
                main方法中調用change方法時,定義的變量a和b
 */
public class Demo01BaseParam {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("ms..a="+a);//10
        System.out.println("ms..b="+b);//20

        //調用方法
        change(a,b);

        System.out.println("me..a="+a);//10
        System.out.println("me..b="+b);//20

    }

    public static void change(int a, int b) {
        System.out.println("cs..a="+a);//10
        System.out.println("cs..b="+b);//20
        a *= 10;
        b *= 10;
        System.out.println("ce..a="+a);//100
        System.out.println("ce..b="+b);//200
        return;
    }
}

/*
    引用數據類型作爲方法參數
        注意:
	    1.引用類型作爲方法參數,調用方法時,傳遞的是地址值


	    2.引用類型作爲方法的形式參數,通過形式參數修改堆內存空間的內容,
	        會影響到實際參數看到的堆內存空間的內容


        引用類型作爲形參,形式參數的改變會影響實際參數

 */
public class Demo02RefParam {
    public static void main(String[] args) {
        int[] arr = new int[]{10,20};//arr中存儲的是數組的地址值,假設:0x666
        System.out.println("ms..arr[0]="+arr[0]);//10
        System.out.println("ms..arr[1]="+arr[1]);//20

        //調用方法: change(0x666)
        change(arr);

        System.out.println("me..arr[0]="+arr[0]);//100
        System.out.println("me..arr[1]="+arr[1]);//200


    }
    /*
        當調用change方法時:
        int[] arr = 0x666 = arr(main方法中的) = new int[]{10,20}
     */
    public static void change(int[] arr) {
        System.out.println("cs..arr[0]="+arr[0]);//10
        System.out.println("cs..arr[1]="+arr[1]);//20
        arr[0] *= 10;//arr[0] = arr[0] * 10
        arr[1] *= 10;//arr[1] = arr[1] * 10
        System.out.println("ce..arr[0]="+arr[0]);//100
        System.out.println("ce..arr[1]="+arr[1]);//200
        return ;
    }


}

九.day09內容

1.方法重載概念

/*
    練習:
        1.定義方法,獲取2個int數據之和
        2.定義方法,獲取3個int數據之和
        3.定義方法,獲取2個double數據之和
        4.定義方法,獲取3個double數據之和

    發現問題:
        以下四個方法,都是完成求和功能,功能相同,只是參數列表不同,
        但是我們給每個方法起了一個非常複雜而且不相同的名字,
        導致程序員學習/使用的時候太麻煩,記不住

    解決方案: 方法重載
        1.概念:
            在同一個類中,多個功能相同,但是參數列表不同的方法,可以使用相同的名字,這種現象就叫做方法的重載

        2.作用:
            (1)節省命名空間
            (2)減少程序員學習/使用的成本
 */
public class Demo02OverLoad {
    public static void main(String[] args) {
        System.out.println(getSum(10,20));
        System.out.println(getSum(10,20,30));
        System.out.println(getSum(10.0,20.0));
        System.out.println(getSum(10.0,20.0,30.0));
    }

    //1.定義方法,獲取2個int數據之和
    public static int getSum(int a, int b) {
        System.out.println("獲取2個int數據之和的方法被調用了....");
        return a + b;
    }

    //2.定義方法,獲取3個int數據之和
    public static int getSum(int a, int b,int c) {
        System.out.println("獲取3個int數據之和的方法被調用了....");
        return a + b + c;
    }

    //3.定義方法,獲取2個double數據之和
    public static double getSum(double a, double b) {
        System.out.println("獲取2個double數據之和的方法被調用了....");
        return a + b;

    }

    //4.定義方法,獲取3個double數據之和
    public static double getSum(double a, double b,double c) {
        System.out.println("獲取3個double數據之和的方法被調用了....");
        return a + b + c;

    }
}

2.參數列表不同有哪些情況

/*
    方法重載中,參數列表不同有哪些情況?          ----方法重載,主要關心方法的參數
        1.參數數量不同
        2.參數類型不同
        3.多個類型,順序不同
 */
public class Demo03OverLoad {
    public static void main(String[] args) {
    }

    //1.有兩個int參數
    public static void printMax(int a, int b) {

    }
    //2 方法2有3個int參數,而方法1有2個int參數,參數數量不同,    可以構成重載
    public static void printMax(int a, int b,int c) {

    }

    //3 方法3有2個double參數,而方法1有2個int參數,參數的類型不同, 可以構成重載
    public static void printMax(double a, double b) {

    }

    //4.有1個double參數和1個int參數,而且double在前,int在後
    public static void printMax(double a, int b) {

    }

    //5.有1個double參數和1個int參數,而且int在前,double在後  多個類型,但是順序不同,可以構成重載
    public static void printMax(int a, double b) {

    }

}

3.方法重載與哪些因素無關

/*
    方法重載與哪些因素無關?
        1.與方法的參數名稱無關
        2.與返回值類型無關
        3.與修飾符無關

    定義方法時()中定義的變量/參數  稱之爲 形式參數
    調用方法時()中穿度的變量/參數  稱之爲 實際參數

 */
public class Demo04OverLoad {
    public static void main(String[] args) {

    }

    //1.有兩個int參數,參數名稱是a和b
    public static void printMax(int a, int b) {

    }

    //2.方法2和方法1只有參數的名稱不同,                   無法構成重載
    /*public static void printMax(int c, int d) {

    }*/

    //3.有2個int參數,返回值類型int
    public static int getNum(int a,int b) {
        return 0;
    }

    //4.有2個int參數,返回值類型double
    //方法4和方法3,只有返回值類型不同                    無法構成重載
    /*public static double getNum(int a,int b) {
        return 0.0;
    }*/

    //5.有2個int參數,返回值類型int
    //方法5和方法3,只有修飾符不同                       無法構成重載
    /*private static int getNum(int a,int b) {
        return 0;
    }*/

}

十.day10內容

1.數組統計學生成績

/*
    數組統計學生成績
        需求:
            1.鍵盤錄入班級人數
            2.根據錄入的班級人數創建數組
            3.利用隨機數產生0-100的成績(包含0和100)
            4.要求:
                (1)打印該班級的不及格人數
                (2)打印該班級的平均分
                (3)演示格式如下:
                    請輸入班級人數:
                    鍵盤錄入:100
                    控制檯輸出: 不及格人數:19
                    班級平均分:87
        實現步驟:
            1.創建鍵盤錄入Scanner類的對象
            2.獲取鍵盤錄入的整數數字(代表班級人數),保存到int變量size中
            3.創建長度爲size的int類型的數組array           元素都是默認值0
            4.創建產生隨機數的Random類的對象
            5.給數組元素賦值(0到100之間,包含0和100)
            6.定義int變量count,用來統計不及格的人數,初始值0
            7.定義int變量sum,用來求數組元素之和,初始值0
            8.使用for循環遍歷數組
            9.把當前元素累加到求和變量sum中
            10.判斷如果當前元素值小於60,計數器count的值+1
            11.計算平均值
            12.for循環結束打印不及格人數和所有創建的平均值


 */
public class Test02ArrayScore {
    public static void main(String[] args) {
        //1.創建鍵盤錄入Scanner類的對象
        Scanner sc = new Scanner(System.in);

        //2.獲取鍵盤錄入的整數數字(代表班級人數),保存到int變量size中
        System.out.println("請輸入一個整數(代表班級的人數): ");
        int size = sc.nextInt();

        //3.創建長度爲size的int類型的數組array           元素都是默認值0
        int[] array = new int[size];

        //4.創建產生隨機數的Random類的對象
        Random r = new Random();

        //5.給數組元素賦值(0到100之間,包含0和100)
        /*array[0] = r.nextInt(101);
        array[1] = r.nextInt(101);
        array[2] = r.nextInt(101);
        //...
        array[size-1] = r.nextInt(101);*/
        for (int i = 0; i < array.length; i++) {
            array[i] = r.nextInt(101);
        }

        //6.定義int變量count,用來統計不及格的人數,初始值0
        int count = 0;

        //7.定義int變量sum,用來求數組元素之和,初始值0
        int sum = 0;

        //8.使用for循環遍歷數組
        for (int i = 0; i < array.length; i++) {
            //9.把當前元素累加到求和變量sum中
            sum += array[i];

            //10.判斷如果當前元素值小於60,計數器count的值+1
            if (array[i] < 60) {
                count++;
            }

        }
        //11.計算平均值
        int avg = sum / size;

        //12.for循環結束打印不及格人數和所有創建的平均值
        System.out.println("不及格人數: "+count);
        System.out.println("平均分: " + avg);
    }
}

2.隨機抽取數組元素

/*
    隨機抽取數組元素
        需求:
            將數字1-10保存到一個長度爲10的int數組arrA中
            定義一個新數組arrB,長度爲3,取出原來數組中隨機的三個元素(不考慮是否重複)
            給新數組的元素賦值
            求新數組所有元素的和

        注意:
            元素組的長度10(length屬性值),最大索引9(length屬性值-1)
            如何從長度爲10的數組中,隨機取出3個元素呢?
            1.要取出數組元素,必須產生索引?產生索引的時候,不能越界?
                因爲源數組的索引是0到9(包含0和9)
                產生的索引範圍是0到9(包含0和9)
                Random r = new Random();
                r.nextInt(10);//而10 是數組的長度,可以使用length屬性代替
                r.nextInt(arrA.length): 產生0到arrA.length-1範圍內的索引
            2.通過隨機索引獲取源數組元素,存儲到新數組中


        實現步驟:
            1.創建長度爲10的int類型數組arrA
            2.向arrA數組中存儲1-10的數字
            3.創建產生隨機數的Random類的對象
            4.創建長度爲3的int類型數組arrB
            5.使用for循環遍歷數組arrB
            6.產生一個int隨機數字index(要獲取的老數組中隨機元素的索引值),範圍是老數組的索引範圍
            7.從老數組arrA中通過索引index獲取元素值,保存int變量num中
            8.把num的值保存到數組arrB的當前元素中
            9.定義int類型求和變量sum,初始化值0
            10.遍歷新數組arrB
            11.把當前元素累加到求和變量sum中
            12.打印求和變量sum


        擴展:
            如果新數組中元素不能重複,應該怎麼做?

 */
public class Test03ArrayRandom {
    public static void main(String[] args) {
        //1.創建長度爲10的int類型數組arrA
        int[] arrA = new int[10];

        //2.向arrA數組中存儲1-10的數字
        /*arrA[0] = 0+1;
        arrA[1] = 1+1;
        arrA[2] = 2+1;
        //...
        arrA[arrA.length-1] = arrA.length-1 +1;*/
        for (int i = 0; i < arrA.length; i++) {
            arrA[i] = i+1;
        }

        //3.創建產生隨機數的Random類的對象
        Random r = new Random();

        //4.創建長度爲3的int類型數組arrB
        int[] arrB = new int[3];

        //5.使用for循環遍歷數組arrB
        for (int i = 0; i < arrB.length; i++) {
            //6.產生一個int隨機數字index(要獲取的老數組中隨機元素的索引值),範圍是老數組的索引範圍
            int index = r.nextInt(arrA.length);

            //7.從老數組arrA中通過索引index獲取元素值,保存int變量num中
            int num = arrA[index];

            //8.把num的值保存到數組arrB的當前元素中
            arrB[i] = num;

        }
        //9.定義int類型求和變量sum,初始化值0
        int sum = 0;

        //10.遍歷新數組arrB
        for (int i = 0; i < arrB.length; i++) {
            //11.把當前元素累加到求和變量sum中
            sum += arrB[i];
        }
        //12.打印求和變量sum
        System.out.println("新數組元素內容: "+ Arrays.toString(arrB)+"新數組元素和: "+sum);
    }
}

3.評委打分

/*
    評委打分
        需求
        在編程競賽中，有6個評委爲參賽的選手打分，分數爲0-100(包含0和10)的整數分(鍵盤錄入)。
        選手的最後得分爲：去掉一個最高分和一個最低分後 的4個評委平均值 (不考慮小數部分)。

    實現步驟:
        1.創建長度爲6的int數組array
        2.創建鍵盤錄入Scanner對象
        3.通過鍵盤錄入數據給數組array中6個元素賦值
        4.定義求int數組array元素和的方法getSum
        5.定義求int數組array元素最大值的方法getMax
        6.定義求int數組array元素最小值的方法getMin
        7.調用求數組元素和的方法getSum,獲取求和結果,保存到int變量sum中
        8.調用求數組元素最大值的方法getMax,獲取最大值結果,保存到int變量max中
        9.調用求數組元素最小值的方法getMin,獲取最小值結果,保存到int變量min中
        10.計算平均分: (sum - max - min)/(array.length-2)
        11.打印平均分
 */
public class Demo07ArrayScore {
    public static void main(String[] args) {

        //調用方法,獲取int數組
        int[] array = getArray();

        //調用方法,獲取平均值
        int avg = getAvg(array);

        //11.打印平均分
        System.out.println("數組內容: ");
        printArray(array);
        System.out.println("按照規則計算出來的平均分: "+avg);
    }

    /*
        定義getAvg方法,獲取方法參數int數組的平均值
     */
    public static int getAvg(int[] array) {
        //7.調用求數組元素和的方法getSum,獲取求和結果,保存到int變量sum中
        int sum = getSum(array);

        //8.調用求數組元素最大值的方法getMax,獲取最大值結果,保存到int變量max中
        int max = getMax(array);

        //9.調用求數組元素最小值的方法getMin,獲取最小值結果,保存到int變量min中
        int min = getMin(array);

        //10.計算平均分: (sum - max - min)/(array.length-2)
        int avg = (sum - max - min)/(array.length - 2);

        //11.返回平均值
        return avg;

    }
    /*
        定義getArray方法,返回一個int數組
     */
    public static int[] getArray() {
        //步驟1-3能否封裝成一個方法

        //1.創建長度爲6的int數組array
        int[] array = new int[6];

        //2.創建鍵盤錄入Scanner對象
        Scanner sc = new Scanner(System.in);

        //3.通過鍵盤錄入數據給數組array中6個元素賦值
        for (int i = 0; i < array.length; i++) {
            System.out.println("請輸入第"+(i+1)+"個評分");
            array[i] = sc.nextInt();
        }


        //4.返回數組array
        return array;

    }

    //6.定義求int數組array元素最小值的方法getMin
    public static int getMin(int[] array) {
        //1.假設索引0對應的元素是最小的,保存到int變量min中
        int min = array[0];
        //2.for循環遍歷數組(從索引1開始)
        for (int i = 1; i < array.length; i++) {
            //3.如果當前元素<min
            if (array[i] < min) {
                //4.把當前元素賦值給min
                min = array[i];
            }
        }
        //5.返回min
        return min;
    }

    //5.定義求int數組array元素最大值的方法getMax
    public static int getMax(int[] array) {
        //1.假設索引0對應的元素是最大的,保存到int變量max中
        int max = array[0];
        //2.for循環遍歷數組(從索引1開始)
        for (int i = 1; i < array.length; i++) {
            //3.如果當前元素>max
            if (array[i] > max) {
                //4.把當前元素賦值給max
                max = array[i];
            }
        }
        //5.返回max
        return max;
    }

    //4.定義求int數組array元素和的方法getSum
    public static int getSum(int[] array) {
        //1.定義int類型求和變量sum,初始值0
        int sum = 0;
        //2.for循環遍歷數組
        for (int i = 0; i < array.length; i++) {
            //3.把當前元素累加到求和變量sum中
            sum += array[i];
        }
        //4.返回求和變量sum
        return sum;
    }

    //打印數組
    public static void printArray(int[] array) {
        //1.打印"[",不換行
        System.out.print("[");
        //2.使用for循環遍歷數組
        for (int i = 0; i < array.length; i++) {
            //2.1打印元素
            System.out.print(array[i]);
            //2.2如果不是最後一個元素,打印", ",不換行
            if (i != array.length - 1) {
                System.out.print(", ");
            }

        }
        //3.打印"]",換行
        System.out.println("]");
    }
}

4.水仙花數

/*
    水仙花數
        案例需求
        在控制檯輸出所有的“水仙花數”及其總個數
        什麼是水仙花數？
        水仙花數，指的是一個三位數，個位、十位、百位的數字立方和等於原數
        例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153
        要求: 需要定義一個判斷三位數字是否是水仙花數字的方法isWaterFlowerNum

    實現步驟:
        1.定義判斷一個三位數字是否是水仙花數字的方法isWaterFlowerNum
        2.定義int變量count,用來計數,初始化值0
        3.使用for循環遍歷所有的三位數字
        4.判斷如果當前數字是水仙花數字(調用isWaterFlowerNum方法)
        5.打印當前數字
        6.計數器count+1
        7.打印count的值
 */
public class Demo01WaterFlowers {
    public static void main(String[] args) {
        //2.定義int變量count,用來計數,初始化值0
        int count = 0;

        //3.使用for循環遍歷所有的三位數字
        for (int i = 100; i <= 999; i++) {
            //4.判斷如果當前數字是水仙花數字(調用isWaterFlowerNum方法)
            /*boolean result = isWaterFlowerNum(i);
            if(result == true){}*/
            if(isWaterFlowerNum(i) == true) {
                //5.打印當前數字
                System.out.println(i);
                //6.計數器count+1
                count++;
            }

        }
        //7.打印count的值
        System.out.println("水仙花數字總共有"+count+"個");
    }

    /*
        定義判斷一個三位數字是否是水仙花數字的方法isWaterFlowerNum
        要求:
            個位、十位、百位的數字立方和等於原數
        三要素:
            1.方法名稱: isWaterFlowerNum
            2.參數列表: int num
            3.返回值類型: boolean

        實現步驟:
            1.計算方法參數num的個位,十位,百位,分別保存int變量ge,shi,bai中
            2.計算個位,十位,百位數字的立方和,保存int變量sum中
            3.判斷如果立方和sum等於該數字num本身,返回true
            4.判斷如果立方和sum不等於該數字num本身,返回false
     */
    public static boolean isWaterFlowerNum(int num) {
        //1.計算方法參數num的個位,十位,百位,分別保存int變量ge,shi,bai中
        int ge = num%10;//個位
        int shi = num/10%10;//十位
        int bai = num/100%10;//百位

        //2.計算個位,十位,百位數字的立方和,保存int變量sum中
        int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;

        /*if (sum == num) {
            //3.判斷如果立方和sum等於該數字num本身,返回true
            return true;
        } else {
            //4.判斷如果立方和sum不等於該數字num本身,返回false
            return false;
        }*/

        return sum == num;

    }
}

十一.day11內容

1.面向對象的特點

面向對象思想總結: 
	1.面向過程:當要實現一個功能時,需要親力親爲,處理每個細節 
	2.面向對象:當要實現一個功能時,不關心具體的實現步驟,只關心結果,找一個具有該功能的類,幫我們做事 
	3.面向對象的思想 
		(1)面向對象是基於面向過程的編程思想. 
		(2)面向過程:強調的是每一個功能的步驟 
		(3)面向對象:強調的是對象,然後由對象去調用功能 
    4.特點
    	(1)是一種更符合我們思考習慣的思想 
    	(2)可以將複雜的事情簡單化 
    	(3)角色發生了轉換,將我們從執行者變成了指揮者

2.類和對象的關係

類：類是對現實生活中一類具有共同屬性和行爲的事物的抽象
	類是對一類事物的描述，是抽象的。
對象：是能夠看得到摸的着的真實存在的實體
	對象是一類事物的實例，是具體的。
簡單理解：類是對事物的一種描述，對象則爲具體存在的事物
	類是對象的模板，對象是類的實體。

3.類的定義

/*
    定義Student類,用來模擬學生事物
        分析,學生事物有兩部分組成
            1.屬性(名詞): 姓名,性別,年齡
            2.行爲(動詞): 吃飯,睡覺,學習

        對應到java的類中,也有兩部分組成
            1.成員變量(屬性,名詞):
                姓名: String name
                性別: String gender
                年齡: int age
            2.成員方法(行爲,動詞)
                吃飯: eat()
                睡覺: sleep()
                學習: study()

         類的定義格式:
            public class 類名 {
                //成員變量
                //成員方法
            }

            注意: class是定義類的關鍵字,class後面的名稱,叫做類名

        注意:
            1.成員變量: 和以前定義變量的格式相同,只是位置發生了改變,成員變量定義在類中方法外
                以前在方法內部定義的變量,叫做局部變量

            2.成員方法: 和以前定義方法的格式相同,只是需要去掉static關鍵字




 */
/*
    這裏定義了一個名稱爲Student的類,用來描述學生事物,相當於模板/模型/圖紙,
    不能直接使用,要想使用,必須根據模板/模型/圖紙創建一個具體的對象纔可以使用.
    抽象:
        抽取出現實事物中像的部分,相同的部分,相似的部分
 */
public class Student {
    //成員變量(屬性,名詞)
    String name;//姓名
    String gender;//性別
    private int age;//年齡

    //
    public Student() {
        System.out.println("空參構造被調用了.....");
    }

    public Student(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 0 && age <= 100) {
            this.age = age;
        }
    }

    //成員方法
    //吃飯
    public void eat(){
        System.out.println(age+"吃飯飯...");
    }

    //睡覺
    public void sleep() {
        System.out.println("睡覺覺...");
    }

    //學習
    public void study() {
        System.out.println("正在學習面向對象的內容...");
    }
}

4.對象的使用

/*
    前面定義的一個名稱爲Student的類,用來描述學生事物,相當於模板/模型/圖紙,
    不能直接使用,要想使用,必須根據模板/模型/圖紙創建一個具體的對象纔可以使用.

    類是一種引用數據類型,使用有3個步驟
        1.導包(找到要使用的類):
            java.lang包下的內容可以直接使用,不需要導包
            導包格式: import xxx.xxx.類名;
            快捷鍵: alt + 回車
            注意:
                當前的類和要使用的類在同一個包中,不需要導包

        2.創建對象:
            數組對象的創建:
                數據類型[] 數組名稱 = new 數據類型[3];
                int[] array = new int[3];
                array[0],array[1],array[2]
                sout(array[0]);
                array[0] = 100;

            類的對象的創建:
                類名 對象名 = new 類名();

        3.對象的使用:
            (1)對象名稱: 對象在內存空間的地址值
            (2)成員變量的使用格式:
                對象名稱.成員變量名稱
                比如:
                    stu.name: 對象的name屬性值

            (3)成員方法的使用格式:
                對象名稱.成員方法名稱(...);
                比如:
                    stu.eat(): 調用對象stu的eat方法

            總結:
                點(.): 理解爲xxx的yyy

        4.注意:
            對象的成員變量有默認初始化值
            (1)基本類型
                整數(byte/short/int/long):    0
                小數(float/double):           0.0
                布爾(boolean):                false
                字符(char):                   空白字符
            (2)引用類型         null

 */
public class Demo02Student {
    public static void main(String[] args) {
        //創建Student類的對象
        Student stu = new Student();

        Student stu2 = new Student("lisi", "nan", 16);
        stu2.eat();

        System.out.println(stu);//地址值: itheima01.Student@1540e19d

        //打印成員變量的值
        System.out.println(stu.name);//null,打印對象stu的name屬性值,默認值: null
        System.out.println(stu.gender);//null,打印對象stu的gender屬性值,默認值: null
        System.out.println(stu.getAge());//0,打印對象stu的age屬性值,默認值: 0

        //給成員變量賦值
        stu.name = "小強";//把字符串"小強"賦值給對象stu的name屬性
        stu.gender = "男";//把字符串"男"賦值給對象stu的gender屬性
        stu.setAge(-8888);//把int數字賦值給對象stu的age屬性

        System.out.println(stu);//地址值: itheima01.Student@1540e19d

        //打印成員變量的值
        System.out.println(stu.name);//小強,打印對象stu的name屬性值: 小強
        System.out.println(stu.gender);//男,打印對象stu的gender屬性值: 男
        System.out.println(stu.getAge());//18,打印對象stu的age屬性值: 18

        //調用成員方法
        stu.eat();//調用對象stu的eat方法
        stu.sleep();//調用對象stu的sleep方法
        stu.study();//調用對象stu的study方法
    }
}

5.成員變量和局部變量區別

/*
    成員變量和局部變量區別
        1.初始化值的不同
            成員變量：有默認值
            局部變量：沒有默認值。必須先定義，賦值，最後使用
            局部變量: 在定義/聲明方法的時候()中定義的變量,或者在方法內部定義的變量

        2..在類中的位置不同
            成員變量：類中，方法外
            局部變量：方法中或者方法聲明上(形式參數)

        3.作用範圍不一樣
            成員變量：類中
            局部變量：方法中

        4.在內存中的位置不同
            成員變量：堆內存 局部變量：棧內存

        5.生命週期不同
            成員變量：隨着對象的創建而存在，隨着對象的消失而消失
            局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失
 */
public class Demo03VarDiff {


    public static void main(String[] args) {
        //int a;//在方法內部定義的變量,局部變量,不賦值,不能使用
        //System.out.println(a);

        Person p = new Person();
        //name是在Person類中定義的成員變量
        //創建對象後,有默認初始化值
        System.out.println(p.name);//null

    }

    /*
        a和b也是局部變量,在方法定義的時候定義的,
        而方法不調用不執行
        只要調用方法getSum,那麼必須傳遞兩個int數字分別給a和b
     */
    public static int getSum(int a, int b) {
        int sum = a + b;
        System.out.println("和: "+sum);
        return sum;
    }
}

//定義Person類
public class Person {
    String name;//成員變量,在整個類中都可以使用

    public void show() {
        //局部變量,只能在show方法內部使用
        int num = 100;
        System.out.println(num);
        System.out.println(name+"...");

    }

    public void method() {
        //不能使用num
        //System.out.println(num);//超出了num的作用範圍
        System.out.println(name+"----");
    }
}

十二.day12內容

1.private的含義

將屬性隱藏起來，若需要訪問某個屬性，提供公共方法對其訪問。
private是一個權限修飾符，代表最小權限。
可以修飾成員變量和成員方法。
被private修飾後的成員變量和成員方法，只在本類中才能訪問。

/*
    發現問題:
        定義類時,規定了成員變量的含義,但是卻無法保證成員變量的取值在一個合理有效的範圍內;
        比如年齡age: 規定0到100之間

    如何解決呢?
    解決方案:
        使用private(私有)關鍵字,將需要保護的成員變量使用private修飾一把

    private關鍵字的特點:
        1.被private修飾的成員(成員變量/方法),只能在所屬的類中直接使用
        2.在其它類中無法直接使用(對象名.成員變量名)被private修飾的成員

    出現新的問題:
        其它類中不能直接訪問被private修飾的成員,
        但是其它類中可以間接訪問被private修飾的成員

    解決方案:
        需要爲被private修飾的成員變量提供set和get方法
        set方法: 給成員變量賦值
        三要素:
            1.方法名稱: set + 成員變量名稱(第一個字母大寫)
            2.參數列表: 定義和成員變量相同類型的一個變量
            3.返回值類型: void

        注意:
            可以在set方法內部添加邏輯判斷,控制成員變量的取值範圍

        get方法: 獲取成員變量的值
        三要素:
            1.方法名稱: get + 成員變量名稱(第一個字母大寫)
            2.參數列表: 沒有參數
            3.返回值類型: 要獲取值的成員變量的類型


 */
public class Person02 {
    //成員變量
    String name;//姓名
    private int age;//年齡

    //成員方法
    public void show()  {
        System.out.println("姓名: "+name+", 年齡: "+age);

    }

    //set成員方法,給成員變量賦值
    public void setAge(int a) {
        if (a > 0 && a <= 100) {
            age = a;
        }
    }
    //get成員方法,獲取age的值
    public int getAge() {
        return age;
    }
}

2.this關鍵字

/*
    方法內部變量的訪問規則
        就近原則,方法內部有直接使用方法內部自己的,方法內部沒有,找成員問題

    局部變量和成員變量名稱相同?
        1.直接寫變量名: 代表的是方法內部的局部變量
        2.this.變量名:
            代表的是成員變量

    this代表誰?
        哪個對象調用方法,該方法內部的this就代表那個調用方法的對象
        誰調用我,我就代表誰

    注意:
        使用對象調用方法時,每個方法內部隱藏一個this關鍵字,用來接收調用該方法的對象的地址值,
        如果需要使用this,你就直接用,不用就算了
 */
public class Person03 {
    String name;//姓名

    //打招呼
    public void sayHello(String who) {
        System.out.println("你好: "+who+", 我是 "+name);
    }

    //以上方法參數String who 不能做到見名知意
    //把String who改成String name
    //發現: 方法()中定義的局部變量和成員變量同名
    //問題: 不能直接訪問到成員變量的
    public void sayHello2(String name) {
        System.out.println("你好: "+name+", 我是 "+name);
    }

    //要在方法內部使用和局部變量同名的成員變量
    //this.name: 成員變量name
    public void sayHello3(String name) {
        System.out.println("sayHello3....this..."+this);
        System.out.println("你好: "+name+", 我是 "+this.name);
    }
}

3.構造方法發

/*
    創建對象的格式:
        類名 對象名 = new 類名();
        Student stu = new Student();

    創建對象的過程: new + 調用構造方法

    構造方法:
        1.作用: 當使用new關鍵字創建對象以後,通過調用構造方法,完成對象成員的初始化
        2.格式:
            修飾符 類名(參數列表...) {
                方法體;
                return ;
            }
        3.特點:
            (1)修飾符中沒有static
            (2)沒有返回值類型,連void都沒有
            (3)構造方法名稱和類名保持一模一樣
            (4)return ; 可以省略

        4.注意:
            (1)自定義類時,如果一個構造方法都不寫,
                編譯器默認隱藏提供一個空參構造,裏面什麼都不做,我們看不見

            (2)構造方法也是一種方法,就可以重載(方法名稱相同,參數列表不同)

            (3)自定義類時,只要自己定義了構造方法,編譯器,將不再提供空參構造
                --建議:自定義類建議手動添加空參構造方法

 */
public class Demo05Constructor {
    public static void main(String[] args) {
        //創建Person05類的對象: 空參構造創建對象
        //對象的成員都是默認值
        Person05 p = new Person05();

        //調用set方法給成員變量賦值
        p.setName("張三");
        p.setAge(18);

        //調用成員方法
        p.show();

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

        //創建Person05類的對象: 滿參構造創建對象
        //對象創建完畢後,會立刻使用構造方法的參數,
        //對對象的成員變量進行初始化
        //name的值: "李四"
        //age的值: 28
        Person05 p2 = new Person05("李四",28);

        //調用成員方法
        p2.show();
    }
}

public class Person05 {
    private String name;//姓名
    private int age;//年齡

    //空參構造
    public Person05() {
        System.out.println("空參構造被調用了....");
        //return ;//可以省略
    }

    //滿參/全參構造
    public Person05(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //只給name賦值的構造方法
    public Person05(String name) {
        this.name = name;
    }
    //只給age賦值的構造方法
    public Person05(int age) {
        this.age = age;
    }

    //展示信息
    public void show() {
        System.out.println("姓名: "+name+", 年齡: "+age);
    }


    //get 和 set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

4.String類的介紹

/*
    java.lang.String類: 代表字符串
        1.API文檔中的描述:
            String 類代表字符串。Java 程序中的所有字符串字面值（常量: 如 "abc" ）都作爲此類的實例實現(對象)。
            字符串是常量；它們的值在創建之後不能更改(但凡是你感覺它要變化的時候,其實都是產生了一個新的字符串)。
            因爲字符串很常用,所以所有使用雙引號""引起來的內容,都作爲字符串String類的對象

        2.特點:
            (1)字符串不變：字符串的值在創建後不能被更改。
                String s1 = "abc";
                s1 += "d";//s1 = s1 + "d"; //s1 = "abcd"
                System.out.println(s1); // "abcd"
                // 內存中有"abc"，"abcd"兩個對象，s1從指向"abc"，改變指向，指向了"abcd"。

            (2)因爲String對象是不可變的，所以它們可以被共享。
                String s1 = "abcde";
                String s2 = "abcde";
                //內存中只有一個"abcde"對象被創建，同時被s1和s2共享。

            (3) "abc" 等效於 char[] data = { 'a' , 'b' , 'c' }
                jdk8及以前版本,String內部使用的是字符數組


        查看源代碼:
            ctrl + n --> 輸入類名 --> 回車

 */
public class Demo08String {
}

5.創建字符串對象兩種方式的區別

/*
    創建字符串對象兩種方式的區別
        1.使用new關鍵字創建字符串對象: 只要new就會在堆內存中開闢空間
        2.使用""寫的字符串常量的形式: 字符串常量在常量池中

    ==的使用:
        1.基本類型: 比較的是變量中具體的數據是否相同
        2.引用類型: 比較的地址值是否相同
            如果想比較字符串的內容,需要使用equals方法
            public boolean equals(Object obj): 判斷調用equals方法的字符串和參數字符串的內容是否一模一樣(區分大小寫的)
            比如:
                s1.equals(s2): 比較字符串s1和s2的內容是否相同,如果相同返回true,如果不相同返回false

        new String(chs):
            最終是一個"abc"一個字符串,首先檢查常量池中是否具有該字符串"abc"
            如果沒有,在常量池中創建一個字符串"abc",然後堆內存空間中保存的常量池中"abc"的地址值
            如果有,不會在常量池中重新創建一個字符串"abc",直接在堆內存空間中保存的常量池中"abc"的地址值
 */
public class Demo10Diff {
    public static void main(String[] args) {
        char[] chs = {'a','b','c'};
        String s1 = new String(chs);//"abc"
        String s2 = new String(chs);
        String s3 = "abc";
        String s4 = "abc";
        System.out.println(s1 == s2);//false
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//true
        System.out.println("-------------------------");


        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//true
        System.out.println(s3.equals(s4));//true
    }
}

十三.day13內容

1.String類的常用方法

String類的成員方法:
        1.public boolean equals(Object obj):
            將此字符串(調用方法的字符串)與指定對象(方法參數指定的字符串)進行比較,
            如果內容一模一樣,返回true,否則,返回false(區分大小的)
            舉例:
                s1.equals(s2): 比較s1和s2這兩個字符串的內容,
                        是否一模一樣,如果一樣,返回true,如果不一樣,返回false

        2.public boolean equalsIgnoreCase(String str):
            將此字符串(調用方法的字符串)與指定對象(方法參數指定的字符串)進行比較,
            忽略大小寫後,內容一樣返回true,內容不一樣返回false
            舉例:
                s1.equalsIgnoreCase(s2): 比較s1和s2這兩個字符串的內容,
                忽略大小寫後是否一模一樣,如果一樣,返回true,如果不一樣,返回false
                
        3.public int length(): 返回此字符串的長度(字符串中包含的字符的數量)。
            比如:
                s1.length(): 獲取字符串s1中的字符數量

            注意:
                數組的長度使用length屬性,用的時候後面不寫()

        4.String類的底層採用的是字符數組,而數組有索引,索引從0開始,到數組長度-1
          所以字符串中的每個字符也有索引,從0開始,到字符串的長度-1
          比如:
            "abcd": 'a'--> 索引是0   'b'--> 索引是1 'c'--> 索引是2   'd'--> 索引是3

          public char charAt(int index):獲取調用方法的字符串中索引編號爲index處對應的字符


    ==:
        1.基本類型: 比較的是變量中的具體數據值是否相同
        2.引用類型:
            比較的是地址值是否相同,只要new地址值就是不相同的

2.用戶登錄案例

/*
    String類的練習-用戶登錄案例         

    需求
        已知用戶名和密碼，請用程序實現模擬用戶登錄。
        總共給三次機會，登錄之後，給出相應的提示
        (1)用戶名和密碼都相同: 提示 "登錄成功"
        (2)用戶名和密碼有不相同: 提示 "登錄失敗",還要提示剩餘xx次機會

    實現步驟:
        1.定義兩個String變量rUsername和rPassword,表示已經註冊的用戶名和密碼,並分別初始化
        2.創建鍵盤錄入Scanner對象
        3.循環次數(總共可以登錄3次)確定,所以使用for循環
        3.1獲取鍵盤錄入的用戶名和密碼,分別保存在String變量inUsername和inPassword中
        3.2 判斷 如果用戶輸入的用戶名inUsername和已經註冊的用戶名rUsername相同 並且
                用戶輸入的密碼inPassword和已經註冊的密碼rPassword也相同
        3.3 提示 "登錄成功" 結束for循環
        3.4 否則(要麼用戶名不相同,要麼密碼不相同) 提示 "登錄失敗","剩餘登錄次數"

 */
public class Demo03StringLogin {
    public static void main(String[] args) {
        //1.定義兩個String變量rUsername和rPassword,表示已經註冊的用戶名和密碼,並分別初始化
        String rUsername = "admin";
        String rPassword = "123";

        //2.創建鍵盤錄入Scanner對象
        Scanner sc = new Scanner(System.in);

        //3.循環次數(總共可以登錄3次)確定,所以使用for循環
        for (int times = 1; times <= 3; times++) {
            //3.1獲取鍵盤錄入的用戶名和密碼,分別保存在String變量inUsername和inPassword中
            System.out.println("請輸入用戶名: ");
            String inUsername = sc.nextLine();
            System.out.println("請輸入密碼: ");
            String inPassword = sc.nextLine();

            //3.2 判斷 如果用戶輸入的用戶名inUsername和已經註冊的用戶名rUsername相同 並且
            //用戶輸入的密碼inPassword和已經註冊的密碼rPassword也相同
            if (inUsername.equals(rUsername) && inPassword.equals(rPassword)) {
                System.out.println("登錄成功~~~~");
                break;//結束循環
            } else {
                //3.4 否則(要麼用戶名不相同,要麼密碼不相同,要麼用戶名和密碼都不相同)
                //提示 "登錄失敗","剩餘登錄次數"
                System.out.println("用戶名或者密碼有誤,登錄失敗~~~");
                if (times == 3) {
                    System.out.println("您的登錄次數3次已經用完...");
                } else {
                    System.out.println("您還剩餘: "+(3-times)+" 次登錄機會,請珍惜~~~~");
                }
            }
        }

    }
}

3.String類的練習-統計字符次數

/*
    String類的練習-統計字符次數           
        需求
            鍵盤錄入一個字符串，統計該字符串中大寫字母，小寫字母，數字字符以及其它字符出現的次數

        實現步驟:
            1.創建鍵盤錄入Scanner對象
            2.獲取鍵盤錄入的字符串,保存到String變量str中
            3.定義四個int類型的變量,初始化值分別爲0,用來統計不同類型的字符的個數
                int bigCount = 0;//統計大寫字母的數量
                int smallCount = 0;//統計小寫字母的數量
                int numCount = 0;//統計數字字符的數量
                int otherCount = 0;//統計其它字符的數量
            4.使用for循環遍歷字符串
            4.1 獲取當前索引對應的字符,保存到char類型的變量ch中
            4.2 判斷 如果 ch中是大寫字母(ch>= 'A' && ch<='Z'): bigCount++
            4.3 判斷 如果 ch中是小寫字母(ch>= 'a' && ch<='z'): smallCount++
            4.4 判斷 如果 ch中是數字字符(ch>= '0' && ch<='9'): numCount++
            4.5 否則(其它字符): otherCount++
            5.for循環結束,打印四個計數器的值

 */
public class Demo06StringCount {
    public static void main(String[] args) {
        //1.創建鍵盤錄入Scanner對象
        Scanner sc = new Scanner(System.in);

        //2.獲取鍵盤錄入的字符串,保存到String變量str中
        System.out.println("請輸入一個字符串: ");
        String str = sc.nextLine();

        //3.定義四個int類型的變量,初始化值分別爲0,用來統計不同類型的字符的個數
        int bigCount = 0;//統計大寫字母的數量
        int smallCount = 0;//統計小寫字母的數量
        int numCount = 0;//統計數字字符的數量
        int otherCount = 0;//統計其它字符的數量

        //4.使用for循環遍歷字符串
        for (int i = 0; i < str.length(); i++) {
            //4.1 獲取當前索引對應的字符,保存到char類型的變量ch中
            char ch = str.charAt(i);

            if (ch >= 'A' && ch <= 'Z') {
                //4.2 判斷 如果 ch中是大寫字母(ch>= 'A' && ch<='Z'): bigCount++
                bigCount++;
            } else if (ch >= 'a' && ch <= 'z') {
                //4.3 判斷 如果 ch中是小寫字母(ch>= 'a' && ch<='z'): smallCount++
                smallCount++;
            } else if (ch >= '0' && ch <= '9') {
                //4.4 判斷 如果 ch中是數字字符(ch>= '0' && ch<='9'): numCount++
                numCount++;
            } else {
                //4.5 否則(其它字符): otherCount++
                otherCount++;
            }

        }
        //5.for循環結束,打印四個計數器的值
        System.out.println("字符串"+str+"中大寫字母數量:"+bigCount+"個");
        System.out.println("字符串"+str+"中小寫字母數量:"+smallCount+"個");
        System.out.println("字符串"+str+"中數字字符數量:"+numCount+"個");
        System.out.println("字符串"+str+"中其它字符數量:"+otherCount+"個");

    }
}

4.String和StringBuilder類的區別

1.StringBuilder中的內容是可以改變的
2.String中的內容是不可以改變的
3.StringBuilder內部提供了反轉的方法,而String沒有
4.StringBuilder進行大量字符串的拼接時,效率高

/*
    java.lang.StringBuilder類: 代表字符串緩衝區,支持可以改變的字符串
    底層: 是一個默認長度爲16的字符數組
    構造方法:
        public StringBuilder() ：構造一個空的StringBuilder容器,內部是一個長度爲16的字符數組
        public StringBuilder(String str) ：把構造方法參數String對象str,轉換成爲StringBuilder對象

    打印引用變量,默認調用toString方法

    StringBuilder和String的區別?
        1.StringBuilder中的內容是可以改變的
        2.String中的內容是不可以改變的
        3.StringBuilder內部提供了反轉的方法,而String沒有
        4.StringBuilder進行大量字符串的拼接時,效率高

 */
public class Demo05StringBuilder {
    public static void main(String[] args) {
        //public StringBuilder() ：構造一個空的StringBuilder容器,內部是一個長度爲16的字符數組
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);
        /*String s = sb.toString();
        System.out.println("hello"+s+"world");//helloworld*/
        System.out.println(sb.toString());

        //public StringBuilder(String str) ：把構造方法參數String對象str,轉換成爲StringBuilder對象
        StringBuilder sb2 = new StringBuilder("HelloWorld");
        System.out.println(sb2);
        System.out.println(sb2.toString());
    }
}

5.StringBuilder的常用方法

/*
    StringBuilder的常用方法
        public StringBuilder append(...) ：添加任意類型數據的字符串形式，並返回當前對象自身。做原樣添加
        public StringBuilder reverse() ：返回反轉的字符序列
        public String toString()：將當前StringBuilder對象轉換爲String對象。
 */
public class Demo06StringBuilder {
    public static void main(String[] args) {
        //創建StringBuilder對象
        StringBuilder sb = new StringBuilder();
        sb.append(97);
        sb.append('a');
        sb.append("hello");
        sb.append(true);
        System.out.println(sb.toString());//97ahellotrue

        //public StringBuilder reverse()：返回反轉的字符序列
        sb.reverse();
        System.out.println(sb.toString());//toString方法可以省略

        //public String toString() ：將當前StringBuilder對象轉換爲String對象。
        String str = sb.toString();
        System.out.println(str);
    }
}

6.StringBuilder的鏈式調用

/*
    StringBuilder類的append方法,reverse方法有返回值,返回的就是當前調用方法的StringBuilder對象

    StringBuilder支持鏈式編程
    前提: 對象調用方法後,方法返回調用方法的對象本身
 */
public class Demo07StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("A");
        StringBuilder sb2 = sb.append("B");
        StringBuilder sb3 = sb2.append("C");
        System.out.println(sb);//ABC
        System.out.println(sb2);//ABC
        System.out.println(sb3);//ABC
        //發現結果都是true
        //那麼sb,sb2,sb3指向的是同一個StringBuilder對象
        System.out.println(sb == sb2);//true
        System.out.println(sb == sb3);//true
        System.out.println(sb2 == sb3);//true
        System.out.println("------------------");
        StringBuilder sb4 = new StringBuilder();
        sb4.append("hello").append(97).append('a').append(false).append(8.8);
        System.out.println(sb4);//hello97afalse8.8
    }
}

7.String和StringBuilder的相互轉換

/*
    StringBuilder和String相互轉換
        1.String --> StringBuilder
            構造方法:
                public StringBuilder(String str): 把構造方法String參數str,轉換成StringBuilder對象

             構造方法:
                public StringBuilder(): 創建一個空的StringBuilder對象
                再調用append()方法

        2.StringBuilder --> String
            成員方法:
                public String toString(): 把調用toString方法的StringBuilder對象,轉換成String對象
 */
public class Demo08StringBuilder {
    public static void main(String[] args) {

        //StringBuilder sb = "hello";//左右類型不匹配,錯誤的

        //public StringBuilder(String str): 把構造方法String參數str,轉換成StringBuilder對象
        StringBuilder sb = new StringBuilder("hello");

        //public StringBuilder(): 創建一個空的StringBuilder對象
        StringBuilder sb2 = new StringBuilder();
        //再調用append()方法
        sb2.append("hello");


        //public String toString(): 把調用toString方法的StringBuilder對象,轉換成String對象
        String s1 = sb.toString();

        String s2 = sb2.toString();

        System.out.println(s1);
        System.out.println(s2);

    }
}

十四.day14內容

1.數組和ArrayList的區別

1.數組長度不可變,集合長度可變
2.數組中可以存儲任意類型數據,集合只能存儲引用類型,如果存儲基本類型,<>中需要寫出對用的引用類型
3.數組只提供length屬性,沒有提供相關方法,而集合提供了大量的方法

2.ArrayList集合介紹

/*
    java.util.ArrayList類:
        是大小可變的數組的實現，存儲在內的數據稱爲元素。
        此類提供一些方法來操作內部存儲的元素。
        ArrayList 中可不斷添加元素，其大小也自動增長。

    注意:
        1.ArrayList集合內部使用數組實現: Object[] 任意引用類型數據都可以存儲到ArrayList集合內部
        2.空參構造創建ArrayList集合,內部默認的數組長度是10
        3.因爲數組有索引,所以添加到ArrayList集合內部的元素也有索引,從0開始最大值是長度-1
        4.當向ArrayList集合內部添加元素時,集合內部的數組會不斷的擴容,創建新數組,把老數組的內容拷貝到新數組中,
            我們可以繼續向新數組中添加元素,但是至於說如何擴容的,如何拷貝數組的,我們不用關心,我們唯一要做的事情,
            把數據添加到集合當中,而且還要可以從集合中獲取/修改/刪除元素,就OK

    使用步驟:
        1.導包
            java.lang包下的內容不用導包
            當前類和要使用的類,處於同一個包下,不用導包
            import java.util.ArrayList;

        2.創建對象
            類名 對象名 = new 類名(...);

            舉例:
                對象數組的創建:
                Student[] stus = new Student[3];
                []: 代表的是數組
                Student: 代表的是數組中存儲的數據的類型(可以向數組中存儲什麼類型的數據)

            java.util.ArrayList<E>類:
                ArrayList是集合的名字(用的到底是哪個集合),<E>表示ArrayList集合容器中可以存儲的數據的類型

                舉例: 創建一個ArrayList集合容器對象list,存儲數據的類型String
                    ArrayList<String> list = new ArrayList<String>();
                    ArrayList<String> list = new ArrayList<>();//右邊<>中的內容可以省略,但是<>要保留

        3.成員方法
            public boolean add(E e) ： 將方法參數e添加到調用方法的集合容器的末尾處
                返回值類型:
                    boolean: 表示是否添加成功,對於ArrayList而言永遠返回true

        4.注意:
            (1)打印引用變量默認調用toString方法
            (2)打印ArrayList集合對象默認調用toString方法,打印出ArrayList集合的內容
 */
public class Demo02ArrayList {
    public static void main(String[] args) {

        //創建一個ArrayList集合容器對象list2,存儲數據的類型Student
        //ArrayList<Student> list2 = new ArrayList<>();


        //創建一個ArrayList集合容器對象list,存儲數據的類型String
        ArrayList<String> list = new ArrayList<String>();

        System.out.println(list);//[]
        System.out.println(list.toString());//[]

        //public boolean add(E e) ： 將方法參數e添加到調用方法的集合容器的末尾處

        list.add("aaa");//把字符串"aaa"添加到集合對象list的索引爲0的元素中
        System.out.println(list);//[aaa]

        list.add("bbb");//把字符串"bbb"添加到集合對象list的索引爲1的元素中
        System.out.println(list);//[aaa, bbb]

        list.add("ccc");//把字符串"ccc"添加到集合對象list的索引爲2的元素中
        list.add("dddd");//把字符串"ddd"添加到集合對象list的索引爲3的元素中

        System.out.println(list);//[aaa, bbb, ccc, dddd]

    }
}

3.ArrayList集合常用方法

/*
    ArrayList集合常用方法
        對於元素的操作,基本體現就是增、刪、改、查。
        public boolean add(E e) ：將指定的元素e添加到此集合(調用方法的集合)的尾部。
        public void add(int index,E element) ：在此集合中的指定位置插入指定的元素。
        public boolean remove(Object o) ：刪除指定的元素，返回刪除是否成功
            注意: 只刪除第一個元素

        public E remove(int index) ：移除此集合中指定位置上的元素。返回被刪除的元素。
        public E get(int index) ：返回此集合中指定位置上的元素。返回獲取的元素。
        public E set(int index,E element) ：修改指定索引處的元素，返回被修改的元素。
        public int size() ：返回此集合中的元素數。遍歷集合時，可以控制索引範圍，防止越界。
        public void clear(): 清空集合內容

    注意:
        add: 添加
        remove: 刪除          沒有delete方法
        get: 獲取
        set: 修改

        數組長度: length屬性

        字符串長度: length()方法
        集合長度(元素的個數): size()方法
 */
public class Demo03ArrayListMethods {
    public static void main(String[] args) {
        //創建一個ArrayList集合容器對象list,存儲數據的類型String
        ArrayList<String> list = new ArrayList<>();

        //public boolean add(E e) ：將指定的元素e添加到此集合(調用方法的集合)的尾部。
        list.add("aaa");
        list.add("ccc");

        System.out.println(list);//[aaa, ccc]: aaa在集合中的索引編號是0,ccc在集合中的索引編號是1

        //public void add(int index,E element) ：在此集合中的指定位置插入指定的元素
        //在ccc前面添加bbb
        list.add(1,"bbb");
        System.out.println(list);//[aaa, bbb, ccc]: aaa索引編號是0,bbb索引編號是1,ccc索引編號是2

        list.add("ddd");

        System.out.println(list);//[aaa, bbb, ccc, ddd]

        System.out.println("集合中元素的數量: "+list.size());//4
        //list.add("bbb");
        //System.out.println(list);

        //刪除bbb
        //public boolean remove(Object o) ：刪除指定的元素，返回刪除是否成功
        boolean result = list.remove("bbb");
        System.out.println("刪除bbb是否成功? "+result);//true
        System.out.println("刪除bbb後集合內容: "+list);//[aaa, ccc, ddd]:aaa索引編號是0,ccc索引編號是1,ddd索引編號是2

        //刪除索引爲1的元素
        //public E remove(int index) ：移除此集合中指定位置上的元素。返回被刪除的元素。
        String whoRemoved = list.remove(1);
        System.out.println("誰被刪除了呢? "+whoRemoved);//ccc
        System.out.println("刪除索引1的元素後集合內容: "+list);//[aaa, ddd]:aaa索引編號是0,ddd索引編號是1

        //public E get(int index) ：返回此集合中指定位置上的元素。返回獲取的元素。
        //獲取aaa
        String s = list.get(0);
        System.out.println("索引0對應的元素:"+s);//aaa
        //獲取ddd
        String s2 = list.get(1);
        System.out.println("索引1對應的元素:"+s2);//ddd
        System.out.println("獲取0和1索引元素後集合內容: "+list);//[aaa, ddd]:aaa索引編號是0,ddd索引編號是1

        //public E set(int index,E element) ：修改指定索引處的元素，返回被修改的元素。
        //把aaa變成a
        String whoUpdate = list.set(0, "a");
        System.out.println("誰被修改了呢?"+whoUpdate);//aaa
        System.out.println("修改索引0對應的元素後,集合內容: "+list);//[a, ddd]
        //把ddd變成d
        whoUpdate = list.set(1,"d");
        System.out.println("誰被修改了呢?"+whoUpdate);//aaa
        System.out.println("修改索引1對應的元素後,集合內容: "+list);//[a, d]: a索引編號是0,d索引編號是1


        System.out.println("集合中元素的數量: "+list.size());//2

        list.clear();//清空集合元素
        System.out.println("集合中元素的數量: "+list.size());//0
        System.out.println(list);//[]
    }
}

4.ArrayList集合存儲基本類型

/*
    ArrayList集合_存儲基本數據類型
        ArrayList集合容器中存儲基本類型數據時,創建ArrayList集合對象時,<>中必須寫基本類型對應的引用類型
        說白了,就是基本類型對應的類
        byte            Byte
        short           Short
        int             Integer             特殊記憶
        long            Long
        float           Float
        double          Double
        char            Character           特殊記憶
        boolean         Boolean

    注意:
        集合存儲基本類型,只需要在創建集合對象時,<>中寫出基本類型對應的引用類型
        其它操作,都可以按照基本類型完成

 */
public class Demo05ArrayListBase {
    public static void main(String[] args) {
        //創建ArrayList集合對象,存儲數據的類型是整數(byte/short/int/long)
        //ArrayList<int> list = new ArrayList<int>();
        //ArrayList<byte> list = new ArrayList<byte>();
        //ArrayList<long> list = new ArrayList<long>();
        //ArrayList<short> list = new ArrayList<short>();

        //創建ArrayList集合對象,存儲數據的類型是整數(int)
        //ArrayList<int> list = new ArrayList<int>();//錯誤,<>中要寫引用類型,int對應的引用類型Integer
        ArrayList<Integer> list = new ArrayList<>();

        //添加元素
        list.add(100);
        list.add(200);
        list.add(300);

        //遍歷
        for (int i = 0; i < list.size(); i++) {
            //獲取當前元素
            int num = list.get(i);
            System.out.println(num);
        }

    }
}

5.ArrayList集合作爲方法參數

/*
    ArrayList集合作爲方法參數

    ArrayList集合作爲方法參數: 傳遞的是地址值
 */
public class Demo04ParamArrayList {
    public static void main(String[] args) {
        //1.創建ArrayList集合對象,存儲數據的類型Person
        ArrayList<Person> list = new ArrayList<>();
        //2.創建2個Person對象
        Person p1 = new Person("張三");
        Person p2 = new Person("李四");

        //3.把Person對象添加到ArrayList集合內部
        list.add(p1);
        list.add(p2);

        //4.調用方法完成遍歷
        printArrayList(list);

    }

    //定義方法,遍歷存儲Person對象的ArrayList集合對象
    public static void printArrayList(ArrayList<Person> list) {
        //for循環遍歷ArrayList集合
        for (int i = 0; i < list.size(); i++) {
            Person p = list.get(i);
            System.out.println(p.getName());
        }
    }
}

6.ArrayList集合作爲方法返回值

/*
    ArrayList集合作爲方法參數

    ArrayList集合作爲方法返回值: 返回的是集合的地址值
 */
public class Demo05ReturnArrayList {
    public static void main(String[] args) {

        //調用方法,獲取存儲多個Person對象的ArrayList集合對象
        ArrayList<Person> list = getArrayList();

        //遍歷集合
        for (int i = 0; i < list.size(); i++) {
            Person p = list.get(i);
            System.out.println(p.getName());
        }

    }
    //定義方法getArrayList,獲取一個存儲多個Person對象的ArrayList集合對象
    public static ArrayList<Person> getArrayList() {
        //1.創建ArrayList集合對象,存儲數據的類型Person
        ArrayList<Person> list = new ArrayList<>();
        //2.創建2個Person對象
        Person p1 = new Person("張三");
        Person p2 = new Person("李四");

        //3.把Person對象添加到ArrayList集合內部
        list.add(p1);
        list.add(p2);

        //4.返回ArrayList集合對象
        return list;
    }
}

    System.out.println("刪除bbb後集合內容: "+list);//[aaa, ccc, ddd]:aaa索引編號是0,ccc索引編號是1,ddd索引編號是2

    //刪除索引爲1的元素
    //public E remove(int index) ：移除此集合中指定位置上的元素。返回被刪除的元素。
    String whoRemoved = list.remove(1);
    System.out.println("誰被刪除了呢? "+whoRemoved);//ccc
    System.out.println("刪除索引1的元素後集合內容: "+list);//[aaa, ddd]:aaa索引編號是0,ddd索引編號是1

    //public E get(int index) ：返回此集合中指定位置上的元素。返回獲取的元素。
    //獲取aaa
    String s = list.get(0);
    System.out.println("索引0對應的元素:"+s);//aaa
    //獲取ddd
    String s2 = list.get(1);
    System.out.println("索引1對應的元素:"+s2);//ddd
    System.out.println("獲取0和1索引元素後集合內容: "+list);//[aaa, ddd]:aaa索引編號是0,ddd索引編號是1

    //public E set(int index,E element) ：修改指定索引處的元素，返回被修改的元素。
    //把aaa變成a
    String whoUpdate = list.set(0, "a");
    System.out.println("誰被修改了呢?"+whoUpdate);//aaa
    System.out.println("修改索引0對應的元素後,集合內容: "+list);//[a, ddd]
    //把ddd變成d
    whoUpdate = list.set(1,"d");
    System.out.println("誰被修改了呢?"+whoUpdate);//aaa
    System.out.println("修改索引1對應的元素後,集合內容: "+list);//[a, d]: a索引編號是0,d索引編號是1


    System.out.println("集合中元素的數量: "+list.size());//2

    list.clear();//清空集合元素
    System.out.println("集合中元素的數量: "+list.size());//0
    System.out.println(list);//[]
}

}

### 4.ArrayList集合存儲基本類型

```java
/*
    ArrayList集合_存儲基本數據類型
        ArrayList集合容器中存儲基本類型數據時,創建ArrayList集合對象時,<>中必須寫基本類型對應的引用類型
        說白了,就是基本類型對應的類
        byte            Byte
        short           Short
        int             Integer             特殊記憶
        long            Long
        float           Float
        double          Double
        char            Character           特殊記憶
        boolean         Boolean

    注意:
        集合存儲基本類型,只需要在創建集合對象時,<>中寫出基本類型對應的引用類型
        其它操作,都可以按照基本類型完成

 */
public class Demo05ArrayListBase {
    public static void main(String[] args) {
        //創建ArrayList集合對象,存儲數據的類型是整數(byte/short/int/long)
        //ArrayList<int> list = new ArrayList<int>();
        //ArrayList<byte> list = new ArrayList<byte>();
        //ArrayList<long> list = new ArrayList<long>();
        //ArrayList<short> list = new ArrayList<short>();

        //創建ArrayList集合對象,存儲數據的類型是整數(int)
        //ArrayList<int> list = new ArrayList<int>();//錯誤,<>中要寫引用類型,int對應的引用類型Integer
        ArrayList<Integer> list = new ArrayList<>();

        //添加元素
        list.add(100);
        list.add(200);
        list.add(300);

        //遍歷
        for (int i = 0; i < list.size(); i++) {
            //獲取當前元素
            int num = list.get(i);
            System.out.println(num);
        }

    }
}

5.ArrayList集合作爲方法參數

/*
    ArrayList集合作爲方法參數

    ArrayList集合作爲方法參數: 傳遞的是地址值
 */
public class Demo04ParamArrayList {
    public static void main(String[] args) {
        //1.創建ArrayList集合對象,存儲數據的類型Person
        ArrayList<Person> list = new ArrayList<>();
        //2.創建2個Person對象
        Person p1 = new Person("張三");
        Person p2 = new Person("李四");

        //3.把Person對象添加到ArrayList集合內部
        list.add(p1);
        list.add(p2);

        //4.調用方法完成遍歷
        printArrayList(list);

    }

    //定義方法,遍歷存儲Person對象的ArrayList集合對象
    public static void printArrayList(ArrayList<Person> list) {
        //for循環遍歷ArrayList集合
        for (int i = 0; i < list.size(); i++) {
            Person p = list.get(i);
            System.out.println(p.getName());
        }
    }
}

6.ArrayList集合作爲方法返回值

/*
    ArrayList集合作爲方法參數

    ArrayList集合作爲方法返回值: 返回的是集合的地址值
 */
public class Demo05ReturnArrayList {
    public static void main(String[] args) {

        //調用方法,獲取存儲多個Person對象的ArrayList集合對象
        ArrayList<Person> list = getArrayList();

        //遍歷集合
        for (int i = 0; i < list.size(); i++) {
            Person p = list.get(i);
            System.out.println(p.getName());
        }

    }
    //定義方法getArrayList,獲取一個存儲多個Person對象的ArrayList集合對象
    public static ArrayList<Person> getArrayList() {
        //1.創建ArrayList集合對象,存儲數據的類型Person
        ArrayList<Person> list = new ArrayList<>();
        //2.創建2個Person對象
        Person p1 = new Person("張三");
        Person p2 = new Person("李四");

        //3.把Person對象添加到ArrayList集合內部
        list.add(p1);
        list.add(p2);

        //4.返回ArrayList集合對象
        return list;
    }
}