前言

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

1. Java概述

語(yǔ)言：人與人交流溝通的表達(dá)方式

計(jì)算機(jī)語(yǔ)言：人與計(jì)算機(jī)之間進(jìn)行信息交流溝通的一種特殊語(yǔ)言

Java語(yǔ)言是美國(guó)Sun公司（Stanford University Network）在1995年推出的計(jì)算機(jī)語(yǔ)言

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

2009年，Sun公司被甲骨文公司收購(gòu)，所以我們現(xiàn)在訪問(wèn)oracle官網(wǎng)即可：https://www.oracle.com

java語(yǔ)言的三個(gè)版本：

JavaSE: Java 語(yǔ)言的（標(biāo)準(zhǔn)版），用于桌面應(yīng)用的開發(fā)，是其他兩個(gè)版本的基礎(chǔ)

JavaME: Java 語(yǔ)言的（小型版），用于嵌入式消費(fèi)類電子設(shè)備

JavaEE: Java 語(yǔ)言的（企業(yè)版），用于 Web 方向的網(wǎng)站開發(fā)

Java程序并非是直接運(yùn)行的，Java編譯器將Java源程序編譯成與平臺(tái)無(wú)關(guān)的字節(jié)碼文件(class文件)，然后由Java虛擬機(jī)（JVM）對(duì)字節(jié)碼文件解釋執(zhí)行。所以在不同的操作系統(tǒng)下，只需安裝不同的Java虛擬機(jī)即可實(shí)現(xiàn)java程序的跨平臺(tái)。

JVM（Java Virtual Machine），Java虛擬機(jī)

JRE（Java Runtime Environment），Java運(yùn)行環(huán)境，包含了JVM和Java的核心類庫(kù)（Java API）

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

總結(jié)：我們只需安裝JDK即可，它包含了java的運(yùn)行環(huán)境和虛擬機(jī)。

1.4.1 下載

通過(guò)官方網(wǎng)站獲取JDK

http://www.oracle.com

注意：針對(duì)不同的操作系統(tǒng)，需要下載對(duì)應(yīng)版本的JDK。

1.4.2 安裝

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

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

1.4.3 JDK的安裝目錄介紹

2. 第一個(gè)演示程序

在接觸集成開發(fā)環(huán)境之前，我們需要使用命令行窗口對(duì)java程序進(jìn)行編譯和運(yùn)行，所以需要知道一些常用DOS命令。

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

2、常用命令及其作用

2.2.1 為什么配置環(huán)境變量

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

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

各種計(jì)算機(jī)語(yǔ)言都習(xí)慣使用該案例作為第一個(gè)演示案例。

2.3.1 Java程序開發(fā)運(yùn)行流程

開發(fā)Java程序，需要三個(gè)步驟：編寫程序，編譯程序，運(yùn)行程序。

2.3.2 HelloWorld案例的編寫

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

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

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

2.3.3 HelloWorld案例的編譯和運(yùn)行

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

編譯：javac 文件名.java

范例：javac HelloWorld.java

執(zhí)行：java 類名

范例：java HelloWorld

2.5.1 BUG

在電腦系統(tǒng)或程序中，隱藏著的一些未被發(fā)現(xiàn)的缺陷或問(wèn)題統(tǒng)稱為bug（漏洞）。

2.5.2 BUG的解決

1、具備識(shí)別BUG的能力：多看

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

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

2.5.3 HelloWorld案例常見問(wèn)題

1、非法字符問(wèn)題。Java中的符號(hào)都是英文格式的。

2、大小寫問(wèn)題。Java語(yǔ)言對(duì)大小寫敏感（區(qū)分大小寫）。

3、在系統(tǒng)中顯示文件的擴(kuò)展名，避免出現(xiàn)HelloWorld.java.txt文件。

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

5、運(yùn)行命令后的class文件名（類名）不帶文件后綴

2.6.1 什么要使用Notepad++軟件

Notepad++功能比windows中的自帶記事本功能強(qiáng)大，除了可以用來(lái)制作一般的純文字說(shuō)明文件，也十分適合編寫計(jì)算機(jī)程序代碼。Notepad++有行號(hào)，能夠快速定位問(wèn)題位置，還有語(yǔ)法高亮度顯示、代碼折疊等功能。而且它是免費(fèi)的。

2.6.2 Notepad++軟件安裝

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

2.6.3Notepad++軟件配置

安裝完畢之后，為了使用方便，做一個(gè)簡(jiǎn)單的配置：修改默認(rèn)語(yǔ)言和編碼。

3. java基礎(chǔ)語(yǔ)法

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

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

// 這是單行注釋文字

