Java基礎學習 -＞（個人學習記錄筆記）

@

目錄

• 第一章 認識 HelloWorld
  • 1.命名
    • 1. 命名規則
    • 2. 命名規範
• 第二章 常量
• 第三章 變量和資料類型
  • 3.1 變量概述
  • 3.2 資料類型
  • 3.3 變量的定義
  • 3.4 注意事項
    • 基本資料類型
    • 引用資料類型
• 第四章 資料類型轉換
  • 4.1 自動轉換
  • 4.2 強制類型轉換
  • 4.3 Ascall編碼表
• 第五章 運算符
  • 5.1 算數運算符
  • 5.2 指派運算符
  • 5.3 比較運算符
  • 5.4 邏輯運算符
  • 5.5 三元運算符
• 第六章 方法入門
  • 6.1 矩形列印
  • 6.2 方法的定義格式與三種調用格式
  • 6.3 方法有參調用，與無參調用
  • 6.4 有傳回值與無傳回值
    • 1. 比較兩個數字
    • 2. 前100項和
    • 3. 列印指定次數的内容
    • 4.注意事項
• 第七章 Jshell腳本工具
• 第八章 流程控制
  • 8.1 順序結構
  • 8.2 單if語句
  • 8.3 标準的if-else語句
  • 8.4 多分支語句
    • 題目：使用三元運算符和标準的if-else語句分别實作：取兩個數字當中的最大值
  • 8.5 開關語句
  • 8.6 for循環
  • 8.7 while循環
  • 8.8 do-while循環
    • 題目：求出1-100之間的偶數和。
  • 8.9 三種循環的差別
  • 8.10 break關鍵字的用法
  • 8.11 continue關鍵字
  • 8.12 死循環
  • 8.13 嵌套循環體
• 第九章 方法重載
  • 9.1知識點
    • 1.比較兩個資料是否相等。
    • 2. 判斷哪些是正确的重載
    • 3. 實作重載的pri
• 第十章 數組
  • 10.1 定義與動态初始化
  • 10.2 靜态初始化
  • 10.3 靜态動态省略格式
  • 10.4 靜态動态初始化取值
    • 靜态初始化取值
    • 動态初始化取值
  • 10.5 記憶體劃分
    • 記憶體主要劃分5個部分
    • 隻有一個數組的記憶體圖
    • 有兩個數組的記憶體圖
    • 兩個引用指向同一個數組的記憶體圖
  • 10.6 數組索引越界異常
  • 10.7 空指針異常
  • 10.8 擷取數組的長度
  • 10.9 數組的周遊輸出
    • 求數組中的最大值
    • 數組元素的反轉
  • 10.10 數組作為方法參數
  • 10.11 數組作為方法傳回值

javac 檔案名.java 編譯

java 檔案名 運作

idea常用快捷鍵

注釋方法與C語言相同

// 第一行的第三個單詞必須和所在的檔案名稱完全一樣，大小寫也要一樣
//public class 後面代表定義一個類的名稱，類是Java當中所有源代碼的基本組織機關。
public class HelloWorld {
	// 第二行是萬年不變的固定寫法，代表main方法
	// 這一行代表程式執行的起點
    public static void main(String[] args){
		// 第三行代表列印輸出語句（其實就是螢幕顯示）
        System.out.println("Hello,World!");
    }
}
           

1.1 硬性要求

• 辨別符可以包含英文26個字母（區分大小寫）、0-9數字、$（美元符号） 和 _（下劃線）
• 辨別符不能以數字開頭
• 辨別符不能是關鍵字

2.1 軟性建議

• 類名規範：首字母大寫，後面每個單詞首字母大寫（大駝峰式）。HelloWorld
• 變量名規範：首字母小寫，後面每個單詞首字母大寫（小駝峰式）helloWorld
• 方法名規範：同變量名

常量：在程式運作期間，固定不變的量

常量的分類：

1. 字元串常量：凡是用雙引号引起來的部分，叫做字元串常量，例如：“abc”、“Hello”、“123”
2. 整數常量：直接寫上的數字，沒有小數點，例如：100、200、0、-250
3. 浮點數常量：直接寫上的數字，有小數點。例如：2.5、-3.14、0.0
4. 字元常量：凡是用單引号引起來的單個字元，就做字元常量。例如：‘A’、'b'、'9'、'中'
5. 布爾常量：隻有量中取值。true、false.
6. 空常量：null.代表沒有任何資料

public class test {
	public static void main(String[] args) {
		// 字元串常量
		System.out.println("ABC");
		System.out.println("");
		System.out.println("XYZ");
		
		// 整數常量
		System.out.println(30);
		System.out.println(-500);
		
		// 浮點數常量（小數）
		System.out.println(1.14);
		System.out.println(-2.5);
		
		//字元常量
		System.out.println('A');
		System.out.println('6');
		//System.out.println('')//兩個單引号中間必須僅有一個字元，沒有不行。
		//System.out.println('AB');//兩個單引号中間必須僅有一個字元，兩個不行。
		
		//布爾常量
		System.out.println(true);
		System.out.println(false);
		
		//空常量，空常量不能直接用來列印輸出。
		//System.out.println(null); 
	}
}
           

• 變量：常量是固定不變的資料，那麼在程式中可以變化的量稱為變量。

  數學中，可以使用字母代替數字運算，例如x=1+5或者6=x+5。

  程式中，可以使用字母儲存數字的方式進行運算，提高計算能力，可以解決更多的問題。别不x儲存5，x也可以儲存6，這樣x儲存的資料是可以改變的，也就是我們所講解的變量。

Java中要求一個變量每次隻能儲存一個資料，必須要明确儲存的資料類型。

/*
變量：程式運作期間，内容可以發生改變的量。

建立一個變量并且使用的格式：

資料類型 變量名稱; // 建立了一個變量
變量名稱 = 資料值; // 指派，将右邊的資料值，指派交給左邊的變量

一步到位的格式：

資料類型 變量名稱 = 資料值; // 在建立一個變量的同時，立刻放入指定的資料值
*/
public class Demo02Variable {
	public static void main(String[] args) {
		// 建立一個變量
		// 格式：資料類型 變量名稱;
		int num1;
		// 向變量當中存入一個資料
		// 格式：變量名稱 = 資料值;
		num1 = 10;
		// 當列印輸出變量名稱的時候，顯示出來的是變量的内容
		System.out.println(num1); // 10
		
		// 改變變量當中本來的數字，變成新的數字
		num1 = 20;
		System.out.println(num1); // 20
		
		// 使用一步到位的格式來定義變量
		// 格式：資料類型 變量名稱 = 資料值;
		int num2 = 25;
		System.out.println(num2); // 25
		
		num2 = 35;
		System.out.println(num2); // 35
		System.out.println("===============");
		
		byte num3 = 30; // 注意：右側數值的範圍不能超過左側資料類型的取值範圍
		System.out.println(num3); // 30
		
		// byte num4 = 400; // 右側超出了byte資料範圍，錯誤！
		
		short num5 = 50;
		System.out.println(num5); // 50
		
		long num6 = 3000000000L;
		System.out.println(num6); // 3000000000
		
		float num7 = 2.5F;
		System.out.println(num7); // 2.5
		
		double num8 = 1.2;
		System.out.println(num8); // 1.2
		
		char zifu1 = 'A';
		System.out.println(zifu1); // A
		
		zifu1 = '中';
		System.out.println(zifu1); // 中
		
		boolean var1 = true;
		System.out.println(var1); // true
		
		var1 = false;
		System.out.println(var1); // false
		
		// 将一個變量的資料内容，指派交給另一個變量
		// 右側的變量名稱var1已經存在，裡面裝的是false布爾值
		// 将右側變量裡面的false值，向左交給var2變量進行存儲
		boolean var2 = var1;
		System.out.println(var2); // false
	}
}
           

