前言

本文是前三篇文章的整合。

1. Java概述

語言：人與人交流溝通的表達方式

計算機語言：人與計算機之間進行信息交流溝通的一種特殊語言

Java語言是美國Sun公司（Stanford University Network）在1995年推出的計算機語言

Java之父：詹姆斯·高斯林（James Gosling）

2009年，Sun公司被甲骨文公司收購，所以我們現在訪問oracle官網即可：https://www.oracle.com

java語言的三個版本：

JavaSE: Java 語言的（標準版），用于桌面應用的開發，是其他兩個版本的基礎

JavaME: Java 語言的（小型版），用于嵌入式消費類電子設備

JavaEE: Java 語言的（企業版），用于 Web 方向的網站開發

Java程序并非是直接運行的，Java編譯器將Java源程序編譯成與平臺無關的字節碼文件(class文件)，然后由Java虛擬機（JVM）對字節碼文件解釋執行。所以在不同的操作系統下，只需安裝不同的Java虛擬機即可實現java程序的跨平臺。

JVM（Java Virtual Machine），Java虛擬機

JRE（Java Runtime Environment），Java運行環境，包含了JVM和Java的核心類庫（Java API）

JDK（Java Development Kit）稱為Java開發工具，包含了JRE和開發工具

總結：我們只需安裝JDK即可，它包含了java的運行環境和虛擬機。

1.4.1 下載

通過官方網站獲取JDK

http://www.oracle.com

注意：針對不同的操作系統，需要下載對應版本的JDK。

1.4.2 安裝

傻瓜式安裝，下一步即可。但默認的安裝路徑是在C:\Program Files下，為方便統一管理建議修改安裝路徑，將與開發相關的軟件都安裝到一個目錄下，例如：E:\develop。

注意：安裝路徑不要包含中文或者空格等特殊字符（使用純英文目錄）。

1.4.3 JDK的安裝目錄介紹

2. 第一個演示程序

在接觸集成開發環境之前，我們需要使用命令行窗口對java程序進行編譯和運行，所以需要知道一些常用DOS命令。

1、打開命令行窗口的方式：win + r打開運行窗口，輸入cmd，回車。

2、常用命令及其作用

2.2.1 為什么配置環境變量

開發Java程序，需要使用JDK提供的開發工具（比如javac.exe、java.exe等命令），而這些工具在JDK的安裝目錄的bin目錄下，如果不配置環境變量，那么這些命令只可以在該目錄下執行。我們不可能把所有的java文件都放到JDK的bin目錄下，所以配置環境變量的作用就是可以使bin目錄下的java相關命令可以在任意目錄下使用。

HelloWorld案例是指在計算機屏幕上輸出“HelloWorld”這行文字。

各種計算機語言都習慣使用該案例作為第一個演示案例。

2.3.1 Java程序開發運行流程

開發Java程序，需要三個步驟：編寫程序，編譯程序，運行程序。

2.3.2 HelloWorld案例的編寫

1、新建文本文檔文件，修改名稱為HelloWorld.java。

2、用記事本打開HelloWorld.java文件，輸寫程序內容。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

2.3.3 HelloWorld案例的編譯和運行

存文件，打開命令行窗口，將目錄切換至java文件所在目錄，編譯java文件生成class文件，運行class文件。

編譯：javac 文件名.java

范例：javac HelloWorld.java

執行：java 類名

范例：java HelloWorld

2.5.1 BUG

在電腦系統或程序中，隱藏著的一些未被發現的缺陷或問題統稱為bug（漏洞）。

2.5.2 BUG的解決

1、具備識別BUG的能力：多看

2、具備分析BUG的能力：多思考，多查資料

3、具備解決BUG的能力：多嘗試，多總結

2.5.3 HelloWorld案例常見問題

1、非法字符問題。Java中的符號都是英文格式的。

2、大小寫問題。Java語言對大小寫敏感（區分大小寫）。

3、在系統中顯示文件的擴展名，避免出現HelloWorld.java.txt文件。

4、編譯命令后的java文件名需要帶文件后綴.java

5、運行命令后的class文件名（類名）不帶文件后綴

2.6.1 什么要使用Notepad++軟件

Notepad++功能比windows中的自帶記事本功能強大，除了可以用來制作一般的純文字說明文件，也十分適合編寫計算機程序代碼。Notepad++有行號，能夠快速定位問題位置，還有語法高亮度顯示、代碼折疊等功能。而且它是免費的。

2.6.2 Notepad++軟件安裝

安裝：傻瓜式安裝，一直下一步即可。建議也安裝到統一的開發軟件目錄下，比如E:\develop。

2.6.3Notepad++軟件配置

安裝完畢之后，為了使用方便，做一個簡單的配置：修改默認語言和編碼。

3. java基礎語法

注釋是對代碼的解釋和說明文字，可以提高程序的可讀性，因此在程序中添加必要的注釋文字十分重要。Java中的注釋分為三種：

單行注釋。單行注釋的格式是使用//，從//開始至本行結尾的文字將作為注釋文字。

// 這是單行注釋文字

多行注釋。多行注釋的格式是使用/* 和 */將一段較長的注釋括起來。

/*
這是多行注釋文字
這是多行注釋文字
這是多行注釋文字
*/
注意：多行注釋不能嵌套使用。

文檔注釋。文檔注釋以/**開始，以*/結束。