多行注釋。多行注釋的格式是使用/* 和 */將一段較長(zhǎng)的注釋括起來(lái)。

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

文檔注釋。文檔注釋以/**開始，以*/結(jié)束。

關(guān)鍵字是指被java語(yǔ)言賦予了特殊含義的單詞。

關(guān)鍵字的特點(diǎn)：

關(guān)鍵字的字母全部小寫。

常用的代碼編輯器對(duì)關(guān)鍵字都有高亮顯示，比如現(xiàn)在我們能看到的public、class、static等。

常量：在程序運(yùn)行過(guò)程中，其值不可以發(fā)生改變的量。

Java中的常量分類：

字符串常量 用雙引號(hào)括起來(lái)的多個(gè)字符（可以包含0個(gè)、一個(gè)或多個(gè)），例如"a"、"abc"、"中國(guó)"等

整數(shù)常量 整數(shù)，例如：-10、0、88等

小數(shù)常量 小數(shù)，例如：-5.5、1.0、88.88等

字符常量 用單引號(hào)括起來(lái)的一個(gè)字符，例如：'a'、'5'、'B'、'中'等

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

空常量 一個(gè)特殊的值，空值，值為null

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

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

變量的定義格式：

數(shù)據(jù)類型 變量名 = 數(shù)據(jù)值；

數(shù)據(jù)類型：為空間中存儲(chǔ)的數(shù)據(jù)加入類型限制。整數(shù)？小數(shù)？

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

數(shù)據(jù)值： 空間中要存儲(chǔ)的數(shù)值，沒有難度

3.5.1 計(jì)算機(jī)存儲(chǔ)單元

我們知道計(jì)算機(jī)是可以用來(lái)存儲(chǔ)數(shù)據(jù)的，但是無(wú)論是內(nèi)存還是硬盤，計(jì)算機(jī)存儲(chǔ)設(shè)備的最小信息單元叫“位（bit）”，我們又稱之為“比特位”，通常用小寫的字母”b”表示。而計(jì)算機(jī)中最基本的存儲(chǔ)單元叫“字節(jié)（byte）”，

通常用大寫字母”B”表示，字節(jié)是由連續(xù)的8個(gè)位組成。

除了字節(jié)外還有一些常用的存儲(chǔ)單位，其換算單位如下：

1B（字節(jié)） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

3.5.2 Java中的數(shù)據(jù)類型

Java是一個(gè)強(qiáng)類型語(yǔ)言，Java中的數(shù)據(jù)必須明確數(shù)據(jù)類型。在Java中的數(shù)據(jù)類型包括基本數(shù)據(jù)類型和引用數(shù)據(jù)類型兩種。

Java中的基本數(shù)據(jù)類型：

說(shuō)明：

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

在java中整數(shù)默認(rèn)是int類型，浮點(diǎn)數(shù)默認(rèn)是double類型。

3.6.1 變量的定義

變量：在程序運(yùn)行過(guò)程中，其值可以發(fā)生改變的量。

從本質(zhì)上講，變量是內(nèi)存中的一小塊區(qū)域，其值可以在一定范圍內(nèi)變化。

變量的定義格式：

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

或者(擴(kuò)展)

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

還可以(擴(kuò)展)

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

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

3.6.2 變量的修改

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

變量前面不加數(shù)據(jù)類型時(shí)，表示修改已存在的變量的值。

1. 在同一對(duì)花括號(hào)中，變量名不能重復(fù)。

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

3. 定義long類型的變量時(shí)，需要在整數(shù)的后面加L（大小寫均可，建議大寫）。因?yàn)檎麛?shù)默認(rèn)是int類型，整數(shù)太大可能超出int范圍。

4. 定義float類型的變量時(shí)，需要在小數(shù)的后面加F（大小寫均可，建議大寫）。因?yàn)楦↑c(diǎn)數(shù)的默認(rèn)類型是double， double的取值范圍是大于float的，類型不兼容。

我們可以通過(guò) Scanner 類來(lái)獲取用戶的輸入。使用步驟如下：

1、導(dǎo)包。Scanner 類在java.util包下，所以需要將該類導(dǎo)入。導(dǎo)包的語(yǔ)句需要定義在類的上面。

import java.util.Scanner; 

2、創(chuàng)建Scanner對(duì)象。

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

3、接收數(shù)據(jù)

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

示例：

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

標(biāo)識(shí)符是用戶編程時(shí)使用的名字，用于給類、方法、變量、常量等命名。

Java中標(biāo)識(shí)符的組成規(guī)則：

由字母、數(shù)字、下劃線“_”、美元符號(hào)“$”組成，第一個(gè)字符不能是數(shù)字。