/*
使用變量的時候，有一些注意事項：

1. 如果建立多個變量，那麼變量之間的名稱不可以重複。
2. 對于float和long類型來說，字母字尾F和L不要丢掉。
3. 如果使用byte或者short類型的變量，那麼右側的資料值不能超過左側類型的範圍。
4. 沒有進行指派的變量，不能直接使用；一定要指派之後，才能使用。
5. 變量使用不能超過作用域的範圍。
【作用域】：從定義變量的一行開始，一直到直接所屬的大括号結束為止。
6. 可以通過一個語句來建立多個變量，但是一般情況不推薦這麼寫。
*/
public class Demo03VariableNotice {
	public static void main(String[] args) {
		int num1 = 10; // 建立了一個新的變量，名叫num1
		// int num1 = 20; // 又建立了另一個新的變量，名字也叫num1，錯誤！
		
		int num2 = 20;
		
		int num3;
		num3 = 30;
		
		int num4; // 定義了一個變量，但是沒有進行指派
		// System.out.println(num4); // 直接使用列印輸出就是錯誤的！
		
		// System.out.println(num5); // 在建立變量之前，不能使用這個變量
		
		int num5 = 500;
		System.out.println(num5); // 500
		
		{
			int num6 = 60;
			System.out.println(num6); // 60
		}
		// int num6;
		// System.out.println(num6); // 已經超出了大括号的範圍，超出了作用域，變量不能再使用了
		
		// 同時建立了三個全都是int類型的變量
		int a, b, c;
		// 各自分别指派
		a = 10;
		b = 20;
		c = 30;
		System.out.println(a); // 10
		System.out.println(b); // 20
		System.out.println(c); // 30
		
		// 同時建立三個int變量，并且同時各自指派
		int x = 100, y = 200, z = 300;
		System.out.println(x); // 100
		System.out.println(y); // 200
		System.out.println(z); // 300
	}
}
           

• 整數型 byte short int long
• 浮點型 float double
• 字元型 char
• 布爾型 boolean

字元串、數組、類、接口、Lambda
           

注意事項：

1. 字元串不是基本類型，而是引用類型。
2. 浮點型可能隻是一個近似值，并非精确的值。
3. 資料範圍與位元組數不一定相關，例如float資料範圍比long更加廣泛，但是float是4位元組，long是8位元組。

4. 浮點數當中預設類型是double。如果一定要使用float類型，需要加上一個字尾F。

   如果是整數，預設為int類型，如果一定要使用long類型，需要加上一個字尾L。推薦使用大寫字母字尾。

   

/*
當資料類型不一樣時，将會發生資料類型轉換。

自動類型裝換(隐式)
	1. 特點:代碼不需要進行特殊處理，自動完成。
	2. 規則:資料範圍從小到大。
強制類型轉換(顯式)
*/
public class Demo01DataType{
	public static void main(String[] srgs){
		System.out.println(1024);//這就是一個整數，預設就是int類型
		System.out.println(3.14);//這就是一個浮點數，預設是就是double類型
		
		// 左邊是long類型，右邊是預設的int類型，左右不一樣
		// 一個等号代表指派，将右側的int常量，交給左側的long變量進行存儲
		// int --> long，符合了資料範圍從小到大的要求
		// 這一行代碼發生了自動類型轉換。
		long num1 = 100;
		System.out.println(num1); //100
		
		// 左邊是double類型，右邊是float類型，左右不一樣
		// float-->double,符合了資料範圍從小到大的規則
		// 也發生了自動類型轉換
		double num2 = 2.5F;
		System.out.println(num2);//2.5
		
		// 左邊是float類型，右邊是long類型，左右不一樣
		// long-->float，範圍是float更大一些，符合了資料範圍從小到大的規則
		//也發生了自動類型轉換
		float num3 = 30L;
	}
}
           

/*
強制類型轉換
	1. 特點：代碼需要進行特殊的格式處理，不能自動完成。
	2. 格式：範圍小的類型 範圍小的變量名 = (範圍小的類型) 原本範圍大的資料;

注意事項：
	1. 強制類型轉換一般不推薦使用，因為有可能發生精度損失、資料溢出。
	2. byte/short/char這三種類型都可以發生數學運算，例如加法“+”.
	3. byte/short/char這三種類型在運算的時候，都會被首先提升成為int類型，然後再計算。
	4. boolean類型不能發生資料類型轉換
*/
public class Demo02DataType {
	public static void main(String[] args) {
		// 左邊是int類型，右邊是long類型，不一樣
		// long --> int，不是從小到大
		// 不能發生自動類型轉換！
		// 格式：範圍小的類型 範圍小的變量名 = (範圍小的類型) 原本範圍大的資料;
		int num = (int) 100L;
		System.out.println(num);
		
		// long強制轉換成為int類型 資料溢出
		int num2 = (int) 6000000000L;
		System.out.println(num2); // 1705032704
		
		// double --> int，強制類型轉換
		int num3 = (int) 3.99;
		System.out.println(num3); // 3，這并不是四舍五入，所有的小數位都會被舍棄掉
		
		char zifu1 = 'A'; // 這是一個字元型變量，裡面是大寫字母A
		System.out.println(zifu1 + 1); // 66，也就是大寫字母A被當做65進行處理
		// 計算機的底層會用一個數字（二進制）來代表字元A，就是65
		// 一旦char類型進行了數學運算，那麼字元就會按照一定的規則翻譯成為一個數字
		
		byte num4 = 40; // 注意！右側的數值大小不能超過左側的類型範圍
		byte num5 = 50;
		// byte + byte --> int + int --> int
		int result1 = num4 + num5;
		System.out.println(result1); // 90
		
		short num6 = 60;
		// byte + short --> int + int --> int
		// int強制轉換為short：注意必須保證邏輯上真實大小本來就沒有超過short範圍，否則會發生資料溢出
		short result2 = (short) (num4 + num6);
		System.out.println(result2); // 100
	}
}
           

/*
數字和字元的對照關系表（編碼表）：

ASCII碼表：American Standard Code for Information Interchange，美國資訊交換标準代碼。
Unicode碼表：萬國碼。也是數字和符号的對照關系，開頭0-127部分和ASCII完全一樣，但是從128開始包含有更多字元。

48 - '0'
65 - 'A'
97 - 'a'
*/
public class Demo03DataTypeChar {
	public static void main(String[] args) {
		char zifu1 = '1';
		System.out.println(zifu1 + 0); // 49
		
		char zifu2 = 'A'; // 其實底層儲存的是65數字
		
		char zifu3 = 'c';
		// 左側是int類型，右邊是char類型，
		// char --> int，确實是從小到大
		// 發生了自動類型轉換
		int num = zifu3;
		System.out.println(num); // 99
		
		char zifu4 = '中'; // 正确寫法
		System.out.println(zifu4 + 0); // 20013
	}
}
           