關鍵字是指被java語言賦予了特殊含義的單詞。

關鍵字的特點：

關鍵字的字母全部小寫。

常用的代碼編輯器對關鍵字都有高亮顯示，比如現在我們能看到的public、class、static等。

常量：在程序運行過程中，其值不可以發生改變的量。

Java中的常量分類：

字符串常量 用雙引號括起來的多個字符（可以包含0個、一個或多個），例如"a"、"abc"、"中國"等

整數常量 整數，例如：-10、0、88等

小數常量 小數，例如：-5.5、1.0、88.88等

字符常量 用單引號括起來的一個字符，例如：'a'、'5'、'B'、'中'等

布爾常量 布爾值，表示真假，只有兩個值true和false

空常量 一個特殊的值，空值，值為null

除空常量外，其他常量均可使用輸出語句直接輸出。

public class Demo {
    public static void main(String[] args) {
        System.out.println(10); // 輸出一個整數
        System.out.println(5.5); // 輸出一個小數
        System.out.println('a'); // 輸出一個字符
        System.out.println(true); // 輸出boolean值true
        System.out.println("歡迎來到中科文峰"); // 輸出字符串
    }
}

變量的定義格式：

數據類型 變量名 = 數據值；

數據類型：為空間中存儲的數據加入類型限制。整數？小數？

變量名：自己要為空間起的名字，沒有難度

數據值： 空間中要存儲的數值，沒有難度

3.5.1 計算機存儲單元

我們知道計算機是可以用來存儲數據的，但是無論是內存還是硬盤，計算機存儲設備的最小信息單元叫“位（bit）”，我們又稱之為“比特位”，通常用小寫的字母”b”表示。而計算機中最基本的存儲單元叫“字節（byte）”，

通常用大寫字母”B”表示，字節是由連續的8個位組成。

除了字節外還有一些常用的存儲單位，其換算單位如下：

1B（字節） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

3.5.2 Java中的數據類型

Java是一個強類型語言，Java中的數據必須明確數據類型。在Java中的數據類型包括基本數據類型和引用數據類型兩種。

Java中的基本數據類型：

說明：

e+38表示是乘以10的38次方，同樣，e-45表示乘以10的負45次方。

在java中整數默認是int類型，浮點數默認是double類型。

3.6.1 變量的定義

變量：在程序運行過程中，其值可以發生改變的量。

從本質上講，變量是內存中的一小塊區域，其值可以在一定范圍內變化。

變量的定義格式：

數據類型 變量名 = 初始化值; // 聲明變量并賦值
int age = 18;
System.out.println(age);

或者(擴展)

// 先聲明，后賦值（使用前賦值即可）
數據類型 變量名;
變量名 = 初始化值;
double money;
money = 55.5;
System.out.println(money);

還可以(擴展)

在同一行定義多個同一種數據類型的變量，中間使用逗號隔開。但不建議使用這種方式，降低程序的可讀性。

int a = 10, b = 20; // 定義int類型的變量a和b，中間使用逗號隔開
System.out.println(a);
System.out.println(b);
​
int c,d; // 聲明int類型的變量c和d，中間使用逗號隔開
c = 30;
d = 40;
System.out.println(c);
System.out.println(d);

3.6.2 變量的修改

int a = 10;
a = 30;  //修改變量的值
System.out.println(a);

變量前面不加數據類型時，表示修改已存在的變量的值。

1. 在同一對花括號中，變量名不能重復。

2. 變量在使用之前，必須初始化（賦值）。

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

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

我們可以通過 Scanner 類來獲取用戶的輸入。使用步驟如下：

1、導包。Scanner 類在java.util包下，所以需要將該類導入。導包的語句需要定義在類的上面。

import java.util.Scanner; 

2、創建Scanner對象。

Scanner sc = new Scanner(System.in);// 創建Scanner對象，sc表示變量名，其他均不可變

3、接收數據

int i = sc.nextInt(); // 表示將鍵盤錄入的值作為int數返回。

示例：

import java.util.Scanner;
public class ScannerDemo {
    public static void main(String[] args) {
        //創建對象
        Scanner sc = new Scanner(System.in);
        //接收數據
        int a = sc.nextInt();
        //輸出數據
        System.out.println(a);
    }
}

標識符是用戶編程時使用的名字，用于給類、方法、變量、常量等命名。

Java中標識符的組成規則：

由字母、數字、下劃線“_”、美元符號“$”組成，第一個字符不能是數字。

不能使用java中的關鍵字作為標識符。

標識符對大小寫敏感（區分大小寫）。

Java中標識符的命名約定：

小駝峰式命名：變量名、方法名

首字母小寫，從第二個單詞開始每個單詞的首字母大寫。

大駝峰式命名：類名

每個單詞的首字母都大寫。

另外，標識符的命名最好可以做到見名知意

例如：username、studentNumber等。

4 類型轉換

在Java中，一些數據類型之間是可以相互轉換的。分為兩種情況：自動類型轉換和強制類型轉換。

把一個表示數據范圍小的數值或者變量賦值給另一個表示數據范圍大的變量。這種轉換方式是自動的，直接書寫即可。例如：

double num = 10; // 將int類型的10直接賦值給double類型
System.out.println(num); // 輸出10.0

類型從小到大關系圖：

說明：