不能使用java中的關(guān)鍵字作為標(biāo)識(shí)符。

標(biāo)識(shí)符對(duì)大小寫敏感（區(qū)分大小寫）。

Java中標(biāo)識(shí)符的命名約定：

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

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

大駝峰式命名：類名

每個(gè)單詞的首字母都大寫。

另外，標(biāo)識(shí)符的命名最好可以做到見名知意

例如：username、studentNumber等。

4 類型轉(zhuǎn)換

在Java中，一些數(shù)據(jù)類型之間是可以相互轉(zhuǎn)換的。分為兩種情況：自動(dòng)類型轉(zhuǎn)換和強(qiáng)制類型轉(zhuǎn)換。

把一個(gè)表示數(shù)據(jù)范圍小的數(shù)值或者變量賦值給另一個(gè)表示數(shù)據(jù)范圍大的變量。這種轉(zhuǎn)換方式是自動(dòng)的，直接書寫即可。例如：

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

類型從小到大關(guān)系圖：

說(shuō)明：

1. 整數(shù)默認(rèn)是int類型，byte、short和char類型數(shù)據(jù)參與運(yùn)算均會(huì)自動(dòng)轉(zhuǎn)換為int類型。

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2; 
// 第三行代碼會(huì)報(bào)錯(cuò)，b1和b2會(huì)自動(dòng)轉(zhuǎn)換為int類型，計(jì)算結(jié)果為int，int賦值給byte需要強(qiáng)制類型轉(zhuǎn)換。
// 修改為:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);

2. boolean類型不能與其他基本數(shù)據(jù)類型相互轉(zhuǎn)換。

4.2 強(qiáng)制轉(zhuǎn)換(理解)

把一個(gè)表示數(shù)據(jù)范圍大的數(shù)值或者變量賦值給另一個(gè)表示數(shù)據(jù)范圍小的變量。

強(qiáng)制類型轉(zhuǎn)換格式：目標(biāo)數(shù)據(jù)類型 變量名 = (目標(biāo)數(shù)據(jù)類型)值或者變量;

例如：

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

4.3 類型轉(zhuǎn)換案例(理解)

案例代碼：

byte a = 3;
byte b = 4;
byte c = a + b; //錯(cuò)誤。因?yàn)閮蓚�(gè)byte變量相加，會(huì)先提升為int類型
byte d = 3 + 4; //正確。常量?jī)?yōu)化機(jī)制

常量?jī)?yōu)化機(jī)制：

在編譯時(shí)，整數(shù)常量的計(jì)算會(huì)直接算出結(jié)果，并且會(huì)自動(dòng)判斷該結(jié)果是否在byte取值范圍內(nèi)，

在：編譯通過(guò)

    不在：編譯失敗

5. 運(yùn)算符

5.1.1 運(yùn)算符和表達(dá)式（了解）

運(yùn)算符：對(duì)常量或者變量進(jìn)行操作的符號(hào)

表達(dá)式：用運(yùn)算符把常量或者變量連接起來(lái)符合java語(yǔ)法的式子就可以稱為表達(dá)式。

不同運(yùn)算符連接的表達(dá)式體現(xiàn)的是不同類型的表達(dá)式。

舉例說(shuō)明：

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

+：是運(yùn)算符，并且是算術(shù)運(yùn)算符。

a + b：是表達(dá)式，由于+是算術(shù)運(yùn)算符，所以這個(gè)表達(dá)式叫算術(shù)表達(dá)式。

5.1.2 算術(shù)運(yùn)算符(應(yīng)用)

注意：

1. /和%的區(qū)別：兩個(gè)數(shù)據(jù)做除法，/取結(jié)果的商，%取結(jié)果的余數(shù)。

2. 整數(shù)操作只能得到整數(shù)，要想得到小數(shù)，必須有浮點(diǎn)數(shù)參與運(yùn)算。

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

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

char類型參與算術(shù)運(yùn)算，使用的是計(jì)算機(jī)底層對(duì)應(yīng)的十進(jìn)制數(shù)值。需要我們記住三個(gè)字符對(duì)應(yīng)的數(shù)值：

'a' -- 97 a-z是連續(xù)的，所以'b'對(duì)應(yīng)的數(shù)值是98，'c'是99，依次遞加

'A' -- 65 A-Z是連續(xù)的，所以'B'對(duì)應(yīng)的數(shù)值是66，'C'是67，依次遞加

'0' -- 48 0-9是連續(xù)的，所以'1'對(duì)應(yīng)的數(shù)值是49，'2'是50，依次遞加