/*
運算符：進行特定操作的符号。例如：+
表達式：用運算符連起來的式子叫做表達式。例如：20 + 5。又例如：a + b

四則運算：
加：+
減：-
乘：*
除：/

取模（取餘數）：%

首先計算得到表達式的結果，然後再列印輸出這個結果。
複習一下國小一年級的除法公式：
被除數 / 除數 = 商 ... 餘數

對于一個整數的表達式來說，除法用的是整除，整數除以整數，結果仍然是整數。隻看商，不看餘數。
隻有對于整數的除法來說，取模運算符才有餘數的意義。

注意事項：
	1. 一旦運算當中有不同類型的資料，那麼結果将會是資料類型範圍大的那種。
*/
public class Demo04Operator {
	public static void main(String[] args) {
		// 兩個常量之間可以進行數學運算
		System.out.println(20 + 30);
		
		// 兩個變量之間也可以進行數學運算
		int a = 20;
		int b = 30;
		System.out.println(a - b); // -10
		
		// 變量和常量之間可以混合使用
		System.out.println(a * 10); // 200
		
		int x = 10;
		int y = 3;
		
		int result1 = x / y;
		System.out.println(result1); // 3
		
		int result2 = x % y;
		System.out.println(result2); // 餘數，模，1
		
		// int + double --> double + double --> double
		double result3 = x + 2.5;
		System.out.println(result3); // 12.5
	}
}
           

/*
四則運算當中的加号“+”有常見的三種用法：

1. 對于數值來說，那就是加法。
2. 對于字元char類型來說，在計算之前，char會被提升成為int，然後再計算。
char類型字元，和int類型數字，之間的對照關系表：ASCII、Unicode
3. 對于字元串String（首字母大寫，并不是關鍵字）來說，加号代表字元串連接配接操作。
任何資料類型和字元串進行連接配接的時候，結果都會變成字元串
*/
public class Demo05Plus {
	public static void main(String[] args) {
		// 字元串類型的變量基本使用
		// 資料類型 變量名稱 = 資料值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 20); // Java20
		
		// 優先級問題
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 20 + 30); // Java2030
		
		System.out.println(str2 + (20 + 30)); // Java50
	}
}
           

/*
自增運算符：++
自減運算符：--

基本含義：讓一個變量漲一個數字1，或者讓一個變量降一個數字1
使用格式：寫在變量名稱之前，或者寫在變量名稱之後。例如：++num，也可以num++
使用方式：
	1. 單獨使用：不和其他任何操作混合，自己獨立成為一個步驟。
	2. 混合使用：和其他操作混合，例如與指派混合，或者與列印操作混合，等。
使用差別：
	1. 在單獨使用的時候，前++和後++沒有任何差別。也就是：++num;和num++;是完全一樣的。
	2. 在混合的時候，有【重大差別】
		A. 如果是【前++】，那麼變量【立刻馬上+1】，然後拿着結果進行使用。	【先加後用】
		B. 如果是【後++】，那麼首先使用變量本來的數值，【然後再讓變量+1】。	【先用後加】
		
注意事項：
	隻有變量才能使用自增、自減運算符。常量不可發生改變，是以不能用。
*/
public class Demo06Operator {
	public static void main(String[] args) {
		int num1 = 10;
		System.out.println(num1); // 10
		++num1; // 單獨使用，前++
		System.out.println(num1); // 11
		num1++; // 單獨使用，後++
		System.out.println(num1); // 12
		System.out.println("=================");
		
		// 與列印操作混合的時候
		int num2 = 20;
		// 混合使用，先++，變量立刻馬上變成21，然後列印結果21
		System.out.println(++num2); // 21
		System.out.println(num2); // 21
		System.out.println("=================");
		
		int num3 = 30;
		// 混合使用，後++，首先使用變量本來的30，然後再讓變量+1得到31
		System.out.println(num3++); // 30
		System.out.println(num3); // 31
		System.out.println("=================");
		
		int num4 = 40;
		// 和指派操作混合
		int result1 = --num4; // 混合使用，前--，變量立刻馬上-1變成39，然後将結果39交給result1變量
		System.out.println(result1); // 39
		System.out.println(num4); // 39
		System.out.println("=================");
		
		int num5 = 50;
		// 混合使用，後--，首先把本來的數字50交給result2，然後我自己再-1變成49
		int result2 = num5--;
		System.out.println(result2); // 50
		System.out.println(num5); // 49
		System.out.println("=================");
		
		int x = 10;
		int y = 20;
		// 11 + 20 = 31
		int result3 = ++x + y--;
		System.out.println(result3); // 31
		System.out.println(x); // 11
		System.out.println(y); // 19
		
		// 30++; // 錯誤寫法！常量不可以使用++或者--
	}
}
           

/*
指派運算符分為：

基本指派運算符：就是一個等号“=”，代表将右側的資料交給左側的變量。
	int a = 30;

複合指派運算符：
	+=		a += 3		相當于		a = a + 3
	-=		b -= 4		相當于		b = b - 4
	*=		c *= 5		相當于		c = c * 5
	/=		d /= 6		相當于		d = d / 6
	%=		e %= 7		相當于		e = e % 7

注意事項：
	1. 隻有變量才能使用指派運算符，常量不能進行指派。
	2. 複合指派運算符其中隐含了一個強制類型轉換。
*/
public class Demo07Operator {
	public static void main(String[] args) {
		int a = 10;
		// 按照公式進行翻譯：a = a + 5
		// a = 10 + 5;
		// a = 15;
		// a本來是10，現在重新指派得到15
		a += 5; 
		System.out.println(a); // 15
		
		int x = 10;
		// x = x % 3;
		// x = 10 % 3;
		// x = 1;
		// x本來是10，現在重新指派得到1
		x %= 3;
		System.out.println(x); // 1
		
		// 50 = 30; // 常量不能進行指派，不能寫在指派運算符的左邊。錯誤寫法！
		
		byte num = 30;
		// num = num + 5;
		// num = byte + int
		// num = int + int
		// num = int
		// num = (byte) int
		num += 5;
		System.out.println(num); // 35
	}
}
           

/*
比較運算符：
大于：		>
小于：		<
大于等于：	>=
小于等于：	<=
相等：		==	【兩個等号連寫才是相等，一個等号代表的是指派】
不相等：	!=

注意事項：
1. 比較運算符的結果一定是一個boolean值，成立就是true，不成立就是false
2. 如果進行多次判斷，不能連着寫。
數學當中的寫法，例如：1 < x < 3
程式當中【不允許】這種寫法。
*/
public class Demo08Operator {
	public static void main(String[] args) {
		System.out.println(10 > 5); // true
		int num1 = 10;
		int num2 = 12;
		System.out.println(num1 < num2); // true
		System.out.println(num2 >= 100); // false
		System.out.println(num2 <= 100); // true
		System.out.println(num2 <= 12); // true
		System.out.println("===============");
		
		System.out.println(10 == 10); // true
		System.out.println(20 != 25); // true
		System.out.println(20 != 20); // false
		
		int x = 2;
		// System.out.println(1 < x < 3); // 錯誤寫法！編譯報錯！不能連着寫。
	}
}
           