1. 整數默認是int類型，byte、short和char類型數據參與運算均會自動轉換為int類型。

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2; 
// 第三行代碼會報錯，b1和b2會自動轉換為int類型，計算結果為int，int賦值給byte需要強制類型轉換。
// 修改為:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);

2. boolean類型不能與其他基本數據類型相互轉換。

4.2 強制轉換(理解)

把一個表示數據范圍大的數值或者變量賦值給另一個表示數據范圍小的變量。

強制類型轉換格式：目標數據類型 變量名 = (目標數據類型)值或者變量;

例如：

double num1 = 5.5;
int num2 = (int) num1; // 將double類型的num1強制轉換為int類型
System.out.println(num2); // 輸出5（小數位直接舍棄）

4.3 類型轉換案例(理解)

案例代碼：

byte a = 3;
byte b = 4;
byte c = a + b; //錯誤。因為兩個byte變量相加，會先提升為int類型
byte d = 3 + 4; //正確。常量優化機制

常量優化機制：

在編譯時，整數常量的計算會直接算出結果，并且會自動判斷該結果是否在byte取值范圍內，

在：編譯通過

    不在：編譯失敗

5. 運算符

5.1.1 運算符和表達式（了解）

運算符：對常量或者變量進行操作的符號

表達式：用運算符把常量或者變量連接起來符合java語法的式子就可以稱為表達式。

不同運算符連接的表達式體現的是不同類型的表達式。

舉例說明：

int a = 10;
int b = 20;
int c = a + b;

+：是運算符，并且是算術運算符。

a + b：是表達式，由于+是算術運算符，所以這個表達式叫算術表達式。

5.1.2 算術運算符(應用)

注意：

1. /和%的區別：兩個數據做除法，/取結果的商，%取結果的余數。

2. 整數操作只能得到整數，要想得到小數，必須有浮點數參與運算。

int a = 10;
int b = 3;
System.out.println(a / b); // 輸出結果3
System.out.println(a % b); // 輸出結果1

5.1.3 字符的“+”操作（理解）

char類型參與算術運算，使用的是計算機底層對應的十進制數值。需要我們記住三個字符對應的數值：

'a' -- 97 a-z是連續的，所以'b'對應的數值是98，'c'是99，依次遞加

'A' -- 65 A-Z是連續的，所以'B'對應的數值是66，'C'是67，依次遞加

'0' -- 48 0-9是連續的，所以'1'對應的數值是49，'2'是50，依次遞加

// 可以通過使用字符與整數做算術運算，得出字符對應的數值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 輸出98，97 + 1 = 98
​
char ch2 = 'A';
System.out.println(ch2 + 1); // 輸出66，65 + 1 = 66
​
char ch3 = '0';
System.out.println(ch3 + 1); // 輸出49，48 + 1 = 49

算術表達式中包含不同的基本數據類型的值的時候，整個算術表達式的類型會自動進行提升。

提升規則：

byte類型，short類型和char類型將被提升到int類型，不管是否有其他類型參與運算。

整個表達式的類型自動提升到與表達式中最高等級的操作數相同的類型

等級順序：byte,short,char --> int --> long --> float --> double

例如：

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 該行報錯，因為byte類型參與算術運算會自動提示為int，int賦值給byte可能損失精度
int i3 = b1 + b2; // 應該使用int接收
byte b3 = (byte) (b1 + b2); // 或者將結果強制轉換為byte類型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因為num1會自動提升為double類型

5.1.4 字符串的“+”操作（理解）

當“+”操作中出現字符串時，這個”+”是字符串連接符，而不是算術運算。

System.out.println("wedu"+ 666); // 輸出：wedu666

在”+”操作中，如果出現了字符串，就是連接運算符，否則就是算術運算。當連續進行“+”操作時，從左到右逐個執行。

System.out.println(1 + 99 + "年文峰");            // 輸出：100年文峰
System.out.println(1 + 2 + "wedu" + 3 + 4);   // 輸出：3wedu34
// 可以使用小括號改變運算的優先級 
System.out.println(1 + 2 + "wedu" + (3 + 4)); // 輸出：3wedu7

5.1.5 數值拆分（應用）

需求：

鍵盤錄入一個三位數，將其拆分為個位，十位，百位，打印在控制臺

示例代碼：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        // 1：使用Scanner鍵盤錄入一個三位數
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個三位數");
        int num = sc.nextInt();
        // 2：個位的計算：數值 % 10
        int ge = num % 10;      
        // 3：十位的計算：數值 / 10 % 10
        int shi = num / 10 % 10;    
        // 4：百位的計算：數值 / 100
        int bai = num / 100;
        // 5：將個位, 十位, 百位拼接上正確的字符串, 打印即可
        System.out.println("整數"+num+"個位為:" + ge);
        System.out.println("整數"+num+"十位為:" + shi);
        System.out.println("整數"+num+"百位為:" + bai);
    }
}

注意事項：

++和-- 既可以放在變量的后邊，也可以放在變量的前邊。

單獨使用的時候， ++和-- 無論是放在變量的前邊還是后邊，結果是一樣的。

參與操作的時候，如果放在變量的后邊，先拿變量參與操作，后拿變量做++或者--。

參與操作的時候，如果放在變量的前邊，先拿變量做++或者--，后拿變量參與操作。

最常見的用法：單獨使用。