// 可以通過(guò)使用字符與整數(shù)做算術(shù)運(yùn)算，得出字符對(duì)應(yīng)的數(shù)值是多少
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

算術(shù)表達(dá)式中包含不同的基本數(shù)據(jù)類型的值的時(shí)候，整個(gè)算術(shù)表達(dá)式的類型會(huì)自動(dòng)進(jìn)行提升。

提升規(guī)則：

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

整個(gè)表達(dá)式的類型自動(dòng)提升到與表達(dá)式中最高等級(jí)的操作數(shù)相同的類型

等級(jí)順序：byte,short,char --> int --> long --> float --> double

例如：

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 該行報(bào)錯(cuò)，因?yàn)閎yte類型參與算術(shù)運(yùn)算會(huì)自動(dòng)提示為int，int賦值給byte可能損失精度
int i3 = b1 + b2; // 應(yīng)該使用int接收
byte b3 = (byte) (b1 + b2); // 或者將結(jié)果強(qiáng)制轉(zhuǎn)換為byte類型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因?yàn)閚um1會(huì)自動(dòng)提升為double類型

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

當(dāng)“+”操作中出現(xiàn)字符串時(shí)，這個(gè)”+”是字符串連接符，而不是算術(shù)運(yùn)算。

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

在”+”操作中，如果出現(xiàn)了字符串，就是連接運(yùn)算符，否則就是算術(shù)運(yùn)算。當(dāng)連續(xù)進(jìn)行“+”操作時(shí)，從左到右逐個(gè)執(zhí)行。

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

5.1.5 數(shù)值拆分（應(yīng)用）

需求：

鍵盤錄入一個(gè)三位數(shù)，將其拆分為個(gè)位，十位，百位，打印在控制臺(tái)

示例代碼：

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

注意事項(xiàng)：

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

單獨(dú)使用的時(shí)候， ++和-- 無(wú)論是放在變量的前邊還是后邊，結(jié)果是一樣的。

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

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

最常見的用法：?jiǎn)为?dú)使用。

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

練習(xí)：

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

賦值運(yùn)算符的作用是將一個(gè)表達(dá)式的值賦給左邊，左邊必須是可修改的，不能是常量。

注意：

擴(kuò)展的賦值運(yùn)算符隱含了強(qiáng)制類型轉(zhuǎn)換。

short s = 10;
s = s + 10; // 此行代碼報(bào)出，因?yàn)檫\(yùn)算中s提升為int類型，運(yùn)算結(jié)果int賦值給short可能損失精度
​
s += 10; // 此行代碼沒有問(wèn)題，隱含了強(qiáng)制類型轉(zhuǎn)換，相當(dāng)于 s = (short) (s + 10);

關(guān)系運(yùn)算符有6種關(guān)系，分別為小于、小于等于、大于、等于、大于等于、不等于。

注意事項(xiàng)：

關(guān)系運(yùn)算符的結(jié)果都是boolean類型，要么是true，要么是false。

千萬(wàn)不要把“==”誤寫成“=”，"=="是判斷是否相等的關(guān)系，"="是賦值。

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
​
// 關(guān)系運(yùn)算的結(jié)果肯定是boolean類型，所以也可以將運(yùn)算結(jié)果賦值給boolean類型的變量
boolean flag = a > b;
System.out.println(flag); // 輸出false

邏輯運(yùn)算符把各個(gè)運(yùn)算的關(guān)系表達(dá)式連接起來(lái)組成一個(gè)復(fù)雜的邏輯表達(dá)式，以判斷程序中的表達(dá)式是否成立，判斷的結(jié)果是 true 或 false。

//定義變量
int i = 10;
int j = 20;
int k = 30;
​
//& “與”，并且的關(guān)系，只要表達(dá)式中有一個(gè)值為false，結(jié)果即為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("--------");
​
//| “或”，或者的關(guān)系，只要表達(dá)式中有一個(gè)值為true，結(jié)果即為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

在邏輯與運(yùn)算中，只要有一個(gè)表達(dá)式的值為false，那么結(jié)果就可以判定為false了，沒有必要將所有表達(dá)式的值都計(jì)算出來(lái)，短路與操作就有這樣的效果，可以提高效率。同理在邏輯或運(yùn)算中，一旦發(fā)現(xiàn)值為true，右邊的表達(dá)式將不再參與運(yùn)算。

• 邏輯與&，無(wú)論左邊真假，右邊都要執(zhí)行。

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