/*
與（并且）	&&	全都是true，才是true；否則就是false
或（或者）	||	至少一個是true，就是true；全都是false，才是false
非（取反）	!	本來是true，變成false；本來是false，變成true

與“&&”，或“||”，具有短路效果：如果根據左邊已經可以判斷得到最終結果，那麼右邊的代碼将不再執行，進而節省一定的性能。

注意事項：
1. 邏輯運算符隻能用于boolean值。
2. 與、或需要左右各自有一個boolean值，但是取反隻要有唯一的一個boolean值即可。
3. 與、或兩種運算符，如果有多個條件，可以連續寫。
兩個條件：條件A && 條件B
多個條件：條件A && 條件B && 條件C

TIPS：
對于1 < x < 3的情況，應該拆成兩個部分，然後使用與運算符連接配接起來：
int x = 2;
1 < x && x < 3
*/
public class Demo09Logic {
	public static void main(String[] args) {
		System.out.println(true && false); // false
		// true && true --> true
		System.out.println(3 < 4 && 10 > 5); // true
		System.out.println("============");
		
		System.out.println(true || false); // true
		System.out.println(true || true); // true
		System.out.println(false || false); // false
		System.out.println("============");
		
		System.out.println(true); // true
		System.out.println(!true); // false	
		System.out.println("============");
		
		int a = 10;
		// false && ...
		System.out.println(3 > 4 && ++a < 100); // false
		System.out.println(a); // 10
		System.out.println("============");
		
		int b = 20;
		// true || ...
		System.out.println(3 < 4 || ++b < 100); // true
		System.out.println(b); // 20
	}
}
           

/*
一進制運算符：隻需要一個資料就可以進行操作的運算符。例如：取反!、自增++、自減--
二進制運算符：需要兩個資料才可以進行操作的運算符。例如：加法+、指派=
三元運算符：需要三個資料才可以進行操作的運算符。

格式：
資料類型 變量名稱 = 條件判斷 ? 表達式A : 表達式B;

流程：
首先判斷條件是否成立：
	如果成立為true，那麼将表達式A的值指派給左側的變量；
	如果不成立為false，那麼将表達式B的值指派給左側的變量；
二者選其一。

注意事項：
1. 必須同時保證表達式A和表達式B都符合左側資料類型的要求。
2. 三元運算符的結果必須被使用。
*/
public class Demo10Operator {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		// 資料類型 變量名稱 = 條件判斷 ? 表達式A : 表達式B;
		// 判斷a > b是否成立，如果成立将a的值指派給max；如果不成立将b的值指派給max。二者選其一
		int max = a > b ? a : b; // 最大值的變量
		System.out.println("最大值：" + max); // 20
		
		// int result = 3 > 4 ? 2.5 : 10; // 錯誤寫法！
		
		System.out.println(a > b ? a : b); // 正确寫法！
		
		// a > b ? a : b; // 錯誤寫法！
	}
}
           

/*
定義一個方法的格式：
public static void 方法名稱() {
	方法體
}

方法名稱的命名規則和變量一樣，使用小駝峰。
方法體：也就是大括号當中可以包含任意條語句。

注意事項：
1. 方法定義的先後順序無所謂。
2. 方法的定義不能産生嵌套包含關系。
3. 方法定義好了之後，不會執行的。如果要想執行，一定要進行方法的【調用】。

如何調用方法，格式：

方法名稱();
*/
public class Demo11Method {
	
	public static void main(String[] args) {
		farmer(); // 調用農民的方法
		seller(); // 調用小商販的方法
		cook(); // 調用廚子的方法
		me(); // 調用我自己的方法
	}
	
	// 廚子
	public static void cook() {
		System.out.println("洗菜");
		System.out.println("切菜");
		System.out.println("炒菜");
		System.out.println("裝盤");
	}
	
	// 我
	public static void me() {
		System.out.println("吃");
	}
	
	// 小商販
	public static void seller() {
		System.out.println("運輸到農貿市場");
		System.out.println("擡高價格");
		System.out.println("吆喝");
		System.out.println("賣給廚子");
	}
	
	// 農民伯伯
	public static void farmer() {
		System.out.println("播種");
		System.out.println("澆水");
		System.out.println("施肥");
		System.out.println("除蟲");
		System.out.println("收割");
		System.out.println("賣給小商販");
	}
}
           

/*
複習一下此前學習的方法基礎入門知識。

定義格式：
public static void 方法名稱() {
    方法體
}

調用格式：
方法名稱();

注意事項：
1. 方法定義的先後順序無所謂。
2. 方法定義必須是挨着的，不能在一個方法的内部定義另外一個方法。
3. 方法定義之後，自己不會執行的；如果希望執行，一定要進行方法的調用。
 */
public class Demo01Method {

    public static void main(String[] args) {
        printMethod();
    }
    public static void printMethod() {
        for (int j = 0; j < 5; j++) {
            for (int i = 0; i < 20; i++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

}
           

/*
方法其實就是若幹語句的功能集合。

方法好比是一個工廠。
蒙牛工廠     原料：奶牛、飼料、水
            産出物：奶制品
鋼鐵工廠     原料：鐵礦石、煤炭
            産出物：鋼鐵建材

參數（原料）：就是進入方法的資料。
傳回值（産出物）：就是從方法中出來的資料。

定義方法的完整格式：
修飾符 傳回值類型 方法名稱(參數類型 參數名稱, ...) {
    方法體
    return 傳回值;
}

修飾符：現階段的固定寫法，public static
傳回值類型：也就是方法最終産生的資料結果是什麼類型
方法名稱：方法的名字，規則和變量一樣，小駝峰
參數類型：進入方法的資料是什麼類型
參數名稱：進入方法的資料對應的變量名稱
PS：參數如果有多個，使用逗号進行分隔
方法體：方法需要做的事情，若幹行代碼
return：兩個作用，第一停止目前方法，第二将後面的傳回值還給調用處
傳回值：也就是方法執行後最終産生的資料結果

注意：return後面的“傳回值”，必須和方法名稱前面的“傳回值類型”，保持對應。

定義一個兩個int數字相加的方法。三要素：
傳回值類型：int
方法名稱：sum
參數清單：int a, int b

方法的三種調用格式。
1. 單獨調用：方法名稱(參數);
2. 列印調用：System.out.println(方法名稱(參數));
3. 指派調用：資料類型 變量名稱 = 方法名稱(參數);

注意：此前學習的方法，傳回值類型固定寫為void，這種方法隻能夠單獨調用，不能進行列印調用或者指派調用。
*/
public class Demo02MethodDefine {

    public static void main(String[] args) {
        // 單獨調用
        sum(10, 20);
        System.out.println("===========");

        // 列印調用
        System.out.println(sum(10, 20)); // 30
        System.out.println("===========");

        // 指派調用
        int number = sum(15, 25);
        number += 100;
        System.out.println("變量的值：" + number); // 140
    }

    public static int sum(int a, int b) {
        System.out.println("方法執行啦！");
        int result = a + b;
        return result;
    }
           

/*
有參數：小括号當中有内容，當一個方法需要一些資料條件，才能完成任務的時候，就是有參數。
例如兩個數字相加，必須知道兩個數字是各自多少，才能相加。

無參數：小括号當中留白。一個方法不需要任何資料條件，自己就能獨立完成任務，就是無參數。
例如定義一個方法，列印固定10次HelloWorld。
 */
public class Demo03MethodParam {

    public static void main(String[] args) {
        method1(10, 20);
        System.out.println("==============");
        method2();
    }

    // 兩個數字相乘，做乘法，必須知道兩個數字各自是多少，否則無法進行計算
    // 有參數
    public static void method1(int a, int b) {
        int result = a * b;
        System.out.println("結果是：" + result);
    }

    // 例如列印輸出固定10次文本字元串
    public static void method2() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello, World!" + i);
        }
    }

}
           

/*
題目要求：定義一個方法，用來【求出】兩個數字之和。（你幫我算，算完之後把結果告訴我。）
題目變形：定義一個方法，用來【列印】兩個數字之和。（你來計算，算完之後你自己負責顯示結果，不用告訴我。）

注意事項：
對于有傳回值的方法，可以使用單獨調用、列印調用或者指派調用。
但是對于無傳回值的方法，隻能使用單獨調用，不能使用列印調用或者指派調用。
 */
public class Demo04MethodReturn {

    public static void main(String[] args) {
        // 我是main方法，我來調用你。
        // 我調用你，你來幫我計算一下，算完了之後，把結果告訴我的num變量
        int num = getSum(10, 20);
        System.out.println("傳回值是：" + num);
        System.out.println("==============");

        printSum(100, 200);
        System.out.println("==============");

        System.out.println(getSum(2, 3)); // 正确寫法
        getSum(3, 5); // 正确寫法，但是傳回值沒有用到
        System.out.println("==============");

        // 對于void沒有傳回值的方法，隻能單獨，不能列印或者指派
//        System.out.println(printSum(2, 3)); // 錯誤寫法！
//        System.out.println(void);

//        int num2 = printSum(10, 20); // 錯誤寫法！
//        int num3 = void;
//        void num4 = void;
    }

    // 我是一個方法，我負責兩個數字相加。
    // 我有傳回值int，誰調用我，我就把計算結果告訴誰
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }

    // 我是一個方法，我負責兩個數字相加。
    // 我沒有傳回值，不會把結果告訴任何人，而是我自己進行列印輸出。
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("結果是：" + result);
    }

}
           