int i = 10;
i++; // 單獨使用
System.out.println("i:" + i); // i:11
​
int j = 10;
++j; // 單獨使用
System.out.println("j:" + j); // j:11
​
int x = 10;
int y = x++; // 賦值運算，++在后邊，所以是使用x原來的值賦值給y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10
​
int m = 10;
int n = ++m; // 賦值運算，++在前邊，所以是使用m自增后的值賦值給n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

練習：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？
/*
解析，三個表達式都是++在后，所以每次使用的都是自增前的值，但程序自左至右執行，所以第一次自增時，使用的是10進行計算，但第二次自增時，x的值已經自增到11了，所以第二次使用的是11，然后再次自增。。。
所以整個式子應該是：int y = 10 + 11 + 12;
輸出結果為33。
*/
注意：通過此練習深刻理解自增和自減的規律，但實際開發中強烈建議不要寫這樣的代碼！小心挨打！

賦值運算符的作用是將一個表達式的值賦給左邊，左邊必須是可修改的，不能是常量。

注意：

擴展的賦值運算符隱含了強制類型轉換。

short s = 10;
s = s + 10; // 此行代碼報出，因為運算中s提升為int類型，運算結果int賦值給short可能損失精度
​
s += 10; // 此行代碼沒有問題，隱含了強制類型轉換，相當于 s = (short) (s + 10);

關系運算符有6種關系，分別為小于、小于等于、大于、等于、大于等于、不等于。

注意事項：

關系運算符的結果都是boolean類型，要么是true，要么是false。

千萬不要把“==”誤寫成“=”，"=="是判斷是否相等的關系，"="是賦值。

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true
​
// 關系運算的結果肯定是boolean類型，所以也可以將運算結果賦值給boolean類型的變量
boolean flag = a > b;
System.out.println(flag); // 輸出false

邏輯運算符把各個運算的關系表達式連接起來組成一個復雜的邏輯表達式，以判斷程序中的表達式是否成立，判斷的結果是 true 或 false。

//定義變量
int i = 10;
int j = 20;
int k = 30;
​
//& “與”，并且的關系，只要表達式中有一個值為false，結果即為false
System.out.println((i > j) & (i > k)); //false & false,輸出false
System.out.println((i < j) & (i > k)); //true & false,輸出false
System.out.println((i > j) & (i < k)); //false & true,輸出false
System.out.println((i < j) & (i < k)); //true & true,輸出true
System.out.println("--------");
​
//| “或”，或者的關系，只要表達式中有一個值為true，結果即為true
System.out.println((i > j) | (i > k)); //false | false,輸出false
System.out.println((i < j) | (i > k)); //true | false,輸出true
System.out.println((i > j) | (i < k)); //false | true,輸出true
System.out.println((i < j) | (i < k)); //true | true,輸出true
System.out.println("--------");
​
//^ “異或”，相同為false，不同為true
System.out.println((i > j) ^ (i > k)); //false ^ false,輸出false
System.out.println((i < j) ^ (i > k)); //true ^ false,輸出true
System.out.println((i > j) ^ (i < k)); //false ^ true,輸出true
System.out.println((i < j) ^ (i < k)); //true ^ true,輸出false
System.out.println("--------");
​
//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,輸出true

在邏輯與運算中，只要有一個表達式的值為false，那么結果就可以判定為false了，沒有必要將所有表達式的值都計算出來，短路與操作就有這樣的效果，可以提高效率。同理在邏輯或運算中，一旦發現值為true，右邊的表達式將不再參與運算。

• 邏輯與&，無論左邊真假，右邊都要執行。

• 短路與&&，如果左邊為真，右邊執行；如果左邊為假，右邊不執行。

• 邏輯或|，無論左邊真假，右邊都要執行。

• 短路或||，如果左邊為假，右邊執行；如果左邊為真，右邊不執行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 兩個表達都會運算
System.out.println(x); // 4
System.out.println(y); // 5
System.out.println((x++ > 4) && (y++ > 5)); // 左邊已經可以確定結果為false，右邊不參與運算
System.out.println(x); // 4
System.out.println(y); // 4

三元運算符語法格式：

關系表達式 ? 表達式1 : 表達式2;

解釋：問號前面的位置是判斷的條件，判斷結果為boolean型，為true時調用表達式1，為false時調用表達式2。其邏輯為：如果條件表達式成立或者滿足則執行表達式1，否則執行第二個。

舉例：

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判斷 a>b 是否為真，如果為真取a的值，如果為假，取b的值

需求：

一座寺廟里住著三個和尚，已知他們的身高分別為150cm、210cm、165cm，請用程序實現獲取這三個和尚的最高身高。

public class OperatorTest02 {
 public static void main(String[] args) {
  //1：定義三個變量用于保存和尚的身高，單位為cm，這里僅僅體現數值即可。
  int height1 = 150;
  int height2 = 210;
  int height3 = 165; 
  //2：用三元運算符獲取前兩個和尚的較高身高值，并用臨時身高變量保存起來。
  int tempHeight = height1 > height2 ? height1 : height2;  
  //3：用三元運算符獲取臨時身高值和第三個和尚身高較高值，并用最大身高變量保存。
  int maxHeight = tempHeight > height3 ? tempHeight : height3; 
  //4：輸出結果
  System.out.println("maxHeight:" + maxHeight);
 }
}

6. 流程控制語句