• 邏輯或|，無(wú)論左邊真假，右邊都要執(zhí)行。

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

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 兩個(gè)表達(dá)都會(huì)運(yùn)算
System.out.println(x); // 4
System.out.println(y); // 5
System.out.println((x++ > 4) && (y++ > 5)); // 左邊已經(jīng)可以確定結(jié)果為false，右邊不參與運(yùn)算
System.out.println(x); // 4
System.out.println(y); // 4

三元運(yùn)算符語(yǔ)法格式：

關(guān)系表達(dá)式 ? 表達(dá)式1 : 表達(dá)式2;

解釋：?jiǎn)柼?hào)前面的位置是判斷的條件，判斷結(jié)果為boolean型，為true時(shí)調(diào)用表達(dá)式1，為false時(shí)調(diào)用表達(dá)式2。其邏輯為：如果條件表達(dá)式成立或者滿足則執(zhí)行表達(dá)式1，否則執(zhí)行第二個(gè)。

舉例：

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

需求：

一座寺廟里住著三個(gè)和尚，已知他們的身高分別為150cm、210cm、165cm，請(qǐng)用程序?qū)崿F(xiàn)獲取這三個(gè)和尚的最高身高。

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

6. 流程控制語(yǔ)句

在一個(gè)程序執(zhí)行的過(guò)程中，各條語(yǔ)句的執(zhí)行順序?qū)Τ绦虻慕Y(jié)果是有直接影響的。所以，我們必須清楚每條語(yǔ)句的執(zhí)行流程。而且，很多時(shí)候要通過(guò)控制語(yǔ)句的執(zhí)行順序來(lái)實(shí)現(xiàn)我們想要的功能。

順序結(jié)構(gòu)

分支結(jié)構(gòu)(if, switch)

循環(huán)結(jié)構(gòu)(for, while, do…while)

順序結(jié)構(gòu)是程序中最簡(jiǎn)單最基本的流程控制，沒有特定的語(yǔ)法結(jié)構(gòu)，按照代碼的先后順序，依次執(zhí)行，程序中大多數(shù)的代碼都是這樣執(zhí)行的。

順序結(jié)構(gòu)執(zhí)行流程圖：

6.3.1 if語(yǔ)句格式1（理解）

格式：
if (關(guān)系表達(dá)式) {
    語(yǔ)句體; 
}

執(zhí)行流程：

①首先計(jì)算關(guān)系表達(dá)式的值

②如果關(guān)系表達(dá)式的值為true就執(zhí)行語(yǔ)句體

③如果關(guān)系表達(dá)式的值為false就不執(zhí)行語(yǔ)句體

④繼續(xù)執(zhí)行后面的語(yǔ)句內(nèi)容

示例：

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

6.3.2 if語(yǔ)句格式2（理解）

格式：
if (關(guān)系表達(dá)式) {
    語(yǔ)句體1; 
} else {
    語(yǔ)句體2; 
}

執(zhí)行流程：

①首先計(jì)算關(guān)系表達(dá)式的值

②如果關(guān)系表達(dá)式的值為true就執(zhí)行語(yǔ)句體1

③如果關(guān)系表達(dá)式的值為false就執(zhí)行語(yǔ)句體2

④繼續(xù)執(zhí)行后面的語(yǔ)句內(nèi)容

示例：奇偶數(shù)

任意給出一個(gè)整數(shù)，請(qǐng)用程序?qū)崿F(xiàn)判斷該整數(shù)是奇數(shù)還是偶數(shù)，并在控制臺(tái)輸出該整數(shù)是奇數(shù)還是偶數(shù)。

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

6.3.3 if語(yǔ)句格式3（理解）

格式：
if (關(guān)系表達(dá)式1) {
    語(yǔ)句體1; 
} else if (關(guān)系表達(dá)式2) {
    語(yǔ)句體2; 
} 
…
else {
    語(yǔ)句體n+1;
}

執(zhí)行流程：

①首先計(jì)算關(guān)系表達(dá)式1的值

②如果值為true就執(zhí)行語(yǔ)句體1；如果值為false就計(jì)算關(guān)系表達(dá)式2的值

③如果值為true就執(zhí)行語(yǔ)句體2；如果值為false就計(jì)算關(guān)系表達(dá)式3的值

④…

⑤如果沒有任何關(guān)系表達(dá)式為true，就執(zhí)行語(yǔ)句體n+1。

示例：

定義一個(gè)在0~100之間的變量a, 90~100優(yōu)秀，80~89良好，70~79中等，60~69及格，0~59請(qǐng)努力加油！

public class Demo3If {
 public static void main(String[] args){
  int score = 65;
  if(score >= 90 && score <= 100){
   System.out.println("優(yōu)秀");
  }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("請(qǐng)努力加油");
  }else{
   System.out.println("成績(jī)有誤!");
  }
 }
}