/*
題目要求：
定義一個方法，用來判斷兩個數字是否相同。
 */
public class Demo01MethodSame {

    public static void main(String[] args) {
        System.out.println(isSame(10, 20)); // false
        System.out.println(isSame(20, 20)); // true
    }

    /*
    三要素：
    傳回值類型：boolean
    方法名稱：isSame
    參數清單：int a, int b
     */
    public static boolean isSame(int a, int b) {
        /*boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }*/

        // boolean same = a == b ? true : false;

        // boolean same = a == b;

        return a == b;
    }

}
           

/*
題目要求：
定義一個方法，用來求出1-100之間所有數字的和值。
 */
public class Demo02MethodSum {

    public static void main(String[] args) {
        System.out.println("結果是：" + getSum());
    }

    /*
    三要素
    傳回值：有傳回值，計算結果是一個int數字
    方法名稱：getSum
    參數清單：資料範圍已經确定，是固定的，是以不需要告訴我任何條件，不需要參數
     */
    public static int getSum() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }

}
           

/*
題目要求：
定義一個方法，用來列印指定次數的HelloWorld。
 */
public class Demo03MethodPrint {

    public static void main(String[] args) {
        printCount(10);
    }

    /*
    三要素
    傳回值類型：隻是進行一大堆列印操作而已，沒有計算，也沒有結果要告訴調用處
    方法名稱：printCount
    參數清單：到底要列印多少次？必須告訴我，否則我不知道多少次，沒法列印。次數：int
     */
    public static void printCount(int num) {
        for (int i = 0; i < num; i++) {
            System.out.println("Hello, World!" + (i + 1));
        }
    }

}
           

/*
使用方法的時候，注意事項：

1. 方法應該定義在類當中，但是不能在方法當中再定義方法。不能嵌套。
2. 方法定義的前後順序無所謂。
3. 方法定義之後不會執行，如果希望執行，一定要調用：單獨調用、列印調用、指派調用。
4. 如果方法有傳回值，那麼必須寫上“return 傳回值;”，不能沒有。
5. return後面的傳回值資料，必須和方法的傳回值類型，對應起來。
6. 對于一個void沒有傳回值的方法，不能寫return後面的傳回值，隻能寫return自己。
7. 對于void方法當中最後一行的return可以省略不寫。
8. 一個方法當中可以有多個return語句，但是必須保證同時隻有一個會被執行到，兩個return不能連寫。
 */
public class Demo04MethodNotice {

    public static int method1() {
        return 10;
    }

    public static void method2() {
//        return 10; // 錯誤的寫法！方法沒有傳回值，return後面就不能寫傳回值。
        return; // 沒有傳回值，隻是結束方法的執行而已。
    }

    public static void method3() {
        System.out.println("AAA");
        System.out.println("BBB");
//        return; // 最後一行的return可以省略不寫。
    }

    public static int getMax(int a, int b) {
        /*int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;*/

        if (a > b) {
            return a;
        } else {
            return b;
        }
    }

}
           

C:\Users\22509>jshell
|  歡迎使用 JShell -- 版本 15.0.1
|  要大緻了解該版本, 請鍵入: /help intro

jshell> /help intro
|
|                                   intro
|                                   =====
|
|  使用 jshell 工具可以執行 Java 代碼，進而立即擷取結果。
|  您可以輸入 Java 定義（變量、方法、類等等），例如：int x = 8
|  或 Java 表達式，例如：x + x
|  或 Java 語句或導入。
|  這些小塊的 Java 代碼稱為“片段”。
|
|  這些 jshell 工具指令還可以讓您了解和
|  控制您正在執行的操作，例如：/list
|
|  有關指令的清單，請執行：/help