在一個程序執行的過程中，各條語句的執行順序對程序的結果是有直接影響的。所以，我們必須清楚每條語句的執行流程。而且，很多時候要通過控制語句的執行順序來實現我們想要的功能。

順序結構

分支結構(if, switch)

循環結構(for, while, do…while)

順序結構是程序中最簡單最基本的流程控制，沒有特定的語法結構，按照代碼的先后順序，依次執行，程序中大多數的代碼都是這樣執行的。

順序結構執行流程圖：

6.3.1 if語句格式1（理解）

格式：
if (關系表達式) {
    語句體; 
}

執行流程：

①首先計算關系表達式的值

②如果關系表達式的值為true就執行語句體

③如果關系表達式的值為false就不執行語句體

④繼續執行后面的語句內容

示例：

public class IfDemo {
 public static void main(String[] args) {
  System.out.println("開始");
  // 如果年齡大于18歲, 就可以上網吧
  int age = 17;
  if(age >= 18){
   // int a = 10;
   System.out.println("可以上網吧");
  }
  System.out.println("結束");
 }
}

6.3.2 if語句格式2（理解）

格式：
if (關系表達式) {
    語句體1; 
} else {
    語句體2; 
}

執行流程：

①首先計算關系表達式的值

②如果關系表達式的值為true就執行語句體1

③如果關系表達式的值為false就執行語句體2

④繼續執行后面的語句內容

示例：奇偶數

任意給出一個整數，請用程序實現判斷該整數是奇數還是偶數，并在控制臺輸出該整數是奇數還是偶數。

public class Demo2If {
 public static void main(String[] args) {
  // 程序判斷一個數, 是奇數還是偶數
  int num = 9;
  if(num % 2 == 0){
   System.out.println("偶數");
  }else{
   System.out.println("奇數");
  }
 }
}

6.3.3 if語句格式3（理解）

格式：
if (關系表達式1) {
    語句體1; 
} else if (關系表達式2) {
    語句體2; 
} 
…
else {
    語句體n+1;
}

執行流程：

①首先計算關系表達式1的值

②如果值為true就執行語句體1；如果值為false就計算關系表達式2的值

③如果值為true就執行語句體2；如果值為false就計算關系表達式3的值

④…

⑤如果沒有任何關系表達式為true，就執行語句體n+1。

示例：

定義一個在0~100之間的變量a, 90~100優秀，80~89良好，70~79中等，60~69及格，0~59請努力加油！

public class Demo3If {
 public static void main(String[] args){
  int score = 65;
  if(score >= 90 && score <= 100){
   System.out.println("優秀");
  }else if (score >= 80 && score <= 89){
   System.out.println("良好");
  }else if (score >= 70 && score <= 79){
   System.out.println("中等");
  }else if (score >= 60 && score <= 69){
   System.out.println("及格");
  }else if (score >= 0 && score <= 59){
   System.out.println("請努力加油");
  }else{
   System.out.println("成績有誤!");
  }
 }
}

6.3.4 if語句格式3案例（應用）

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

分析：

①小明的考試成績未知，可以使用鍵盤錄入的方式獲取值

②由于獎勵種類較多，屬于多種判斷，采用if...else...if格式實現

③為每種判斷設置對應的條件

④為每種判斷設置對應的獎勵

import java.util.Scanner;
public class IfTest02 {
    public static void main(String[] args){
        // 1. 使用Scanner錄入考試成績
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入您的成績:");
        int score = sc.nextInt();
        // 2. 判斷成績是否在合法范圍內 0~100
        if(score >=0 && score <= 100){
            // 合法成績
            // 3. 在合法的語句塊中判斷成績范圍符合哪一個獎勵
            if(score >= 95 && score <= 100){
                System.out.println("自行車一輛");
            }else if(score >= 90 && score <= 94){
                System.out.println("游樂場一次");
            }else if(score >= 80 && score <= 89){
                System.out.println("變形金剛一個");
            }else {
                System.out.println("挨頓揍, 這座城市又多了一個傷心的人~");
            }
        }else{
            // 非法的話, 給出錯誤提示
            System.out.println("您的成績輸入有誤!");
        }
    }
}

7. switch語句

• 格式

  switch (表達式) {
      case 1:
          語句體1;
          break;
      case 2:
          語句體2;
          break;
      ...
      default:
          語句體n+1;
          break;
  }

• 執行流程：

  • 首先計算出表達式的值

  • 其次，和case依次比較，一旦有對應的值，就會執行相應的語句，在執行的過程中，遇到break就會結 束。

  • 最后，如果所有的case都和表達式的值不匹配，就會執行default語句體部分，然后程序結束掉。

• 需求：鍵盤錄入星期數，顯示今天的減肥活動

周一：跑步  
周二：游泳  
周三：慢走  
周四：動感單車
周五：拳擊  
周六：爬山  
周日：好好吃一頓 

• 示例代碼：

public static void main(String[] args){
        // 1. 鍵盤錄入星期數據，使用變量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入");
        int week = sc.nextInt();
        // 2. 多情況判斷，采用switch語句實現
        switch(week){
            // 3. 在不同的case中，輸出對應的減肥計劃
            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;
        }
    }
}

• 概述 : 如果switch語句中,case省略了break語句, 就會開始case穿透

• 需求 : 鍵盤錄入星期數，輸出工作日、休息日 (1-5)工作日，(6-7)休息日

• 示例代碼：