6.3.4 if語(yǔ)句格式3案例（應(yīng)用）

需求：小明快要期末考試了，小明爸爸對(duì)他說(shuō)，會(huì)根據(jù)他不同的考試成績(jī)，送他不同的禮物，假如你可以控制小明的得分，請(qǐng)用程序?qū)崿F(xiàn)小明到底該獲得什么樣的禮物，并在控制臺(tái)輸出。

分析：

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

②由于獎(jiǎng)勵(lì)種類較多，屬于多種判斷，采用if...else...if格式實(shí)現(xiàn)

③為每種判斷設(shè)置對(duì)應(yīng)的條件

④為每種判斷設(shè)置對(duì)應(yīng)的獎(jiǎng)勵(lì)

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

7. switch語(yǔ)句

• 格式

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

• 執(zhí)行流程：

  • 首先計(jì)算出表達(dá)式的值

  • 其次，和case依次比較，一旦有對(duì)應(yīng)的值，就會(huì)執(zhí)行相應(yīng)的語(yǔ)句，在執(zhí)行的過(guò)程中，遇到break就會(huì)結(jié) 束。

  • 最后，如果所有的case都和表達(dá)式的值不匹配，就會(huì)執(zhí)行default語(yǔ)句體部分，然后程序結(jié)束掉。

• 需求：鍵盤錄入星期數(shù)，顯示今天的減肥活動(dòng)

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

• 示例代碼：