jshell> System.out.p
print(     printf(    println(
jshell> System.out.println("hello,world");
hello,world

jshell> int a = 10;
a ==> 10

jshell> int b = 20;
b ==> 20

jshell> int result = a*b;
result ==> 200

jshell> /exit
|  再見
           

/*
對于byte/short/char三種類型來說，如果右側指派的數值沒有超過範圍，
那麼javac編譯器将會自動隐含地為我們補上一個(byte)(short)(char)。

1. 如果沒有超過左側的範圍，編譯器補上強轉。
2. 如果右側超過了左側範圍，那麼直接編譯器報錯。
*/
public class Demo12Notice {
	public static void main(String[] args) {
		// 右側确實是一個int數字，但是沒有超過左側的範圍，就是正确的。
		// int --> byte，不是自動類型轉換
		byte num1 = /*(byte)*/ 30; // 右側沒有超過左側的範圍
		System.out.println(num1); // 30
		
		// byte num2 = 128; // 右側超過了左側的範圍
		
		// int --> char，沒有超過範圍
		// 編譯器将會自動補上一個隐含的(char)
		char zifu = /*(char)*/ 65;
		System.out.println(zifu); // A
	}
}
           

/*
在給變量進行指派的時候，如果右側的表達式當中全都是常量，沒有任何變量，
那麼編譯器javac将會直接将若幹個常量表達式計算得到結果。
short result = 5 + 8; // 等号右邊全都是常量，沒有任何變量參與運算
編譯之後，得到的.class位元組碼檔案當中相當于【直接就是】：
short result = 13;
右側的常量結果數值，沒有超過左側範圍，是以正确。

這稱為“編譯器的常量優化”。

但是注意：一旦表達式當中有變量參與，那麼就不能進行這種優化了。
*/
public class Demo13Notice {
	public static void main(String[] args) {
		short num1 = 10; // 正确寫法，右側沒有超過左側的範圍，
		
		short a = 5;
		short b = 8;
		// short + short --> int + int --> int
		// short result = a + b; // 錯誤寫法！左側需要是int類型
		
		// 右側不用變量，而是采用常量，而且隻有兩個常量，沒有别人
		short result = 5 + 8;
		System.out.println(result);
		
		short result2 = 5 + a + 8; // 18 報錯 不再常量優化
	}
}
           

// 順序結構
public class Demo01Sequence {
	public static void main(String[] args) {
		System.out.println("今天天氣不錯");
		System.out.println("挺風和日麗的");
		System.out.println("我們下午沒課");
		System.out.println("這的确挺爽的");
	}
}
           

// 單if語句
public class Demo02If {
	public static void main(String[] args) {
		System.out.println("今天天氣不錯，正在壓馬路……突然發現一個快樂的地方：網吧");
		int age = 19;
		if (age >= 18) {
			System.out.println("進入網吧，開始high！");
			System.out.println("遇到了一群豬隊友，開始罵街。");
			System.out.println("感覺不爽，結賬走人。");
		}
		System.out.println("回家吃飯");
	}
}
           

// 标準的if-else語句
public class Demo03IfElse {
	public static void main(String[] args) {
		int num = 666;
		
		if (num % 2 == 0) { // 如果除以2能夠餘數為0，說明是偶數
			System.out.println("偶數");
		} else {
			System.out.println("奇數");
		}
	}
}
           

public class Demo05IfElsePractise {
	public static void main(String[] args) {
		int score = 120;
		if (score >= 90 && score <= 100) {
			System.out.println("優秀");
		} else if (score >= 80 && score < 90) {
			System.out.println("好");
		} else if (score >= 70 && score < 80) {
			System.out.println("良");
		} else if (score >= 60 && score < 70) {
			System.out.println("及格");
		} else if (score >= 0 && score < 60) {
			System.out.println("不及格");
		} else { // 單獨處理邊界之外的不合理情況
			System.out.println("資料錯誤");
		}
	}
}
           

// 題目：使用三元運算符和标準的if-else語句分别實作：取兩個數字當中的最大值
public class Demo06Max {
	public static void main(String[] args) {
		int a = 105;
		int b = 20;
		// 首先使用三元運算符
		// int max = a > b ? a : b;
		// 使用今天的if語句
		int max;
		if (a > b) {
			max = a;
		} else {
			max = b;
		}
		System.out.println("最大值：" + max);
	}
}
           

public class Demo07Switch {
	public static void main(String[] args) {
		int num = 10;
		
		switch (num) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("資料不合理");
				break; // 最後一個break語句可以省略，但是強烈推薦不要省略
		}
	}
}
           

/*
switch語句使用的注意事項：

1. 多個case後面的數值不可以重複。

2. switch後面小括号當中隻能是下列資料類型：
基本資料類型：byte/short/char/int
引用資料類型：String字元串、enum枚舉

3. switch語句格式可以很靈活：前後順序可以颠倒，而且break語句還可以省略。
“比對哪一個case就從哪一個位置向下執行，直到遇到了break或者整體結束為止。”
*/
public class Demo08SwitchNotice {
	public static void main(String[] args) {
		int num = 2;
		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;
		} // switch
	}
}
           

/*
循環結構的基本組成部分，一般可以分成四部分：

1. 初始化語句：在循環開始最初執行，而且隻做唯一一次。
2. 條件判斷：如果成立，則循環繼續；如果不成立，則循環退出。
3. 循環體：重複要做的事情内容，若幹行語句。
4. 步進語句：每次循環之後都要進行的掃尾工作，每次循環結束之後都要執行一次。
*/
public class Demo09For {
	public static void main(String[] args) {
		for (int i = 1; i <= 100; i++) {
			System.out.println("我錯啦！原諒我吧！" + i);
		}
		System.out.println("程式停止");
	}
}
           

/*
while循環有一個标準格式，還有一個擴充格式。

标準格式：
while (條件判斷) {
	循環體
}

擴充格式：

初始化語句;
while (條件判斷) {
	循環體;
	步進語句;
}
*/
public class Demo10While {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			System.out.println("我錯啦！" + i);
		}
		System.out.println("=================");
		
		int i = 1; // 1. 初始化語句
		while (i <= 10) { // 2. 條件判斷
			System.out.println("我錯啦！" + i); // 3. 循環體
			i++; // 4. 步進語句
		}
	}
}
           

/*
do-while循環的标準格式：

do {
	循環體
} while (條件判斷);

擴充格式：

初始化語句
do {
	循環體
	步進語句
} while (條件判斷);
*/
public class Demo11DoWhile {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			System.out.println("原諒你啦！起來吧！地上怪涼！" + i);
		}
		System.out.println("===============");
		
		int i = 1; // 1. 初始化語句
		do {
			System.out.println("原諒你啦！起來吧！地上怪涼！" + i); // 3. 循環體
			i++; // 4. 步進語句
		} while (i <= 10); // 2. 條件判斷
	}
}
           

/*
題目：求出1-100之間的偶數和。

思路：
1. 既然範圍已經确定了是1到100之間，那麼我就從1、2、3……一直到100這麼多數字一個一個進行檢查。
2. 總共有100個數字，并非所有數字都能用。必須要是偶數才能用，判斷（if語句）偶數：num % 2 == 0
3. 需要一個變量，用來進行累加操作。也就好比是一個存錢罐。
*/
public class Demo12HundredSum {
	public static void main(String[] args) {
		int sum = 0; // 用來累加的存錢罐
		
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) { // 如果是偶數
				sum += i;
			}
		}
		System.out.println("結果是：" + sum);
	}
}
           

/*
三種循環的差別。

1. 如果條件判斷從來沒有滿足過，那麼for循環和while循環将會執行0次，但是do-while循環會執行至少一次。
2. for循環的變量在小括号當中定義，隻有循環内部才可以使用。while循環和do-while循環初始化語句本來就在外面，是以出來循環之後還可以繼續使用。
*/
public class Demo13LoopDifference {
	public static void main(String[] args) {
		for (int i = 1; i < 0; i++) {
			System.out.println("Hello");
		}
		// System.out.println(i); // 這一行是錯誤寫法！因為變量i定義在for循環小括号内，隻有for循環自己才能用。
		System.out.println("================");
		
		int i = 1;
		do {
			System.out.println("World");
			i++;
		} while (i < 0);
		// 現在已經超出了do-while循環的範圍，我們仍然可以使用變量i
		System.out.println(i); // 2
	}
}
           

/*
break關鍵字的用法有常見的兩種：

1. 可以用在switch語句當中，一旦執行，整個switch語句立刻結束。
2. 還可以用在循環語句當中，一旦執行，整個循環語句立刻結束。打斷循環。

關于循環的選擇，有一個小建議：
凡是次數确定的場景多用for循環；否則多用while循環。
*/
public class Demo14Break {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			// 如果希望從第4次開始，後續全都不要了，就要打斷循環
			if (i == 4) { // 如果目前是第4次
				break; // 那麼就打斷整個循環
			}
			System.out.println("Hello" + i);
		}
	}
}
           

/*
另一種循環控制語句是continue關鍵字。
一旦執行，立刻跳過目前次循環剩餘内容，馬上開始下一次循環。
*/
public class Demo15Continue {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			if (i == 4) { // 如果目前是第4層
				continue; // 那麼跳過目前次循環，馬上開始下一次（第5層）
			}
			System.out.println(i + "層到了。");
		}
	}
}
           

/*
永遠停不下來的循環，叫做死循環。

死循環的标準格式：
while (true) {
	循環體
}
*/
public class Demo16DeadLoop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("I Love Java!");
		}
		
		// System.out.println("Hello");
	}
}
           

public class Demo17LoopHourAndMinute {
	public static void main(String[] args) {
		for (int hour = 0; hour < 24; hour++) { // 外層控制小時

			for (int minute = 0; minute < 60; minute++) { // 内層控制小時之内的分鐘
				System.out.println(hour + "點" + minute + "分");
			}

		}
	}
}
           

/*
對于功能類似的方法來說，因為參數清單不一樣，卻需要記住那麼多不同的方法名稱，太麻煩。

方法的重載（Overload）：多個方法的名稱一樣，但是參數清單不一樣。
好處：隻需要記住唯一一個方法名稱，就可以實作類似的多個功能。

方法重載與下列因素相關：
1. 參數個數不同
2. 參數類型不同
3. 參數的多類型順序不同

方法重載與下列因素無關：
1. 與參數的名稱無關
2. 與方法的傳回值類型無關
 */