/*
case穿透是如何產生的?
        如果switch語句中,case省略了break語句, 就會開始case穿透.
        現象：
            當開始case穿透，后續的case就不會具有匹配效果，內部的語句都會執行
            直到看見break，或者將整體switch語句執行完畢，才會結束。
*/
public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入星期數:");
        int week = sc.nextInt();
        switch(week){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("您的輸入有誤");
                break;
        }
    }   
}

8. for循環

• 循環：

  循環語句可以在滿足循環條件的情況下，反復執行某一段代碼，這段被重復執行的代碼被稱為循環體語句，當反復 執行這個循環體時，需要在合適的時候把循環判斷條件修改為false，從而結束循環，否則循環將一直執行下去，形 成死循環。

• for循環格式：

for (初始化語句;條件判斷語句;條件控制語句) {
    循環體語句;
}

• 格式解釋：

  • 初始化語句： 用于表示循環開啟時的起始狀態，簡單說就是循環開始的時候什么樣

  • 條件判斷語句：用于表示循環反復執行的條件，簡單說就是判斷循環是否能一直執行下去

  • 循環體語句： 用于表示循環反復執行的內容，簡單說就是循環反復執行的事情

  • 條件控制語句：用于表示循環執行中每次變化的內容，簡單說就是控制循環是否能執行下去

• 執行流程：

  ①執行初始化語句

  ②執行條件判斷語句，看其結果是true還是false

  如果是false，循環結束

  如果是true，繼續執行

  ③執行循環體語句

  ④執行條件控制語句

  ⑤回到②繼續

• 需求：在控制臺輸出1-5和5-1的數據

• 示例代碼：

public class ForTest01 {
    public static void main(String[] args) {
        //需求：輸出數據1-5
        for(int i=1; i<=5; i++) {
            System.out.println(i);
        }
        System.out.println("--------");
        //需求：輸出數據5-1
        for(int i=5; i>=1; i--) {
            System.out.println(i);
        }
    }
}

• 需求：求1-5之間的數據和，并把求和結果在控制臺輸出

• 示例代碼：

public class ForTest02 {
    public static void main(String[] args) {
        //求和的最終結果必須保存起來，需要定義一個變量，用于保存求和的結果，初始值為0
        int sum = 0;
        //從1開始到5結束的數據，使用循環結構完成
        for(int i=1; i<=5; i++) {
            //將反復進行的事情寫入循環結構內部
             // 此處反復進行的事情是將數據 i 加到用于保存最終求和的變量 sum 中
            sum += i;
            /*
                sum += i;   sum = sum + i;
                第一次：sum = sum + i = 0 + 1 = 1;
                第二次：sum = sum + i = 1 + 2 = 3;
                第三次：sum = sum + i = 3 + 3 = 6;
                第四次：sum = sum + i = 6 + 4 = 10;
                第五次：sum = sum + i = 10 + 5 = 15;
            */
        }
        //當循環執行完畢時，將最終數據打印出來
        System.out.println("1-5之間的數據和是：" + sum);
    }
}

• 本題要點：

  • 今后遇到的需求中，如果帶有求和二字，請立即聯想到求和變量

  • 求和變量的定義位置，必須在循環外部，如果在循環內部則計算出的數據將是錯誤的

• 需求：求1-100之間的偶數和，并把求和結果在控制臺輸出 }

• 示例代碼：

public class ForTest03 {
    public static void main(String[] args) {
        //求和的最終結果必須保存起來，需要定義一個變量，用于保存求和的結果，初始值為0
        int sum = 0;
        //對1-100的數據求和與1-5的數據求和幾乎完全一樣，僅僅是結束條件不同
        for(int i=1; i<=100; i++) {
            //對1-100的偶數求和，需要對求和操作添加限制條件，判斷是否是偶數
            if(i%2 == 0) {
                sum += i;
            }
        }
        //當循環執行完畢時，將最終數據打印出來
        System.out.println("1-100之間的偶數和是：" + sum);
    }
}

• 需求：在控制臺輸出所有的“水仙花數”

• 解釋：什么是水仙花數？

  • 水仙花數，指的是一個三位數，個位、十位、百位的數字立方和等于原數

    • 例如153 3*3*3 + 5*5*5 + 1*1*1 = 153

• 思路：

  1. 獲取所有的三位數，準備進行篩選，最小的三位數為100，最大的三位數為999，使用for循環獲取

  2. 獲取每一個三位數的個位，十位，百位，做if語句判斷是否是水仙花數

• 示例代碼

public class ForTest04 {
    public static void main(String[] args) {
  //輸出所有的水仙花數必然要使用到循環，遍歷所有的三位數，三位數從100開始，到999結束
  for(int i=100; i<1000; i++) {
   //在計算之前獲取三位數中每個位上的值
   int ge = i%10;
   int shi = i/10%10;
   int bai = i/10/10%10;
   //判定條件是將三位數中的每個數值取出來，計算立方和后與原始數字比較是否相等
   if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
    //輸出滿足條件的數字就是水仙花數
    System.out.println(i);
   }
  }
    }
}

• 需求：在控制臺輸出所有的“水仙花數”，要求每行打印2個

• 示例代碼：