public static void main(String[] args){
        // 1. 鍵盤錄入星期數(shù)據(jù)，使用變量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("請(qǐng)輸入");
        int week = sc.nextInt();
        // 2. 多情況判斷，采用switch語(yǔ)句實(shí)現(xiàn)
        switch(week){
            // 3. 在不同的case中，輸出對(duì)應(yīng)的減肥計(jì)劃
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("動(dòng)感單車");
                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語(yǔ)句中,case省略了break語(yǔ)句, 就會(huì)開始case穿透

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

• 示例代碼：

/*
case穿透是如何產(chǎn)生的?
        如果switch語(yǔ)句中,case省略了break語(yǔ)句, 就會(huì)開始case穿透.
        現(xiàn)象：
            當(dāng)開始case穿透，后續(xù)的case就不會(huì)具有匹配效果，內(nèi)部的語(yǔ)句都會(huì)執(zhí)行
            直到看見break，或者將整體switch語(yǔ)句執(zhí)行完畢，才會(huì)結(jié)束。
*/
public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("請(qǐng)輸入星期數(shù):");
        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循環(huán)

• 循環(huán)：

  循環(huán)語(yǔ)句可以在滿足循環(huán)條件的情況下，反復(fù)執(zhí)行某一段代碼，這段被重復(fù)執(zhí)行的代碼被稱為循環(huán)體語(yǔ)句，當(dāng)反復(fù) 執(zhí)行這個(gè)循環(huán)體時(shí)，需要在合適的時(shí)候把循環(huán)判斷條件修改為false，從而結(jié)束循環(huán)，否則循環(huán)將一直執(zhí)行下去，形 成死循環(huán)。

• for循環(huán)格式：

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

• 格式解釋：

  • 初始化語(yǔ)句： 用于表示循環(huán)開啟時(shí)的起始狀態(tài)，簡(jiǎn)單說(shuō)就是循環(huán)開始的時(shí)候什么樣

  • 條件判斷語(yǔ)句：用于表示循環(huán)反復(fù)執(zhí)行的條件，簡(jiǎn)單說(shuō)就是判斷循環(huán)是否能一直執(zhí)行下去

  • 循環(huán)體語(yǔ)句： 用于表示循環(huán)反復(fù)執(zhí)行的內(nèi)容，簡(jiǎn)單說(shuō)就是循環(huán)反復(fù)執(zhí)行的事情

  • 條件控制語(yǔ)句：用于表示循環(huán)執(zhí)行中每次變化的內(nèi)容，簡(jiǎn)單說(shuō)就是控制循環(huán)是否能執(zhí)行下去

• 執(zhí)行流程：

  ①執(zhí)行初始化語(yǔ)句

  ②執(zhí)行條件判斷語(yǔ)句，看其結(jié)果是true還是false

  如果是false，循環(huán)結(jié)束

  如果是true，繼續(xù)執(zhí)行

  ③執(zhí)行循環(huán)體語(yǔ)句

  ④執(zhí)行條件控制語(yǔ)句

  ⑤回到②繼續(xù)

• 需求：在控制臺(tái)輸出1-5和5-1的數(shù)據(jù)

• 示例代碼：

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

• 需求：求1-5之間的數(shù)據(jù)和，并把求和結(jié)果在控制臺(tái)輸出

• 示例代碼：

public class ForTest02 {
    public static void main(String[] args) {
        //求和的最終結(jié)果必須保存起來(lái)，需要定義一個(gè)變量，用于保存求和的結(jié)果，初始值為0
        int sum = 0;
        //從1開始到5結(jié)束的數(shù)據(jù)，使用循環(huán)結(jié)構(gòu)完成
        for(int i=1; i<=5; i++) {
            //將反復(fù)進(jìn)行的事情寫入循環(huán)結(jié)構(gòu)內(nèi)部
             // 此處反復(fù)進(jìn)行的事情是將數(shù)據(jù) 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;
            */
        }
        //當(dāng)循環(huán)執(zhí)行完畢時(shí)，將最終數(shù)據(jù)打印出來(lái)
        System.out.println("1-5之間的數(shù)據(jù)和是：" + sum);
    }
}

• 本題要點(diǎn)：

  • 今后遇到的需求中，如果帶有求和二字，請(qǐng)立即聯(lián)想到求和變量

  • 求和變量的定義位置，必須在循環(huán)外部，如果在循環(huán)內(nèi)部則計(jì)算出的數(shù)據(jù)將是錯(cuò)誤的

• 需求：求1-100之間的偶數(shù)和，并把求和結(jié)果在控制臺(tái)輸出 }

• 示例代碼：

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

• 需求：在控制臺(tái)輸出所有的“水仙花數(shù)”

• 解釋：什么是水仙花數(shù)？

  • 水仙花數(shù)，指的是一個(gè)三位數(shù)，個(gè)位、十位、百位的數(shù)字立方和等于原數(shù)

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

• 思路：

  1. 獲取所有的三位數(shù)，準(zhǔn)備進(jìn)行篩選，最小的三位數(shù)為100，最大的三位數(shù)為999，使用for循環(huán)獲取

  2. 獲取每一個(gè)三位數(shù)的個(gè)位，十位，百位，做if語(yǔ)句判斷是否是水仙花數(shù)

• 示例代碼

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

• 需求：在控制臺(tái)輸出所有的“水仙花數(shù)”，要求每行打印2個(gè)

• 示例代碼：

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

• 本題要點(diǎn)：

  • 今后如果需求帶有統(tǒng)計(jì)xxx，請(qǐng)先想到計(jì)數(shù)器變量

  • 計(jì)數(shù)器變量定義的位置，必須在循環(huán)外部

9. while循環(huán)

• while循環(huán)完整格式：

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

• while循環(huán)執(zhí)行流程：

  ①執(zhí)行初始化語(yǔ)句

  ②執(zhí)行條件判斷語(yǔ)句，看其結(jié)果是true還是false

  如果是false，循環(huán)結(jié)束

  如果是true，繼續(xù)執(zhí)行

  ③執(zhí)行循環(huán)體語(yǔ)句

  ④執(zhí)行條件控制語(yǔ)句

  ⑤回到②繼續(xù)

• 示例代碼：

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

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

• 示例代碼：

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

10. 循環(huán)細(xì)節(jié)

• 完整格式：

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

• 執(zhí)行流程：

  ① 執(zhí)行初始化語(yǔ)句

  ② 執(zhí)行循環(huán)體語(yǔ)句

  ③ 執(zhí)行條件控制語(yǔ)句

  ④ 執(zhí)行條件判斷語(yǔ)句，看其結(jié)果是true還是false

  如果是false，循環(huán)結(jié)束

  如果是true，繼續(xù)執(zhí)行

  ⑤ 回到②繼續(xù)

• 示例代碼：

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

• 三種循環(huán)的區(qū)別

  • for循環(huán)和while循環(huán)先判斷條件是否成立，然后決定是否執(zhí)行循環(huán)體（先判斷后執(zhí)行）

  • do...while循環(huán)先執(zhí)行一次循環(huán)體，然后判斷條件是否成立，是否繼續(xù)執(zhí)行循環(huán)體（先執(zhí)行后判斷）

• for循環(huán)和while的區(qū)別

  • 條件控制語(yǔ)句所控制的自增變量，因?yàn)闅w屬for循環(huán)的語(yǔ)法結(jié)構(gòu)中，在for循環(huán)結(jié)束后，就不能再次被訪問(wèn)到了

  • 條件控制語(yǔ)句所控制的自增變量，對(duì)于while循環(huán)來(lái)說(shuō)不歸屬其語(yǔ)法結(jié)構(gòu)中，在while循環(huán)結(jié)束后，該變量還可以繼續(xù)使用