public class Demo01MethodOverload {

    public static void main(String[] args) {
        /*System.out.println(sumTwo(10, 20)); // 30
        System.out.println(sumThree(10, 20, 30)); // 60
        System.out.println(sumFour(10, 20, 30, 40)); // 100*/

        System.out.println(sum(10, 20)); // 兩個參數的方法
        System.out.println(sum(10, 20, 30)); // 三個參數的方法
        System.out.println(sum(10, 20, 30, 40)); // 四個參數的方法
//        System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法來比對，是以錯誤！

        sum(10, 20);
    }

    public static int sum(int a, double b) {
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
        System.out.println("有2個參數的方法執行！");
        return a + b;
    }

    // 錯誤寫法！與方法的傳回值類型無關
//    public static double sum(int a, int b) {
//        return a + b + 0.0;
//    }

    // 錯誤寫法！與參數的名稱無關
//    public static int sum(int x, int y) {
//        return x + y;
//    }

    public static int sum(double a, double b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3個參數的方法執行！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4個參數的方法執行！");
        return a + b + c + d;
    }

}

           

/*
題目要求：
比較兩個資料是否相等。
參數類型分别為兩個byte類型，兩個short類型，兩個int類型，兩個long類型，
并在main方法中進行測試。
 */
public class Demo02MethodOverloadSame {

    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));

        System.out.println(isSame((short) 20, (short) 20));

        System.out.println(isSame(11, 12));

        System.out.println(isSame(10L, 10L));
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("兩個byte參數的方法執行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("兩個short參數的方法執行！");
        boolean same = a == b ? true : false;
        return same;
    }

    public static boolean isSame(int a, int b) {
        System.out.println("兩個int參數的方法執行！");
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("兩個long參數的方法執行！");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }

}

           

public static void open(){} // 正确重載
    public static void open(int a){} // 正确重載
    static void open(int a,int b){} // 代碼錯誤：和第8行沖突
    public static void open(double a,int b){} // 正确重載
    public static void open(int a,double b){} // 代碼錯誤：和第6行沖突
    public void open(int i,double d){} // 代碼錯誤：和第5行沖突
    public static void OPEN(){} // 代碼正确不會報錯，但是并不是有效重載
    public static void open(int i,int j){} // 代碼錯誤：和第3行沖突
           

// byte short int long float double char boolean
// String
// 在調用輸出語句的時候，println方法其實就是進行了多種資料類型的重載形式。
public class Demo04OverloadPrint {

    public static void main(String[] args) {
        myPrint(100); // int
        myPrint("Hello"); // String
    }

    public static void myPrint(byte num) {
        System.out.println(num);
    }

    public static void myPrint(short num) {
        System.out.println(num);
    }

    public static void myPrint(int num) {
        System.out.println(num);
    }

    public static void myPrint(long num) {
        System.out.println(num);
    }

    public static void myPrint(float num) {
        System.out.println(num);
    }

    public static void myPrint(double num) {
        System.out.println(num);
    }

    public static void myPrint(char zifu) {
        System.out.println(zifu);
    }

    public static void myPrint(boolean is) {
        System.out.println(is);
    }

    public static void myPrint(String str) {
        System.out.println(str);
    }

}
           

/*
數組的概念：是一種容器，可以同時存放多個資料值。

數組的特點：
1. 數組是一種引用資料類型
2. 數組當中的多個資料，類型必須統一
3. 數組的長度在程式運作期間不可改變

數組的初始化：在記憶體當中建立一個數組，并且向其中賦予一些預設值。

兩種常見的初始化方式：
1. 動态初始化（指定長度）
2. 靜态初始化（指定内容）

動态初始化數組的格式：
資料類型[] 數組名稱 = new 資料類型[數組長度];

解析含義：
左側資料類型：也就是數組當中儲存的資料，全都是統一的什麼類型
左側的中括号：代表我是一個數組
左側數組名稱：給數組取一個名字
右側的new：代表建立數組的動作
右側資料類型：必須和左邊的資料類型保持一緻
右側中括号的長度：也就是數組當中，到底可以儲存多少個資料，是一個int數字
 */
public class Demo01Array {

    public static void main(String[] args) {
        // 建立一個數組，裡面可以存放300個int資料
        // 格式：資料類型[] 數組名稱 = new 資料類型[數組長度];
        int[] arrayA = new int[300];

        // 建立一個數組，能存放10個double類型的資料
        double[] arrayB = new double[10];

        // 建立一個數組，能存放5個字元串
        String[] arrayC = new String[5];
    }

}

           

/*
動态初始化（指定長度）：在建立數組的時候，直接指定數組當中的資料元素個數。
靜态初始化（指定内容）：在建立數組的時候，不直接指定資料個數多少，而是直接将具體的資料内容進行指定。

靜态初始化基本格式：
資料類型[] 數組名稱 = new 資料類型[] { 元素1, 元素2, ... };

注意事項：
雖然靜态初始化沒有直接告訴長度，但是根據大括号裡面的元素具體内容，也可以自動推算出來長度。
 */
public class Demo02Array {

    public static void main(String[] args) {
        // 直接建立一個數組，裡面裝的全都是int數字，具體為：5、15、25
        int[] arrayA = new int[] { 5, 15, 25, 40 };

        // 建立一個數組，用來裝字元串："Hello"、"World"、"Java"
        String[] arrayB = new String[] { "Hello", "World", "Java" };
    }

}
           

/*
使用靜态初始化數組的時候，格式還可以省略一下。

标準格式：
資料類型[] 數組名稱 = new 資料類型[] { 元素1, 元素2, ... };

省略格式：
資料類型[] 數組名稱 = { 元素1, 元素2, ... };

注意事項：
1. 靜态初始化沒有直接指定長度，但是仍然會自動推算得到長度。
2. 靜态初始化标準格式可以拆分成為兩個步驟。
3. 動态初始化也可以拆分成為兩個步驟。
4. 靜态初始化一旦使用省略格式，就不能拆分成為兩個步驟了。

使用建議：
如果不确定數組當中的具體内容，用動态初始化；否則，已經确定了具體的内容，用靜态初始化。
 */
public class Demo03Array {

    public static void main(String[] args) {
        // 省略格式的靜态初始化
        int[] arrayA = { 10, 20, 30 };

        // 靜态初始化的标準格式，可以拆分成為兩個步驟
        int[] arrayB;
        arrayB = new int[] { 11, 21, 31 };

        // 動态初始化也可以拆分成為兩個步驟
        int[] arrayC;
        arrayC = new int[5];

        // 靜态初始化的省略格式，不能拆分成為兩個步驟。
//        int[] arrayD;
//        arrayD = { 10, 20, 30 };
    }

}
           

/*
直接列印數組名稱，得到的是數組對應的：記憶體位址哈希值。
二進制：01
十進制：0123456789
16進制：0123456789abcdef

通路數組元素的格式：數組名稱[索引值]
索引值：就是一個int數字，代表數組當中元素的編号。
【注意】索引值從0開始，一直到“數組的長度-1”為止。
 */
public class Demo04ArrayUse {