public class Demo6For {
 /*
  需求：在控制臺輸出所有的“水仙花數”，要求每行打印2個
  System.out.print (打印內容); 打印后不換行
  System.out.println(打印內容); 打印后換行
  分析:
   1. 定義變量count，用于保存“打印過”的數量，初始值為0
   2. 在判定和打印水仙花數的過程中，拼接空格, 但不換行，并在打印后讓count變量+1，記錄打印過的數量
   3. 在每一次count變量+1后，判斷是否到達了2的倍數，是的話，換行。
 */
 public static void main(String[] args){
  // 1. 定義變量count，用于保存“打印過”的數量，初始值為0
  int count = 0;
  for(int i = 100; i <= 999; i++){
   int ge = i % 10;
   int shi = i / 10 % 10;
   int bai = i / 10 / 10 % 10;
   if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
    //  2. 在判定和打印水仙花數的過程中，拼接空格, 但不換行，并在打印后讓count變量+1，記錄打印過的數量
    System.out.print(i + " ");
    count++;
    // 3. 在每一次count變量+1后，判斷是否到達了2的倍數，是的話，換行
    if(count % 2 == 0){
     System.out.println();
    }
   }
  }
 }
}

• 本題要點：

  • 今后如果需求帶有統計xxx，請先想到計數器變量

  • 計數器變量定義的位置，必須在循環外部

9. while循環

• while循環完整格式：

  初始化語句;
  while (條件判斷語句) {
   循環體語句;
      條件控制語句;
  }

• while循環執行流程：

  ①執行初始化語句

  ②執行條件判斷語句，看其結果是true還是false

  如果是false，循環結束

  如果是true，繼續執行

  ③執行循環體語句

  ④執行條件控制語句

  ⑤回到②繼續

• 示例代碼：

public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制臺輸出5次"HelloWorld"
  //for循環實現
  for(int i=1; i<=5; i++) {
   System.out.println("HelloWorld");
  }
  System.out.println("--------");
  //while循環實現
  int j = 1;
  while(j<=5) {
   System.out.println("HelloWorld");
   j++;
  }
    }
}

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

• 示例代碼：

public class WhileTest {
    public static void main(String[] args) {
  //定義一個計數器，初始值為0
  int count = 0;
  //定義紙張厚度
  double paper = 0.1;
  //定義珠穆朗瑪峰的高度
  int zf = 8844430;
  //因為要反復折疊，所以要使用循環，但是不知道折疊多少次，這種情況下更適合使用while循環
  //折疊的過程中當紙張厚度大于珠峰就停止了，因此繼續執行的要求是紙張厚度小于珠峰高度
  while(paper <= zf) {
   //循環的執行過程中每次紙張折疊，紙張的厚度要加倍
   paper *= 2;
   //在循環中執行累加，對應折疊了多少次
   count++;
  }
  //打印計數器的值
  System.out.println("需要折疊：" + count + "次");
    }
}

10. 循環細節

• 完整格式：

  初始化語句;
  do {
   循環體語句;
   條件控制語句;
  }while(條件判斷語句);

• 執行流程：

  ① 執行初始化語句

  ② 執行循環體語句

  ③ 執行條件控制語句

  ④ 執行條件判斷語句，看其結果是true還是false

  如果是false，循環結束

  如果是true，繼續執行

  ⑤ 回到②繼續

• 示例代碼：

public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制臺輸出5次"HelloWorld"
  //for循環實現
  for(int i=1; i<=5; i++) {
   System.out.println("HelloWorld");
  }
  System.out.println("--------");
  //do...while循環實現
  int j = 1;
  do {
   System.out.println("HelloWorld");
   j++;
  }while(j<=5);
    }
}

• 三種循環的區別

  • for循環和while循環先判斷條件是否成立，然后決定是否執行循環體（先判斷后執行）

  • do...while循環先執行一次循環體，然后判斷條件是否成立，是否繼續執行循環體（先執行后判斷）

• for循環和while的區別

  • 條件控制語句所控制的自增變量，因為歸屬for循環的語法結構中，在for循環結束后，就不能再次被訪問到了

  • 條件控制語句所控制的自增變量，對于while循環來說不歸屬其語法結構中，在while循環結束后，該變量還可以繼續使用

• 死循環（無限循環）的三種格式

  1. for(;;){}

  2. while(true){}

  3. do {} while(true);

• 死循環格式

  for死循環格式 :
  for(;;){
  }
  while死循環格式 :
  while(true){
  }
  do..while死循環格式 :
  do{
  }while(true);

• 死循環案例

/*
 問題: 死循環有應用場景嗎?
    例如: 鍵盤錄入一個1-100之間的整數
    顧慮: 鍵盤錄入是用戶操作的, 用戶就可能會出現一些誤操作的現象
*/
public static void main(String[] args) {
    /*
  for(;;){
   System.out.println("我停不下來了~");
  }
  */
    /*
  while(true){
   System.out.println("我停不下來了~");
  }
  */
    do{
        System.out.println("我停不下來了~"); 
    }while(true);
    System.out.println("看看我能被執行嗎?~"); // 無法訪問的語句
}
}

• 跳轉控制語句（break）

  • 跳出循環，結束循環

• 跳轉控制語句（continue）

  • 跳過本次循環，繼續下次循環

• 注意： continue只能在循環中進行使用！