• 死循環(huán)（無(wú)限循環(huán)）的三種格式

  1. for(;;){}

  2. while(true){}

  3. do {} while(true);

• 死循環(huán)格式

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

• 死循環(huán)案例

/*
 問(wèn)題: 死循環(huán)有應(yīng)用場(chǎng)景嗎?
    例如: 鍵盤錄入一個(gè)1-100之間的整數(shù)
    顧慮: 鍵盤錄入是用戶操作的, 用戶就可能會(huì)出現(xiàn)一些誤操作的現(xiàn)象
*/
public static void main(String[] args) {
    /*
  for(;;){
   System.out.println("我停不下來(lái)了~");
  }
  */
    /*
  while(true){
   System.out.println("我停不下來(lái)了~");
  }
  */
    do{
        System.out.println("我停不下來(lái)了~"); 
    }while(true);
    System.out.println("看看我能被執(zhí)行嗎?~"); // 無(wú)法訪問(wèn)的語(yǔ)句
}
}

• 跳轉(zhuǎn)控制語(yǔ)句（break）

  • 跳出循環(huán)，結(jié)束循環(huán)

• 跳轉(zhuǎn)控制語(yǔ)句（continue）

  • 跳過(guò)本次循環(huán)，繼續(xù)下次循環(huán)

• 注意： continue只能在循環(huán)中進(jìn)行使用！

public class Demo1Continue {
 /*
  continue : 跳過(guò)某次循環(huán)體內(nèi)容的執(zhí)行
  注意：使用是基于條件控制, 在循環(huán)內(nèi)部使用.
  需求: 模擬電梯上行的過(guò)程 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 : 終止循環(huán)體內(nèi)容的執(zhí)行
  注意：使用是基于條件控制的
    break語(yǔ)句只能在循環(huán)和switch中進(jìn)行使用.
  需求: 模擬20歲工作到80歲, 60歲退休.
 */
 public static void main(String[] args){
  for(int i = 20; i <= 80; i++){
   if(i == 60){
    break;  // 結(jié)束整個(gè)循環(huán)
   }
   System.out.println(i + "歲正在上班");
  }
 }
}

import java.util.Scanner;
public class Test {
 /*
  需求：程序運(yùn)行后，用戶可多次查詢星期對(duì)應(yīng)的減肥計(jì)劃，直到輸入0，程序結(jié)束
  步驟:
   1. 不明確用戶操作幾次, 使用死循環(huán)包裹業(yè)務(wù)邏輯
   2. 匹配到0的時(shí)候，使用break結(jié)束循環(huán)死循環(huán)
 */
 public static void main (String[] args){
  lo:while(true){
   System.out.println("請(qǐng)輸入您要查看的星期數(shù):");
   System.out.println("(如無(wú)需繼續(xù)查看,請(qǐng)輸入0退出程序)");
   // 1. 鍵盤錄入星期數(shù)據(jù)，使用變量接收
   Scanner sc = new Scanner(System.in);
   int week = sc.nextInt();
   // 2. 多情況判斷，采用switch語(yǔ)句實(shí)現(xiàn)
   switch(week){
    // 3. 在不同的case中，輸出對(duì)應(yīng)的減肥計(jì)劃
    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("動(dòng)感單車");
     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，內(nèi)部提供了產(chǎn)生隨機(jī)數(shù)的功能

    • API后續(xù)課程詳細(xì)講解，現(xiàn)在可以簡(jiǎn)單理解為Java已經(jīng)寫好的代碼

• 使用步驟：

  1. 導(dǎo)入包

     import java.util.Random;

  2. 創(chuàng)建對(duì)象

     Random r = new Random();

  3. 產(chǎn)生隨機(jī)數(shù)

     int num = r.nextInt(10);

     解釋： 10代表的是一個(gè)范圍，如果括號(hào)寫10，產(chǎn)生的隨機(jī)數(shù)就是0-9，括號(hào)寫20，參數(shù)的隨機(jī)數(shù)則是0-19

• 示例代碼：

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

• 需求：

  程序自動(dòng)生成一個(gè)1-100之間的數(shù)字，使用程序?qū)崿F(xiàn)猜出這個(gè)數(shù)字是多少？

  當(dāng)猜錯(cuò)的時(shí)候根據(jù)不同情況給出相應(yīng)的提示

  A. 如果猜的數(shù)字比真實(shí)數(shù)字大，提示你猜的數(shù)據(jù)大了

  B. 如果猜的數(shù)字比真實(shí)數(shù)字小，提示你猜的數(shù)據(jù)小了

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

• 示例代碼：

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