    public static void main(String[] args) {
        // 靜态初始化的省略格式
        int[] array = { 10, 20, 30 };

        System.out.println(array); // [I@75412c2f

        // 直接列印數組當中的元素
        System.out.println(array[0]); // 10
        System.out.println(array[1]); // 20
        System.out.println(array[2]); // 30
        System.out.println("=============");

        // 也可以将數組當中的某一個單個元素，指派交給變量
        int num = array[1];
        System.out.println(num); // 20
    }

}
           

/*
使用動态初始化數組的時候，其中的元素将會自動擁有一個預設值。規則如下：
如果是整數類型，那麼預設為0；
如果是浮點類型，那麼預設為0.0；
如果是字元類型，那麼預設為'\u0000'；
如果是布爾類型，那麼預設為false；
如果是引用類型，那麼預設為null。

注意事項：
靜态初始化其實也有預設值的過程，隻不過系統自動馬上将預設值替換成為了大括号當中的具體數值。
 */
public class Demo05ArrayUse {

    public static void main(String[] args) {
        // 動态初始化一個數組
        int[] array = new int[3];

        System.out.println(array); // 記憶體位址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("=================");

        // 将資料123指派交給數組array當中的1号元素
        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0
    }

}

           

public class Demo01ArrayOne {

    public static void main(String[] args) {
        int[] array = new int[3]; // 動态初始化
        System.out.println(array); // 位址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("==============");

        // 改變數組當中元素的内容
        array[1] = 10;
        array[2] = 20;
        System.out.println(array); // 位址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 10
        System.out.println(array[2]); // 20
    }
}

           

public class Demo02ArrayTwo {

    public static void main(String[] args) {
        int[] arrayA = new int[3];
        System.out.println(arrayA); // 位址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 0
        System.out.println(arrayA[2]); // 0
        System.out.println("==============");

        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA); // 位址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 10
        System.out.println(arrayA[2]); // 20
        System.out.println("==============");

        int[] arrayB = new int[3];
        System.out.println(arrayB); // 位址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 0
        System.out.println(arrayB[2]); // 0
        System.out.println("==============");

        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB); // 位址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 100
        System.out.println(arrayB[2]); // 200
    }

}

           

public class Demo03ArraySame {

    public static void main(String[] args) {
        int[] arrayA = new int[3];
        System.out.println(arrayA); // 位址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 0
        System.out.println(arrayA[2]); // 0
        System.out.println("==============");

        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA); // 位址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 10
        System.out.println(arrayA[2]); // 20
        System.out.println("==============");

        // 将arrayA數組的位址值，指派給arrayB數組
        int[] arrayB = arrayA;
        System.out.println(arrayB); // 位址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 10
        System.out.println(arrayB[2]); // 20
        System.out.println("==============");

        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB); // 位址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 100
        System.out.println(arrayB[2]); // 200
    }

}
           

/*
數組的索引編号從0開始，一直到“數組的長度-1”為止。

如果通路數組元素的時候，索引編号并不存在，那麼将會發生
數組索引越界異常
ArrayIndexOutOfBoundsException

原因：索引編号寫錯了。
解決：修改成為存在的正确索引編号。
 */
        public class Demo01ArrayIndex {

            public static void main(String[] args) {
                int[] array = { 15, 25, 35 };

                System.out.println(array[0]); //15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 錯誤寫法
        // 并不存在3号元素，是以發生異常
        System.out.println(array[3]);
    }

}

           

/*
所有的引用類型變量，都可以指派為一個null值。但是代表其中什麼都沒有。

數組必須進行new初始化才能使用其中的元素。
如果隻是指派了一個null，沒有進行new建立，
那麼将會發生：
空指針異常 NullPointerException

原因：忘了new
解決：補上new
 */
public class Demo02ArrayNull {

    public static void main(String[] args) {
        int[] array = null;
//        array = new int[3];
        System.out.println(array[0]);
    }

}
           

/*
如何擷取數組的長度，格式：
數組名稱.length

這将會得到一個int數字，代表數組的長度。

數組一旦建立，程式運作期間，長度不可改變。
 */
public class Demo03ArrayLength {

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6, 7, 8, 8, 65, 4};
        int len = arrayB.length;
        System.out.println("arrayB數組的長度是：" + len);
        System.out.println("=============");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}

           

/*
周遊數組，說的就是對數組當中的每一個元素進行逐一、挨個兒處理。預設的處理方式就是列印輸出。
 */
public class Demo04Array {

    public static void main(String[] args) {
        int[] array = { 15, 25, 30, 40, 50, 60, 75 };

        // 首先使用原始方式
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 30
        System.out.println(array[3]); // 40
        System.out.println(array[4]); // 50
        System.out.println(array[5]); // 50
        System.out.println("=================");

        // 使用循環，次數其實就是數組的長度。
        for (int i = 0; i < 6; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=================");

//        int len = array.length; // 長度
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

           

public class Demo05ArrayMax {

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, 30, 35 };

        int max = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果目前元素，比max更大，則換人
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 誰最後最厲害，就能在max當中留下誰的戰鬥力
        System.out.println("最大值：" + max);
    }
}





public class Demo06ArrayMin {

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, -20, 30, 35 };

        int min = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果目前元素，比min更小，則換人
            if (array[i] < min) {
                min = array[i];
            }
        }
        System.out.println("最小值：" + min);
    }

}

           

/*
數組元素的反轉：
本來的樣子：[1, 2, 3, 4]
之後的樣子：[4, 3, 2, 1]

要求不能使用新數組，就用原來的唯一一個數組。
 */
public class Demo07ArrayReverse {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        // 周遊列印數組本來的樣子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");
        /*
        初始化語句：int min = 0, max = array.length - 1
        條件判斷：min < max
        步進表達式：min++, max--
        循環體：用第三個變量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        // 再次列印周遊輸出數組後來的樣子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
           

/*
數組可以作為方法的參數。
當調用方法的時候，向方法的小括号進行傳參，傳遞進去的其實是數組的位址值。
 */
public class Demo01ArrayParam {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        System.out.println(array); // 位址值

        printArray(array); // 傳遞進去的就是array當中儲存的位址值
        System.out.println("==========AAA==========");
        printArray(array);
        System.out.println("==========BBB==========");
        printArray(array);
    }

    /*
    三要素
    傳回值類型：隻是進行列印而已，不需要進行計算，也沒有結果，用void
    方法名稱：printArray
    參數清單：必須給我數組，我才能列印其中的元素。int[] array
     */
    public static void printArray(int[] array) {
        System.out.println("printArray方法收到的參數是：");
        System.out.println(array); // 位址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
           

/*
一個方法可以有0、1、多個參數；但是隻能有0或者1個傳回值，不能有多個傳回值。
如果希望一個方法當中産生了多個結果資料進行傳回，怎麼辦？
解決方案：使用一個數組作為傳回值類型即可。

任何資料類型都能作為方法的參數類型，或者傳回值類型。

數組作為方法的參數，傳遞進去的其實是數組的位址值。
數組作為方法的傳回值，傳回的其實也是數組的位址值。
 */
public class Demo02ArrayReturn {

    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);

        System.out.println("main方法接收到的傳回值數組是：");
        System.out.println(result); // 位址值

        System.out.println("總和：" + result[0]);
        System.out.println("平均數：" + result[1]);
    }

    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c; // 總和
        int avg = sum / 3; // 平均數
        // 兩個結果都希望進行傳回

        // 需要一個數組，也就是一個塑膠兜，數組可以儲存多個結果
        /*
        int[] array = new int[2];
        array[0] = sum; // 總和
        array[1] = avg; // 平均數
        */

        int[] array = { sum, avg };
        System.out.println("calculate方法内部數組是：");
        System.out.println(array); // 位址值
        return array;
    }

}