public class Demo1Continue {
 /*
  continue : 跳過某次循環體內容的執行
  注意：使用是基于條件控制, 在循環內部使用.
  需求: 模擬電梯上行的過程 1-24層, 4層不停.
 */
 public static void main(String[] args){
  for(int i = 1; i <= 24; i++){
   if(i == 4){
    continue;
   }
   System.out.println(i + "層到了~");
  }
 }
}

public class Demo2Break {
 /*
  break : 終止循環體內容的執行
  注意：使用是基于條件控制的
    break語句只能在循環和switch中進行使用.
  需求: 模擬20歲工作到80歲, 60歲退休.
 */
 public static void main(String[] args){
  for(int i = 20; i <= 80; i++){
   if(i == 60){
    break;  // 結束整個循環
   }
   System.out.println(i + "歲正在上班");
  }
 }
}

import java.util.Scanner;
public class Test {
 /*
  需求：程序運行后，用戶可多次查詢星期對應的減肥計劃，直到輸入0，程序結束
  步驟:
   1. 不明確用戶操作幾次, 使用死循環包裹業務邏輯
   2. 匹配到0的時候，使用break結束循環死循環
 */
 public static void main (String[] args){
  lo:while(true){
   System.out.println("請輸入您要查看的星期數:");
   System.out.println("(如無需繼續查看,請輸入0退出程序)");
   // 1. 鍵盤錄入星期數據，使用變量接收
   Scanner sc = new Scanner(System.in);
   int week = sc.nextInt();
   // 2. 多情況判斷，采用switch語句實現
   switch(week){
    // 3. 在不同的case中，輸出對應的減肥計劃
    case 0:
     System.out.println("感謝您的使用");
     break lo;
    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;
   }
  }
 }
}

11. Random

• 概述：

  • Random類似Scanner，也是Java提供好的API，內部提供了產生隨機數的功能

    • API后續課程詳細講解，現在可以簡單理解為Java已經寫好的代碼

• 使用步驟：

  1. 導入包

     import java.util.Random;

  2. 創建對象

     Random r = new Random();

  3. 產生隨機數

     int num = r.nextInt(10);

     解釋： 10代表的是一個范圍，如果括號寫10，產生的隨機數就是0-9，括號寫20，參數的隨機數則是0-19

• 示例代碼：

import java.util.Random;
public class Demo1Random {
 /*
  Random : 產生隨機數
  1. 導包 : import java.util.Random;
        導包的動作必須出現在類定義的上面
  2. 創建對象 : Random r = new Random();
     上面這個格式里面，r 是變量名，可以變，其他的都不允許變
  3. 獲取隨機數 : int number = r.nextInt(10); //獲取數據的范圍：[0,10) 包括0,不包括10
     上面這個格式里面，number是變量名，可以變，數字10可以變。其他的都不允許變
  需求: 產生隨機數1-10之間的
 */
 public static void main(String[] args){
  // 2. 創建對象
  Random r = new Random();
  for(int i = 1; i <= 10; i++){
   // 3. 獲取隨機數
   int num = r.nextInt(10) + 1;  // 1-10
   System.out.println(num);
  }
 }
}

• 需求：

  程序自動生成一個1-100之間的數字，使用程序實現猜出這個數字是多少？

  當猜錯的時候根據不同情況給出相應的提示

  A. 如果猜的數字比真實數字大，提示你猜的數據大了

  B. 如果猜的數字比真實數字小，提示你猜的數據小了

  C. 如果猜的數字與真實數字相等，提示恭喜你猜中了

• 示例代碼：

import java.util.Scanner;
import java.util.Random;
public class Test {
 /*
  需求：程序自動生成一個1-100之間的數字，使用程序實現猜出這個數字是多少？
   當猜錯的時候根據不同情況給出相應的提示
   如果猜的數字比真實數字大，提示你猜的數據大了
   如果猜的數字比真實數字小，提示你猜的數據小了
   如果猜的數字與真實數字相等，提示恭喜你猜中了
  1. 準備Random和Scanner對象, 分別用于產生隨機數和鍵盤錄入
  2. 使用Random產生一個1-100之間的數, 作為要猜的數
  3. 鍵盤錄入用戶猜的的數據
  4. 使用錄入的數據(用戶猜的數據)和隨機數(要猜的數據)進行比較, 并給出提示
  5. 以上內容需要多次進行, 但無法預估用戶輸入幾次可以猜測正確, 使用while(true)死循環包裹
  6. 猜對之后, break結束.
 */
 public static void main(String[] args){
  // 1. 準備Random和Scanner對象, 分別用于產生隨機數和鍵盤錄入
  Random r = new Random();
  Scanner sc = new Scanner(System.in);
  // 2. 使用Random產生一個1-100之間的數, 作為要猜的數
  int randomNum = r.nextInt(100) + 1;
  // 5. 以上內容需要多次進行, 但無法預估用戶輸入幾次可以猜測正確, 使用while(true)死循環包裹
  while(true){
   // 3. 鍵盤錄入用戶猜的的數據
   System.out.println("請輸入您猜的數據:");
   int num = sc.nextInt();
   // 4. 使用錄入的數據(用戶猜的數據)和隨機數(要猜的數據)進行比較, 并給出提示
   if(num > randomNum){
    System.out.println("猜大了");
   }else if(num < randomNum){
    System.out.println("猜小了");
   }else{
    // 6. 猜對之后, break結束.
    System.out.println("恭喜,猜中了");
    break;
   }
  }
  System.out.println("感謝您的使用");
 }
}