javaSe總結1
————基礎班———— 1.安裝 JDK 與配置環境變數 如何配置 : –建立新的變數名稱：JAVA_HOME 計算機-右鍵屬性-高階系統設定-高階-環境變數-系統變數 –為JAVA_HOME新增變數值：JDK安裝目錄 –在path環境變數最前面新增如下內容 %JAVA_HOME%\bin;
- 建立 JAVA_HOME 變數,設定JDK的路徑. 不包含bin目錄.
- 在path環境變數中設定 path= %JAVA_HOME%\bin
2.第一個 Java 程式_HelloWorld
/*
1. 所有的Java程式碼都需要寫在 類 中. 類必須使用 class 開頭.
2. 需要給該類取一個名字. 名字必須遵守 駝峰命名規則
{} 大括號, 表示該類的作用範圍.
4. 如果一個程式需要被執行, 那麼該程式就必須擁有一個 主方法.
主方法的格式 : public static void main(String[] args) {} 主方法就是程式的入口.
5. 我們希望程式能夠看到一些結果, 因此需要 輸出語句.
輸出語句 : System.out.println(“需要輸出的內容即可.”);
6. 原始碼書寫完成, 之後 儲存, ctr+s 檔案型別為: .java 檔名: 必須與類名完全相同(大小寫都要一致)
7. 需要對原始檔進行 編譯class HelloWorld { public static void main(String[] args) { System.out.println(“Hello World.”); } }
3.註釋
/* 註釋 : 對程式進行解釋和說明的文字.
作用 : 註釋是 `程式猿 / 程式媛` 之間的交流工具. 注意 : 註釋是不會被虛擬機器編譯的. 註釋的分類 : 1. 單行註釋 2. 多行註釋 (不能巢狀) 3. 文件註釋 說明 : 註釋一定要有含義, 不要亂書寫, 在編寫的程式碼一定要養成書寫註釋的習慣.
*/
/** * 文件註釋 : 後期可以將文件註釋生成網頁檔案. * * @version 1.0 * @author 傳智播客 * @see www.itcast.cn */
// 定義了一個類, 類名為 HelloWorld3 class HelloWorld3 {
// 定義了程式的主方法
public static void main(String[] args) {
// 以下的程式碼只有上帝和我能看懂.
// 現在只有上帝能看懂了.
// 神奇, 勿動.
System.out.println("Hello World, 你好, 世界.");
}
}
4.常量
/* Java 中的常量 : (固定內容的書寫格式)
1. 整型常量 10, 20, 30,
2. 浮點型常量
2.1 單精度浮點型 12345.123456789f; (最多精確到 8 位) 12345.123
2.2 雙精度浮點型 12345.123456789; (最多精確到 16 位) 12345.123456789
3. 字元常量 A 中 特殊轉義字元 : \ (反斜槓) 必須使用 `單引號` 括起來.
t 字元t \t 製表符 4空格 8空格
n 字元n \n 換行
4. 字串常量 我們是偉大的中國人. 必須使用 `雙引號` 括起來.
5. 布林型別常量 true 真 (正確) false 假(錯誤)
6. 空型別常量 null 空 (將一個物件的引用清空)
注意點 :
字元 :
''; 錯誤! 什麼都不寫不正確.
' '; 正確! 因為空格也是一個字元.
字串 :
""; 正確! 字串可以什麼都不寫.
" "; 正確! 就寫一個空格也正確.
*/
class HelloWorld5 { public static void main(String[] args) { /* 10; // ; 表示一條語句的結束 100; 998;
10.88f;
12345.123456789;
'A';
'中';
'\t';
'\n';
"我們是偉大的中國人.";
true; // 布林型別
false;
"true"; // 字串型別
"false";
null; // 空型別
"null"; // 字串型別
*/
// println -> print line 列印換行
// \t 製表符 (對齊)
System.out.println("hello\nworld");
System.out.println("ab edf");
System.out.println("中國 偉大");
System.out.println("--------------------");
System.out.println("hello\tworld");
System.out.println("ab\tedf");
System.out.println("中國\t偉大");
}
}
5.變數 1.八種基本資料型別的演示 :
/* 基本資料型別 :
*/
class HelloWorld7 { public static void main(String[] args) {
// 1. byte -128 ~ 127
byte b = 127;
// 2. short -32768~32767
short s = 32767;
// 3. int -2147483648~2147483647 (預設型別)
int i = 2147483647;
// 4. long -9223372036854775808 ~ 9223372036854775807
long l = 9223372036854775807L;
// 5. float
float f = 12345.123456789f;
// 6. double
double d = 12345.12345678988;
// 7. char
char ch = 'A';
// 8. boolean
System.out.println("ch = " + ch); // 在字串中, + 符號表示拼接
}
}
2.變數的使用三步曲 : 1.定義 (申請空間) 2. 初始化 (賦值) 3. 使用 (輸出, 判斷, 賦值 …)
/* 變數使用的三步曲 : 1. 定義 2. 初始化 3. 使用
注意1 : 變數沒有初始化, 不可以直接使用.
注意2 : 變數可以在定義的同時進行初始化.
*/
class HelloWorld8 { public static void main(String[] args) { // 1. 定義 (申請空間) // int i;
// 2. 初始化 (給空間賦值)
// i = 100;
// i = 998;
// 定義變數的同時進行初始化.
int i = 100;
// 3. 使用 (輸出, 賦值, 比較, 判斷 ... )
System.out.println("i = " + i);
}
}
3.變數的作用域
/* 變數的作用域 : (作用範圍) */
class HelloWorld9 { public static void main(String[] args) { int num1 = 100;
// 定義了一個作用域 (小的作用範圍)
{
int num2 = 998;
System.out.println("num2 = " + num2);
System.out.println("num1 = " + num1);
}
System.out.println("num1 = " + num1);
// 重新申請空間, 再賦值
int num2 = 666;
// int num2 = 888; 錯誤! 在同一個作用域中, 變數不可以重名.
System.out.println("num2 = " + num2);
}
}
4.變數的資料型別轉換 :
/* 變數的資料型別轉換 :
特點 : Java語言是 `強型別` 語法. 不同的資料型別之間不可以進行運算.
1. 自動型別轉換 : 程式執行時, 不同的資料會以大型別作為引數. 運算時程式就會自動完成型別提升.
2. 強制型別轉換 : 當大型別強制賦值給小型別時, 需要手動完成強制型別轉換.
錯誤! 可能損失精度.
1. int -> byte
2. float -> int
*/
class HelloWorld10 { public static void main(String[] args) { /* int i = 298; byte b = (byte)(i); // 強轉 System.out.println(“b = ” + b); */
float f = 10.88f;
int i = (int) (f);
System.out.println("i = " + i);
/*
byte b = 10;
int i = 20;
// b = b + i; // byte + int
// 強制型別轉換
b = (byte)(b + i);
// i = b + i; // 正確
System.out.println("b = " + b);
*/
}
}
複合賦值運算子的自動強轉功能 :
/* * 搜狗輸入法可以使用 shift 進行中英轉換. * * 大寫 : 按住 shift, 再按需要的字母. */
public class Demo1 { public static void main(String[] args) { // 32767 short s = 32767; int i = 100;
s = (short) (s + i); // short + int -> 結果 int 型別
// 複合賦值運算子會 `自動完成` 了強轉的功能
// 強轉一定要小心, 因為資料一旦超過 `該型別` 的範圍, 就會出錯!
// s += i;
System.out.println(s);
}
}
5.表示式型別的自動提升 :
/* 表示式型別自動提升 :
byte + byte -> 結果為 int 型別.
short + short -> 結果為 int 型別.
整型中最常用的型別為 : int 型別.
為什麼 byte , short 不常用呢 ??? 原因是因為 byte 和 short 表示式結果型別會自動提升.
*/
class HelloWorld11 { public static void main(String[] args) { /* byte b3 = 10; b3 + 1; // int 型別 */
short b1 = 110;
short b2 = 20;
short result = b1 + b2; // byte + byte
System.out.println("result = " + result);
}
}
6.Eclipse 快捷鍵
/* alt + / 程式碼補全 ，程式碼提示 shift + enter 調到下一行開始處.
ctrl + / 新增或取消單行註釋
ctrl + shift + / 新增多行註釋
ctrl + shift + \ 取消多行註釋
ctrl + D 刪除游標所在的行
ctrl + 1 錯誤提示 ，給出解決方案
alt + 向下或向上鍵 移動當前選中的行
ctrl + alt + 向下或向上鍵 複製當前選中的行
ctrl + shift + F 格式化程式碼
*/
7.除法 / 取餘運算
// arithmetic 算術 /* * 算術運算子 : + - * / % (取餘) * * 取餘的使用場景 : * 1. 判斷奇偶數. 數值 % 2 0 (偶數) 1 (奇數) * 2. 控制範圍. 數值 % 6 結果 [0~5] */
public class ArithmeticDemo1 { public static void main(String[] args) {
// 取餘的使用場景2 : 控制結果的取值範圍
int number2 = 6;
int result4 = number2 % 6;
System.out.println("result4 = " + result4);
// 取餘的使用場景1 : 判斷奇偶數. 數值 % 2
int number = 99;
int result3 = number % 2; // 0 (偶數) 1 (奇數)
System.out.println("result3 = " + result3);
// 演示2 : 取餘的演示 :
// 取餘 : (剩餘)
// 商 : 3
// 餘 : 1
int num1 = 10;
int num2 = 5;
int result2 = num1 % num2;
System.out.println("result2 = " + result2); // 0
// 演示1 : 除法的使用注意點 :
int i1 = 10;
int i2 = 4;
// int result = i1 / i2; // 2
// Type mismatch: cannot convert from float to int
// 型別不匹配 : 不能將 float 型別轉換為 int 型別接收
float result = (float) i1 / i2; // float / int
System.out.println("result = " + result);
}
}
注意點 :
public class ArithmeticDemo4 { public static void main(String[] args) {
int num1 = 10;
int num2 = 4;
float result = num1 / num2; (float) num1 / num2; // 2.5
System.out.println(result); // 2.0
}
}
8.算術表示式的結果型別
/* * 算術表示式的結果是什麼型別的 : 大型別 * * 注意1 : 浮點型 > 整型 double > float > long > int > short > byte */
public class ArithmeticDemo2 { public static void main(String[] args) {
// 演示2 : long + float 結果為 float 型別
long num3 = 80L;
float num4 = 10.88f;
float result2 = num3 + num4;
System.out.println("result2 = " + result2);
// 演示1 : int + float 結果為 float 型別
int num1 = 10;
float num2 = 22.15f;
float result = num1 + num2;
System.out.println(result);
}
}
9.賦值 / 複合賦值運算子
/*
* 賦值運算子 : =
*
* 注意 : 一個變數只有在為其重新賦值的時候才會發生改變.
*
* 複合賦值運算子 : += -= *= /= %=
*
*/
public class ArithmeticDemo3 { public static void main(String[] args) {
// 演示2 : 思考題
int number = 10;
number += 5;
System.out.println("number = " + number); // 15
number -= 5;
System.out.println("number = " + number); // 10
number *= 5;
System.out.println("number = " + number); // 50
number /= 5;
System.out.println("number = " + number); // 10
number %= 5;
System.out.println("number = " + number); // 0
// 演示1 :
/*
int number = 10;
// int result = number + 5; // number = 10 result = 15
// 如果在變數的 `自身` 基礎上進行修改, 此時, 我們可以使用 `複合賦值運算子`
// number = number + 5; // number = 15
number += 5;
System.out.println("number = " + number);
*/
}
}
10.自增和自減運算
/* * 自增和自減 : ++ – * * int number = 10; * * 前自增 後自增 * 變數本身 : ++number; 11 number++; 11 * 返回結果 : 11 10 * */
public class ArithmeticDemo5 { public static void main(String[] args) {
// 思考三 :
int i = 8;
int j = 7;
int k = 6;
int result = i++ + --j + k--;
// 結果/本身 8/9 6/6 6/5
/*
int i1 = i++;
int i2 = --j;
int i3 = k--;
int result = i1 + i2 + i3;
*/
System.out.println(result); // 20
/* 思考二 :
int i = 8;
int result = i++ + ++i;
// 結果/本身 8/9 10/10
int i1 = i++; 8 變數本身 9
int i2 = ++i; 10 變數本身 10
int result = i1 + i2;
System.out.println(result); // 18
*/
/* 思考一 :
int i = 8;
int j = 5;
// 運算時, 獲取的是結果的值.
int result = i++ + ++j;
// 結果/變數 8/9 6/6
int i1 = i++; 8
int j1 = ++j; 6
int result = i1 + j1; 14
System.out.println(result);
*/
// 演示1 :
/*
int number = 10;
// number++; // 後自增
// ++number; // 前自增
// int result = number++;
int result = ++number;
System.out.println("number = " + number + ", result = " + result);
*/
}
}
思考 : 浮點型和字元型也可以實現自增和自減嗎?
public class ArithmeticDemo6 { public static void main(String[] args) {
// 問題2 : 字元型可以自增和自減嗎?
// 可以.
char ch = 'a';
ch++;
System.out.println("ch = " + ch);
// 問題1 : 浮點型可以自增和自減嗎?
// 可以, 但是針對整型部分自增. 小數部分不變.
float f = 10.88f;
// f++;
++f;
// float result1 = f++; 10.88f;
// float result2 = ++f; 11.88f;
System.out.println("f = " + f);
}
}
11.編碼表 : ASCII 美國標準資訊交換程式碼
/* * 編碼表 : ASCII 美國標準資訊交換程式碼 * * 48 -> ‘0’ * 65 -> ‘A’ * 97 -> ‘a’ */
public class ArithmeticDemo7 { public static void main(String[] args) {
// char 和 int 可以互相賦值 : 字元在計算機底層是以 `數字` 來進行儲存的, 只不過取出時, 需要使用 `編碼表` 進行翻譯.
// 輸出顯示的內容取決與 `變數的型別`.
char ch1 = '0';
char ch2 = 'A';
char ch3 = 'a';
System.out.println("ch1 = " + ch1 + ", ch2 = " + ch2 + ", ch3 = " + ch3);
char ch4 = 48;
char ch5 = 65;
char ch6 = 97;
System.out.println("ch4 = " + ch4 + ", ch5 = " + ch5 + ", ch6 = " + ch6);
int i1 = '0';
int i2 = 'A';
int i3 = 'a';
System.out.println("i1 = " + i1 + ", i2 = " + i2 + ", i3 = " + i3);
// char 二個位元組 65535 short 二個位元組 32676
char ch = '中';
System.out.println(ch);
System.out.println((int) ch);
/*
// 字串
String str = "abc";
str++; 錯誤!
*/
}
}
12.逗號表示式
/* * 逗號表示式 : * * 格式 : * 資料型別 變數1 = 值1, 變數2 = 值2, 變數3 = 值3, … ; */
public class ArithmeticDemo8 { public static void main(String[] args) {
// 單獨定義變數
// char ch1 = ‘0’; // char ch2 = ‘A’; // char ch3 = ‘a’;
// 逗號表示式 : 定義相同型別的若干變數
char ch1 = '0', ch2 = 'A', ch3 = 'a';
System.out.println("ch1 = " + ch1 + ", ch2 = " + ch2 + ", ch3 = " + ch3);
// int ch4 = 48; // int ch5 = 65; // int ch6 = 97;
int ch4 = 48, ch5 = 65, ch6 = 97;
System.out.println("ch4 = " + ch4 + ", ch5 = " + ch5 + ", ch6 = " + ch6);
/* 不可以使用逗號表示式 :
int i = 10;
float f = 10.88f;
*/
}
}
13.比較運算子
/* * 比較運算子 : 等於 == , 不等於 != , 大於 > , 小於 <, 大於等於 >= , 小於等於 <= . * * 作用 : 比較兩個數值的關係. (等於, 不等, 大於, 小於 …) * 結果 : true / false boolean 布林型別 */
public class ArithmeticDemo9 { public static void main(String[] args) {
int num1 = 10;
int num2 = 10;
boolean result = num1 != num2;
System.out.println("result = " + result);
}
}
14.三元運算子
/*
* 三元運算子 : boolean型別的結果 ? 值1 : 值2;
*
* true 返回值1
* false 返回值2
*
* 三元運算子的結果接收型別取決於 值1,值2 的型別. (值1 和 值2 必須是同一個型別)
*
* 單元運算子 : ++ –
* 雙元運算子 : + - * / …
* 三元運算子 : ? :
*/
public class ArithmeticDemo10 { public static void main(String[] args) {
int num1 = 10;
int num2 = 10;
// boolean型別的結果 ? 值1 : 值2;
String result = num1 == num2 ? "真的" : "假的";
System.out.println(result);
boolean result2 = num1 == num2 ? true : false;
System.out.println(result2);
char result3 = num1 == num2 ? '是' : '否';
System.out.println(result3);
}
}
思考題 : 三個整型數值中求最大值.
public class ArithmeticDemo11 { public static void main(String[] args) {
int num1 = 130;
int num2 = 150;
int num3 = 120;
// 需求 : 使用三元運算子獲取最大值.
int secondMax = num1 > num2 ? num1 : num2;
int max = secondMax > num3 ? secondMax : num3;
System.out.println("max = " + max);
}
}
15.鍵盤錄入 Scanner 1.Scanner 的基本使用步驟 :
package cn.itcast.scanner;
import java.util.Scanner;
/* * Scanner 鍵盤錄入 / 掃描器 * * 1. 導包 import java.util.Scanner; 位置: 包下, 類上. * 2. 建立一個鍵盤錄入物件 Scanner sc = new Scanner(System.in); 位置: main方法中 * 3. 關閉資源 sc.close(); * * 4. 操作資料 (提示, 並接收使用者的輸入) 獲取使用者輸入的整型資料 : nextInt(); 位置: 建立和關閉資源的中間. * int number = sc.nextInt(); String str = sc.nextLine(); * * 5. 後期對使用者輸入的資料進行操作, 建議寫在關閉資源之後. * */
public class ScannerDemo1 { public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入一個整型資料 : ");
int number = sc.nextInt(); // sc.nextInt() 效果就是造成了程式的等待.
sc.close();
// 後期操作 (檢視)
System.out.println("number = " + number);
}
}
2.練習一 : 求和
思路講解 :
// 1.1 導包
public class ScannerDemo2 { public static void main(String[] args) {
// 需求 : 鍵盤錄入兩個資料並求和
// 1.2 建立一個鍵盤錄入物件
// 1.4 操作資料 (提示, 並接收使用者的輸入)
// 1.3 關閉資源
// 2. 後期處理 (兩個資料並求和)
// 2.1 將使用者輸入的兩個整型資料進行相加
// 2.2 輸出檢視結果
}
}
程式碼實現 :
// 1.1 導包 import java.util.Scanner;
public class ScannerDemo2 { public static void main(String[] args) {
// 需求 : 鍵盤錄入兩個資料並求和
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入第一個整型資料 :");
int num1 = sc.nextInt();
System.out.println("親, 請輸入第二個整型資料 :");
int num2 = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (兩個資料並求和)
// 2.1 將使用者輸入的兩個整型資料進行相加
int sum = num1 + num2;
// 2.2 輸出檢視結果
System.out.println("sum = " + sum);
}
}
3.練習二 : 求最大值
// 1.1 導包 import java.util.Scanner;
public class ScannerDemo3 { public static void main(String[] args) {
// 需求 : 鍵盤錄入三個資料獲取最大值
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的 3 次輸入)
System.out.println("親, 請輸入第一個整型資料 :");
int num1 = sc.nextInt();
System.out.println("親, 請輸入第二個整型資料 :");
int num2 = sc.nextInt();
System.out.println("親, 請輸入第三個整型資料 :");
int num3 = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (三個資料獲取最大值)
// 2.1 使用三元運算求較大值
// 格式 : boolean型別的結果 ? 值1 : 值2;
int secondMax = num1 > num2 ? num1 : num2;
// 2.2 使用三元運算求最大值
int max = secondMax > num3 ? secondMax : num3;
// 3. 輸出, 並檢視結果
System.out.println("max = " + max);
}
}
4.練習三 : 求5位數中的每一個數值
// 1.1 導包 import java.util.Scanner;
public class ScannerDemo4 { public static void main(String[] args) {
// 需求 : 鍵盤錄入一個整型萬位資料, 獲取 `個, 十, 百, 千, 萬` 位上的每一個數值. 並檢視
/*
* 87654
* 個位 : 4
* 十位 : 5
* 百位 : 6
* 千位 : 7
* 萬位 : 8
*/
// 1.2 建立鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入一個5位數的萬位資料 :");
int number = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (取每一個位數上的值)
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
int qian = number / 1000 % 10;
int wan = number / 10000;
System.out.println("ge : " + ge + ", shi : " + shi + ", bai : " + bai + ", qian : " + qian + ", wan : " + wan);
}
}
16.邏輯運算子 1.邏輯與和短路與 : 一假即假
public class LogicDemo1 { public static void main(String[] args) {
// 案例 : 判斷一個數是否是 大於0, 並且是 小於100
int number = -98;
// 比較運算子
// boolean result1 = number > 0;
// boolean result2 = number < 100;
// 邏輯運算子用於連線多個 `boolean 型別` 的結果, 邏輯運算子返回的結果還是 boolean 型別的結果.
// & 並且 (邏輯與) 口訣 : 一假即假
boolean result = number > 0 & number < 100;
System.out.println(result);
}
}
public class LogicDemo2 { public static void main(String[] args) {
// && 短路與 & 邏輯與 口訣 : 一假即假
int i = 10;
// 短路與 : 只要結果能確認, 之後的所有語句都不會被執行. (開發中常量)
// boolean result = i++ > 10 && ++i > 5; result = false i = 11
// 邏輯與 : 無論結果是否能確認, 都會執行完畢所有的語句. (不常用)
boolean result = i++ > 10 & ++i > 5;
// 結果/變數 10/11 false 12/12 < 5 true
/*
* 結論 : 如果 i 變數的結果為 11, 說明了該語句 ++i > 5 沒有被執行.
*/
System.out.println("result = " + result);
System.out.println("i = " + i);
}
}
課堂案例 :
public class LogicDemo4 { public static void main(String[] args) {
// 案例 1 : 判斷小明的 `語文, 數學, 英語` 成績是否都及格.
int chineseScore = 100;
int mathScore = 90;
int englishScore = 59 + 1; // 應該累死 / 應改歷史
// 判斷
boolean result = chineseScore >= 60 && mathScore >= 60 && englishScore >= 60;
System.out.println(result);
}
}
2.邏輯或和短路或 : 一真即真
public class LogicDemo3 { public static void main(String[] args) {
// | 邏輯或 || 短路或 (或者) 口訣 : 一真即真
int i = 10;
// | 邏輯或 無論是否能夠確定結果, 所有的語句都會被執行. (不常用)
// boolean result = ++i > 10 | i++ > 20;
// 結果/變數 11/11 true 11/12 false
// || 短路或 一旦能夠確認結果, 之後的語句就不會被執行. (開發中常用)
boolean result = ++i > 10 || i++ > 20;
// 結果/變數 11/11 true 11/12 false
System.out.println(result);
System.out.println(i);
}
}
課堂案例 :
public class LogicDemo5 { public static void main(String[] args) {
// 案例2 : 判斷一個人是否為 `男` 或者年齡大於等於 18 歲.
char gender = 'F'; // F / M Female 雌性 / Male 雄性 Woman / Man
int age = 18;
// 判斷
boolean result = gender == 'M' || age >= 18;
System.out.println(result);
}
}
3.邏輯非 : 真變假, 假變真
public class LogicDemo6 { public static void main(String[] args) {
// ! 邏輯非 口訣 : 真變假, 假變真. if 條件判斷
/*
int num1 = 10;
int num2 = 20;
boolean result = ! (num1 > num2);
*/
boolean result1 = !true; // ! (num1 > num2);
boolean result2 = !false;
System.out.println("result1 = " + result1 + ", result2 = " + result2);
}
}
17.分支結構 1.if的第一種格式 : /* * 條件語句的第一種格式 : 分支結構 * * if (boolean型別的條件) { * 如果條件成立, 就會被執行的語句; 執行體 / 執行語句 * } * */
// 1.1 導包 import java.util.Scanner;
public class ConditionDemo1 { public static void main(String[] args) {
// 課堂練習 : 定義變數接收出生年份, 判斷這個哥們是否成年, 如果成年了就顯示一些資訊給他看, 否則就算了.
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入您的出生年份 : ");
int year = sc.nextInt(); // 1996
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (判斷這個哥們是否成年) if 語句
// 1996
if ((2017 - year) >= 18) {
// 3. 如果條件成立, 就顯示一些資訊給他看.
System.out.println("恭喜你, 你有資格欣賞以下漂亮的內容了. 親, 一定要注意身體!");
}
// 最後 OVER ~
System.out.println("OVER ~");
}
}
2.if的第二種格式 :
/* * if 條件語句的第二種格式 : 特點 : 要麼執行 if 語句, 要麼執行 else. bug 蟲子 / 漏洞 * * if (boolean型別的結果) { * // true 執行語句 * } else { * // false 執行語句 * } */
public class ConditionDemo2 { public static void main(String[] args) {
// 需求 : 假設你有一個兒子, 寫一個程式判斷你兒子的英語成績是否及格. 如果及格, 獎勵, 否則, 打死.
System.out.println("親, 歡迎使用成績自動獎勵系統.");
// 1. 定義一個變數用於儲存成績
int englishScore = 59;
// 2. 判斷你兒子的英語成績是否及格
if (englishScore >= 60) {
// 2.1 如果及格, 獎勵
System.out.println("獎勵了你兒子一輛 BMW.");
} else {
// 2.2 否則, 打死.
System.out.println("你兒子已經被打死了.");
}
System.out.println("親, 感謝您的使用, 下次再來.");
}
}
3.if的第三種格式 :
/* * if 條件語句的第三種格式: 特點: 只會執行其中的一句, 執行完畢就立刻跳出該 if 結構語句. * * if (boolean型別的結果) { * 執行語句 1 * } else if (boolean型別的結果) { * 執行語句 2 * } else if (boolean型別的結果) { * 執行語句 3 * } else { * 如果之前的都不成立, 最後執行該語句 * } * */
// 1.1 導包 import java.util.Scanner;
public class ConditionDemo3 { public static void main(String[] args) {
// 需求 : 鍵盤錄入對一個學生的考試成績進行等級的劃分,
// 如果分數大於等於80分等級為優,
// 否則, 如果分數大於等於70等級為良,
// 否則, 如果分數大於等於60分等級為中,
// 否則, 等級為差.
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入您的考試成績 :");
int score = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (成績等級的劃分) // please have a seat. 請坐.
if (score >= 80) {
// 如果分數大於等於80分等級為優,
System.out.println(score + " : 優");
} else if (score >= 70) {
// 否則, 如果分數大於等於70等級為良,
System.out.println(score + " : 良");
} else if (score >= 60) {
// 否則, 如果分數大於等於60分等級為中,
System.out.println(score + " : 中");
} else if (score >= 0) {
// 否則, 等級為差.
System.out.println(score + " : 差");
} else {
// 提示
System.out.println("親, 請輸入的成績不合法! 沒有等級.");
}
System.out.println("OVER ~ ");
}
}
補充版本 :
/* * if 條件語句的第三種格式: 特點: 只會執行其中的一句, 執行完畢就立刻跳出該 if 結構語句. * * if (boolean型別的結果) { * 執行語句 1 * } else if (boolean型別的結果) { * 執行語句 2 * } else if (boolean型別的結果) { * 執行語句 3 * } else { * 如果之前的都不成立, 最後執行該語句 * } * */
// 1.1 導包 import java.util.Scanner;
public class ConditionDemo4 { public static void main(String[] args) {
// 需求 : 鍵盤錄入對一個學生的考試成績進行等級的劃分,
// 如果分數大於等於80分等級為優,
// 否則, 如果分數大於等於70等級為良,
// 否則, 如果分數大於等於60分等級為中,
// 否則, 等級為差.
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入您的考試成績 :");
int score = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 需求 : 成績必須在 0 ~ 100 之間
// 判斷
if (score >= 0 && score <= 100) {
// 條件成立, 說明成績在 0 ~ 100 之間
// 2. 後期處理 (成績等級的劃分) // please have a seat. 請坐.
if (score >= 80) {
// 如果分數大於等於80分等級為優,
System.out.println(score + " : 優");
} else if (score >= 70) {
// 否則, 如果分數大於等於70等級為良,
System.out.println(score + " : 良");
} else if (score >= 60) {
// 否則, 如果分數大於等於60分等級為中,
System.out.println(score + " : 中");
} else if (score >= 0) {
// 否則, 等級為差.
System.out.println(score + " : 差");
}
} else {
// 成績不在 0 ~ 100 之間
System.out.println("成績不合法");
}
System.out.println("OVER ~ ");
}
}
4.案例 (根據月份輸出對應的季節)
// 1.1 導包 import java.util.Scanner;
public class ConditionDemo5 { public static void main(String[] args) { /* 需求 : 根據使用者給定的月份資料,顯示月份在哪個季節.
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
*/
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入需要查詢的月份 :");
int month = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (根據月份顯示對應的季節)
// 2.1 使用 if ... else if ... else if ... else
// month
if (month >= 3 && month <= 5) {
// 3,4,5 春季
System.out.println(month + " : 對應的季節為春季.");
} else if (month >= 6 && month <= 8) {
// 6,7,8 夏季
System.out.println(month + " : 對應的季節為夏季.");
} else if (month >= 9 && month <= 11) {
// 9,10,11 秋季
System.out.println(month + " : 對應的季節為秋季.");
} else if (month == 12 || month == 1 || month == 2) {
// 12,1,2 冬季
System.out.println(month + " : 對應的季節為冬季.");
} else {
// 如果都不成立, 執行預設語法
System.out.println(month + " : 沒有對應的季節.");
}
System.out.println("OVER ~");
}
}
5.switch語句
import java.util.Scanner;
/* * switch 多條件判斷語句 : * * switch (變數) { 開關 * case 值1 : 當…情況 * 執行語句 1; * break; 跳出 * case 值2 : * 執行語句 2; * break; * case 值3 : * 執行語句 3; * break; * case 值4 : * 執行語句 4; * break; * default : * 預設執行語句; * break; * } */
public class ConditionDemo6 { public static void main(String[] args) { /* 需求 : 根據使用者給定的月份資料,顯示月份在哪個季節.
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
*/
// 1.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 1.4 操作資料 (提示, 並接收使用者的輸入)
System.out.println("親, 請輸入需要查詢的月份 :");
int month = sc.nextInt();
// 1.3 關閉資源
sc.close();
// 2. 後期處理 (根據月份顯示對應的季節)
switch (month) {
case 3:
case 4:
case 5:
System.out.println(month + " : 對應的季節為春季.");
break;
case 6:
case 7:
case 8:
System.out.println(month + " : 對應的季節為夏季.");
break;
case 9:
case 10:
case 11:
System.out.println(month + " : 對應的季節為秋季.");
break;
case 12:
case 1:
case 2:
System.out.println(month + " : 對應的季節為冬季.");
break;
default :
// 預設執行語句...
System.out.println(month + " : 沒有對應的季節.");
break;
}
/*switch (month) {
case 3:
System.out.println(month + " : 對應的季節為春季.");
break;
case 4:
System.out.println(month + " : 對應的季節為春季.");
break;
case 5:
System.out.println(month + " : 對應的季節為春季.");
break;
case 6:
System.out.println(month + " : 對應的季節為夏季.");
break;
case 7:
System.out.println(month + " : 對應的季節為夏季.");
break;
case 8:
System.out.println(month + " : 對應的季節為夏季.");
break;
case 9:
System.out.println(month + " : 對應的季節為秋季.");
break;
case 10:
System.out.println(month + " : 對應的季節為秋季.");
break;
case 11:
System.out.println(month + " : 對應的季節為秋季.");
break;
case 12:
System.out.println(month + " : 對應的季節為冬季.");
break;
case 1:
System.out.println(month + " : 對應的季節為冬季.");
break;
case 2:
System.out.println(month + " : 對應的季節為冬季.");
break;
default :
// 預設執行語句...
System.out.println(month + " : 沒有對應的季節.");
break;
}*/
System.out.println("OVER ~");
}
}
18.迴圈結構 1.for 迴圈結構
/* * for 迴圈結構 : * * for (; ; ) { * * } * * for (初始化變數; 迴圈條件; 增量) { * 執行語句 / 迴圈體; * } */
public class LoopDemo1 { public static void main(String[] args) {
/*
* 問題 :
* 1. 程式碼重複.
* 2. 程式碼維護性差.
*/
// 需求 : 在控制檯輸出 1000 次 `我愛廣州小蠻腰.`. 1 + 2 + 3 + 4... + 100 -> 5050
// 北京 `大褲衩`
for (int i = 0; i < 10; i++) {
// 執行語句 / 迴圈體;
System.out.println("我愛廣州小蠻腰.");
}
/*
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
System.out.println("我愛北京天安門.");
*/
}
}
2.for迴圈求和
public class LoopDemo2 { public static void main(String[] args) {
// 練習: 使用for迴圈, 求 1~100 之間所有整數的累加和.
// 方式一 :
// 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 ... + 100;
// 概念 : 依次訪問固定範圍內所有的整型數值, 這種操作行為被稱為 `遍歷`.
// 0. 定義一個 `框` 變數, 用於累加數值
int sum = 0;
// 1. 遍歷 1~100 之間的所有數值
for (int i = 1; i <= 100; i++) {
// System.out.println(i);
// 2. 求和
sum += i; // sum = sum + i;
}
// 3. 檢視框變數中的數值
System.out.println("sum = " + sum);
}
}
3.for迴圈求水仙花數
public class LoopDemo3 { public static void main(String[] args) {
// 水仙花 : 指一個百位整型數值, 其個位數值, 十位數值, 百位數值的立方和等於該數值本身, 那麼這個百位整型數值就是一個水仙花數.
// 100 ~ 999
// 153 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 == 153
// 1. 遍歷 100 ~ 999 之間的所有整型數值
for (int i = 100; i <= 999; i++) {
// 2. 獲取當前遍歷的數值, 取出 `個, 十, 百` 上的每個數 / %
// 153 -> i
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100;
// 3. 判斷 if 語句
if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
// 4. 如果條件成立, 說明當前遍歷的數值就是水仙花數
System.out.println(i);
}
}
}
}
4.while 迴圈結構
1.練習一 : 列印 10 次 我愛上海傳智播客
/*
* 使用 while 迴圈輸出 10 次 我愛上海傳智播客
*
* for (; 迴圈條件; ) {
* 執行語句 / 迴圈體;
* }
*
* 格式 :
* while (迴圈條件) {
* 執行執行 / 迴圈體;
* }
*/
public class WhileLoopDemo1 { public static void main(String[] args) { /* for (int i = 0; i < 10; i++) {
}
*/
/*
* for 和 while 迴圈的優勢 :
*
* for 迴圈其實就是為 while 迴圈的最關鍵三處程式碼設定了其 `特殊的位置`.
*
* 使用建議 : 如果是一個 `確定次數` 的迴圈, 請選擇使用 for 迴圈.
*/
// Syntax error 語法錯誤!
// 條件 : 必須是 boolean 型別的條件 false / true;
// 1. 定義初始化變數
int i = 0;
// 2. 迴圈條件
while (i < 10) {
// 4. 執行語句
System.out.println("我愛上海傳智播客.");
// 3. 增量
i++;
}
}
}
2.練習二 : 累加 1 ~ 100 之間的整型和
public class WhileLoopDemo2 { public static void main(String[] args) {
// 需求 : 使用 while 迴圈實現 1~100 之間的累加和
/*
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println("sum = " + sum);
*/
// 1. 定義一個框變數
int sum = 0;
// 2.1 初始化變數
int i = 1;
// 2.2 迴圈條件
while (i <= 100) {
// 2.4 執行語句
sum += i;
// 2.3 增量
i++;
}
// 輸出語句
System.out.println("sum = " + sum);
}
}
3.練習三 : 窮舉
/* * 什麼是窮舉 ? 一個一個的試, 效率最低, 也是最笨的方式. * 案例 : 有一個人買了一筐雞蛋 (至少有2個) 兩個兩個的數, 多一個, 三個三個的數, 多一個, 四個四個的數, 多一個. 請問 : 至少有幾個雞蛋 ? * 思路 : 從2開始, 一個一個的試, 直到試出來為止. */
public class WhileLoopDemo3 { public static void main(String[] args) {
// 1. 定義一個變數, 記錄雞蛋的個數
int egg = 2;
// 遍歷 (死迴圈)
// while 迴圈使用的場景 : 未知 / 不確定迴圈次數的情況下, 請使用 while 迴圈.
while (true) {
// 判斷, 雞蛋至少有幾個 ???
// 兩個兩個的數, 多一個, 三個三個的數, 多一個, 四個四個的數
if (egg % 2 == 1 && egg % 3 == 1 && egg % 4 == 1) {
// 如果條件滿足, 說明當前雞蛋的個數就是最少擁有的個數
System.out.println("egg = " + egg);
// 跳出整個 while 迴圈
break;
}
// 注意 : 雞蛋判斷的個數需要自增
egg++;
}
System.out.println("OVER ~");
/*
int num1 = 10;
int num2 = 20;
if (num1 > num2) {
// break cannot be used outside of a loop or a switch
// break 只能在迴圈和 switch 語句中使用.
break;
}
*/
}
}
- do-while 迴圈
/* * 總結 : do-while 迴圈很少使用. * * do { * 執行語句 / 迴圈體; * } while (條件); * * 注意 : while 和 do-while 有什麼區別 ??? * * 1. 如果迴圈條件成立, 兩者無區別. * 2. 如果迴圈條件不成立, while 迴圈一次都不會執行, 而 do-while 至少會執行一次, 還有可能會造成死迴圈. */
public class DoWhileLoopDemo4 { public static void main(String[] args) {
int i = 10;
while (i > 10) {
System.out.println("我來了...");
i++;
}
System.out.println("-----------------");
// 1. 初始化變數
int j = 10;
do {
// 4. 執行語句
System.out.println("我走了...");
// 3. 增量
j++;
// 2. 迴圈條件
} while (j > 10);
}
}
- 迴圈控制語句
- break
/* * break 跳出當前迴圈 / 跳出 switch 結構 */
public class BreakDemo5 { public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("I love you.");
// 需求 : i == 5, 結束了.
if (i == 4) {
break;
}
}
System.out.println("I hate you.");
System.out.println("I miss you.");
}
}
2.continue
/*
* continue : 結束 本次 迴圈, 繼續下次迴圈.
*/
public class ContinueDemo6 { public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
// 需求 : I love you. 5 該跳語句不要輸出.
if (i == 5) {
continue;
}
System.out.println("I love you. " + i);
}
System.out.println("I hate you.");
System.out.println("I miss you.");
}
}
- for / while + continue 的使用注意點
public class ReviewDemo1 { public static void main(String[] args) {
// 已知迴圈次數使用 while 迴圈, 在內部使用了 continue 關鍵字.
// for + continue 無問題 !
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue;
}
System.out.println(i);
}
// while + continue 有問題 !
int i = 0;
while (i < 10) {
if (i == 5) {
System.out.println(i);
continue;
}
System.out.println(i);
i++;
}
}
}
19.Random 隨機數 1.Random 類的使用步驟 :
// 步驟一 : 導包 import java.util.Random;
/* * Random 隨機數 * * 步驟一 : 導包 import java.util.Random; 位置: 包下, 類上 * 步驟二 : 建立隨機數物件 Random r = new Random(); 位置: 類的主方法中 * 步驟三 : 直接使用 int number = r.nextInt(n); 說明 : 0~n-1 的範圍 */
public class RandomDemo1 { public static void main(String[] args) {
// 步驟二 : 建立隨機數物件
Random r = new Random();
for (int i = 0; i < 10; i++) {
// 步驟三 : 直接使用
int number = r.nextInt(11);
System.out.println(number);
}
}
}
2.練習 : 獲取10個 [10~20] 之間的隨機數
// 1.1 導包 import java.util.Random;
public class RandomDemo2 { public static void main(String[] args) {
// 需求 : 隨機生成十個 [10~20] 範圍的隨機數. 格式: 大值 - 小值 + 1
// 2~500 n => 500-2+1 => 499
// 1.2 建立隨機數物件
Random r = new Random();
// 2. 使用 for 迴圈執行 10 次
for (int i = 0; i < 10; i++) {
// 1.3 直接使用
int number = r.nextInt(11) + 10; // 0+10 10+10
System.out.println(number);
}
}
}
3.小遊戲 – 猜數字 需求 : 系統產生一個1-100之間的隨機數，請猜出這個資料是多少。
// 1.1 導包 (隨機數, 鍵盤錄入) import java.util.Random; import java.util.Scanner;
public class RandomDemo3 { public static void main(String[] args) {
// 案例 : 猜數字
// 隨機生成一個 1~100 之間的隨機數, 讓使用者不斷猜, 需要給使用者對應的提醒. (大了, 小了, 猜中了)
// 1.2 建立隨機數物件
Random r = new Random();
// 1.3 直接操作 number 隨機生成的數值
int number = r.nextInt(100) + 1;
System.out.println(number);
// 2.2 建立一個鍵盤錄入物件
Scanner sc = new Scanner(System.in);
// 4. 新增一個迴圈
while (true) {
// 2.4 操作資料 (提示, 並接收使用者的輸入) guessNumber 猜測的數值
System.out.println("親, 請輸入你猜測的數值 :");
int guessNumber = sc.nextInt();
// 3. 判斷 if ... else if ... else
if (guessNumber > number) {
// 大了
System.out.println("猜大了.");
} else if (guessNumber < number) {
// 小了
System.out.println("猜小了.");
} else {
// 猜中了 (不需要再次接收使用者的輸入了)
System.out.println("恭喜您, 您猜對了. ^v^");
// 猜中後, 需要跳出迴圈
break;
}
}
// 2.3 關閉資源
sc.close();
}
}
20.陣列 1.陣列的引入 思考問題 :
我們班有一個學習小組, 共5個人,儲存每一個同學的成績, 再將所有學生成績的總和輸出. 我們很容易想到的第一種方法 : 使用5個變數來儲存每一位同學的成績.
public class ArrayDemo1 { public static void main(String[] args) {
// 需求 : 儲存一個學習小組 50 位成員的成績, 並統計該小組的總成績.
// 1. 定義 5 個變數, 儲存 5 位成員的成績
int stu1 = 100;
int stu2 = 88;
int stu3 = 98;
int stu4 = 78;
int stu5 = 85;
// 2. 累加 5 為成員的成績
int sum = stu1 + stu2 + stu3 + stu4 + stu5;
System.out.println("sum = " + sum);
}
}
2.陣列的兩種定義格式與陣列的遍歷 格式一 : public class ArrayDemo2 { public static void main(String[] args) {
// 需求 : 使用陣列儲存小組的成績.
// 格式一 :
// 元素型別[] 陣列名 = new 元素型別[長度];
int[] arr = new int[5];
// 儲存
arr[0] = 100;
arr[1] = 98;
arr[2] = 88;
arr[3] = 78;
arr[4] = 85;
// 取出
System.out.println("arr[0] = " + arr[0]);
System.out.println("arr[1] = " + arr[1]);
System.out.println("arr[2] = " + arr[2]);
System.out.println("arr[3] = " + arr[3]);
System.out.println("arr[4] = " + arr[4]);
}
}
格式二 : public class ArrayDemo3 { public static void main(String[] args) {
// 需求 : 使用格式二儲存, 並取出資料
// 格式二 :
// 元素型別[] 陣列名 = new 元素型別[]{元素1, 元素2, 元素3, 元素4, 元素5};
int[] arr = new int[]{100, 98, 88, 78, 85}; // int num = 100;
// 依次訪問陣列中的每一個元素陣列 : 遍歷陣列
// 系統提供了一個屬性可以直接獲取陣列的長度 : 陣列名.length;
int len = arr.length;
System.out.println("len = " + len);
// 定義一個框變數
int sum = 0;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
// 累加
sum += arr[i];
}
// 迴圈結束後, 檢視框變數中的數值
System.out.println("sum = " + sum);
/*
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
*/
}
}
3.陣列的回顧與兩個常見的異常
/* * 回顧 : * 格式一 : 元素型別[] 陣列名 = new 元素型別[長度]; 陣列如果不進行初始化, 那麼其元素也有預設初始值. * 說明: 變數如果不初始化, 就不可以直接使用. * * 格式二 : 元素型別[] 陣列名 = new 元素型別[]{元素1, 元素2, 元素3, 元素4, 元素5…}; * 注意點 : 如果一個數組提供了初始值, 那麼該陣列就不可以再定義長度. 因為程式可以直接根據初始值中的元素個數自動確定陣列的長度. */
public class ArrayDemo1 { public static void main(String[] args) {
// 1. 定義一個數組
// int[] arr = new int[5];
// Cannot define dimension expressions 維度表示式 / 陣列的長度
// when an array initializer is provided 當一個數組已經提供了初始值
int[] arr = new int[]{10, 20, 30, 40, 50};
// 簡寫格式 : JVM編譯時, 就根據左邊的型別自動給右方的初始值新增資料型別. new int[]{10, 20, 30, 40, 50};
// int[] arr = {10, 20, 30, 40, 50};
// 遍歷陣列
// arr.length 中的 length 是系統給我們提供了. 所以我們在程式中可以直接使用, 表示獲取該陣列的長度.
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
/*
int num;
// The local variable 這個區域性變數 num may not 可能沒有 have been initialized 被完成初始化.
// 變數沒有初始化之前是不可以使用的.
System.out.println(num);
*/
}
}
兩個常見的陣列異常 :
/* * 問題1 : ArrayIndexOutOfBoundsException 陣列下標越界異常. * * 問題2 : NullPointerException 空指標 / 空引用異常. 陣列 / 物件 已經被清空了, 不能使用了. * 說明 : Java 規定, 空物件 (null) 不可以在程式中再次被使用. (訪問, 賦值 …) */
public class ArrayDemo2 { public static void main(String[] args) {
// 1. 定義一個數組
int[] arr = {10, 20, 30, 40, 50};
// 2. 遍歷陣列
for (int i = 0; i < arr.length; i++) {
System.out.println("arr["+i+"] = " + arr[i]);
}
// 異常一 : ArrayIndexOutOfBoundsException 陣列下標越界異常
System.out.println(arr[5]);
System.out.println(arr[0]);
// 將陣列清空, 之後就表示 `整個陣列` 就不可以在使用了.
arr = null;
// 異常二 : NullPointerException 空引用異常
System.out.println(arr[1]);
System.out.println("OVER~");
}
}
4.陣列記憶體圖解
5.陣列的操作 – 最值
public class ArrayDemo4 { public static void main(String[] args) {
// 1. 定義一個數組
int[] arr = new int[]{89, 76, 34, 56, 99, 12, 67, 100, 88};
// 需求1 : 獲取該陣列中的最大值 ???
// 1.0 定義一個 `擂臺` 變數, 初始化陣列的第 0 個元素.
int max = arr[0]; // 89
// 1.1 遍歷陣列, 遍歷直接從第 1 個下標開始 (依次訪問陣列中的每一個元素)
for (int i = 1; i < arr.length; i++) {
// System.out.println(arr[i]);
// 1.2 比較
if (max < arr[i]) { // 99 < 67
// 條件成立, 說明 max 不是最大的. 需要重新賦值
max = arr[i]; // max = 99;
}
}
// 1.3 檢視 `擂臺` 變數
System.out.println("max = " + max);
// 需求2 : 獲取該陣列中的最小值 ???
// 2.1 定義一個 `擂臺` 變數
int min = arr[0];
// 2.2 遍歷陣列
for (int i = 1; i < arr.length; i++) {
// 2.3 判斷
if (min > arr[i]) {
min = arr[i];
}
}
// 2.4 檢視擂臺變數
System.out.println("min = " + min);
}
}
21.for 迴圈巢狀 1.思考題 : count
/*
* for 迴圈巢狀 : 外層每執行一次, 內層就會執行 所有次.
*
* for (; ; ) {
* for (; ; ) {
* }
* }
*/
public class ForForDemo1 { public static void main(String[] args) {
// 定義一個 `計數器` 變數
int count = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
// 在內層迴圈中, 累加計數器數值
count++;
}
}
System.out.println("count = " + count);
}
}
2.地球和太陽的故事
/*
* 太陽和地球的故事 :
*
* 公轉 : 地球公轉了一圈. 外層迴圈.
* 自轉 : 地球完成了 365 次自轉. 內層迴圈.
*
* for 迴圈巢狀 : 外層每迴圈一次, 內層就會完成 所有次.
*
*/
public class ForForDemo2 { public static void main(String[] args) {
// 公轉
for (int i = 0; i < 2; i++) {
// 自轉
for (int j = 0; j < 365; j++) {
System.out.println("地球完成了第"+(j+1)+"次自轉.");
}
System.out.println("地球完成了第"+(i+1)+"次公轉.");
}
}
}
3.案例 – 拼接兩個陣列中的資料 需求 : 陣列如下 : int[] arr1 = {18, 19, 20, 21}; String[] arr2 = {“貂蟬”, “王昭君”, “西施”, “楊玉環”, “劉德華”, “張學友”, “郭富城”, “黎明”};
要求 : 輸出結果.
程式碼實現 :
public class ForForDemo3 { public static void main(String[] args) {
// 1. 定義兩個陣列
int[] arr1 = {18, 19, 20, 21};
String[] arr2 = {"貂蟬", "王昭君", "西施", "楊玉環", "劉德華", "張學友", "郭富城", "黎明"};
// 2. 實現
for (int i = 0; i < arr2.length; i++) { // 外層 arr2 陣列
// 4 < 4
for (int j = 0; j < arr1.length; j++) { // 內層 arr1 陣列
// 輸出 : 貂蟬18, 貂蟬19, 貂蟬20, 貂蟬21 字串相加就是相拼接.
String str = arr2[i] + arr1[j];
// 如何換行 : 在內層迴圈的最後一次換行 arr1.length (4) - 1
if (j == arr1.length-1) {
System.out.println(str);
} else {
System.out.print(str + ", ");
}
}
}
/*
* 輸出結果如下 :
*
* for 迴圈巢狀 : 外層每迴圈一次, 內層就會迴圈 `所有次`.
*
* 貂蟬18, 貂蟬19, 貂蟬20, 貂蟬21 行: `貂蟬` 是相同的.(外層迴圈) 18, 19, 20, 21 是變化的.(內層迴圈)
* 王昭君18, 王昭君19, 王昭君20, 王昭君21
* ......
*/
}
}
22.二維陣列 (瞭解) 1.定義二維陣列 練習 : 請將下列表格使用二維陣列完成定義 : 組員1 組員2 組員3 組員4 第一小組 11 12 第二小組 21 22 23 第三小組 31 32 33 34
/*
* 二維陣列 : 陣列中的陣列. 二維陣列就是用來儲存 一維陣列 的. 二維陣列元素不是儲存資料, 而是一維陣列.
*
* 格式一 : 元素型別[][] 陣列名 = new int[二維陣列長度][一維陣列長度];
* 格式二 : 元素型別[][] 陣列名 = new int[二維陣列長度][];
* 格式三 : 元素型別[][] 陣列名 = new int[][]{一維陣列1, 一維陣列2, 一維陣列3 …};
* 格式四 : 元素型別[][] 陣列名 = {一維陣列1, 一維陣列2, 一維陣列3 …};
*/
public class ArrayDemo1 { public static void main(String[] args) {
/*
組員1 組員2 組員3 組員4
第一小組 11 12
第二小組 21 22 23
第三小組 31 32 33 34
*/
// 分別定義三個 `一維陣列`, 儲存三組陣列
// int[] arr1 = {11, 12};
// int[] arr2 = {21, 22, 23};
// int[] arr3 = {31, 32, 33, 34};
// 定義一個二維陣列
// 元素型別[][] 陣列名 = new int[][]{一維陣列1, 一維陣列2, 一維陣列3 ...};
// int[][] arr = new int[][]{arr1, arr2, arr3};
// 二維陣列中儲存的是一維陣列, 不是數值.
// int[][] arr = new int[3][]; 預設初始化 null
int[][] arr = new int[][]{{11, 12}, {21, 22, 23}, {31, 32, 33, 34}};
// 一個一個取
/*
* for 迴圈巢狀 : 外層每迴圈一次, 內層就會迴圈 `所有次`.
* 說明 :
* 如果外層是第 0 次迴圈, 內層就迴圈 `兩次`. j < arr[0].length
* 如果外層是第 1 次迴圈, 內層就迴圈 `三次`. j < arr[1].length
* 如果外層是第 2 次迴圈, 內層就迴圈 `四次`. j < arr[2].length
*
* 外層迴圈的條件是 int i = 0; i < arr.length; i++ i < arr.length
* 內層迴圈的條件是根據一維陣列的長度決定的.
*
*/
// 二維陣列的遍歷 :
for (int i = 0; i < arr.length; i++) { // 二維陣列的長度
for (int j = 0; j < arr[i].length; j++) { // 二維陣列中對應一維陣列的長度
System.out.println(arr[i][j]);
}
}
/*
System.out.println(arr.length); // 3
System.out.println(arr[0].length); // 2
System.out.println(arr[1].length); // 3
System.out.println(arr[2].length); // 4
*/
/*
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[1][2]);
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);
System.out.println(arr[2][3]);
*/
// System.out.println(arr[2][4]);
/*
System.out.println(arr[0]);
System.out.println(arr);
System.out.println(arr[2][0]); // 31
System.out.println(arr[1][2]); // 23
*/
}
}
2.二維陣列練習 : 課堂練習 : 通過案例熟悉二維陣列的使用, 例如要統計一個公司三個銷售小組中每個小組的總銷售額以及整個公司的銷售額.
public class ArrayDemo2 { public static void main(String[] args) {
/*
組員1 組員2 組員3 組員4
第一小組 11 12
第二小組 21 22 23
第三小組 31 32 33 34
*/
// 需求 : 統計每一個小組的銷售額, 及總公司的銷售額.
// 二維陣列中儲存的是一維陣列, 不是數值.
int[][] arr = new int[][]{{11, 12}, {21, 22, 23}, {31, 32, 33, 34}};
// 定義兩個 `框` 變數, 一個用於統計小組, 另一個統計總公司.
int companySum = 0;
int groupSum = 0;
// 二維陣列的遍歷 :
for (int i = 0; i < arr.length; i++) {
// 清空 groupSum 中累加的數值
groupSum = 0;
for (int j = 0; j < arr[i].length; j++) {
// System.out.println(arr[i][j]);
// 累加每一個小組的銷售額
groupSum += arr[i][j];
}
// 輸出小組
System.out.println("第"+(i+1)+"個小組的銷售額為: " + groupSum);
// 累加總公司的銷售額
companySum += groupSum;
}
// 輸出
System.o