自學Java基礎知識第三天
課程內容
1、運算子剩餘部分
2、鍵盤錄入
3、分支結構
一、運算子剩餘部分
（一）位移運算子
1、對於在記憶體中表示的資料，按照位置來移動，以達到對資料進行運算的目的。
2、說明：Java中的位移運算子，只能對整數進行操作，最終結果依然是個整數
3、成員：
（1）<<：左移，針對整數，不論正負，每次左移1位，相當於原來的數字乘2
（2）>>：右移，針對整數，不論正負，每次右移1位，相當於原來的數字除2
（3）>>>：無符號右移，只能操作正整數，不能操作負數，運算規律和右移效果一樣
4、好處：比直接乘2或除以2效率要高很多
程式碼示例
package com.offcn.demos;
public class Demo01_Move {
public static void main(String[] args) {
int num = 10;
int num1 = -10;
System.out.println(num << 1);//符號右側的數字表示移動幾位
System.out.println(num << 2);//符號右側的數字表示移動幾位
System.out.println(num1 << 1);
System.out.println(num >> 1);
System.out.println(num >> 2);
System.out.println(num1 >> 1);
System.out.println(num >>> 1);
System.out.println(num1 >>> 1);
}
}
（二）三目運算子（三元運算子）
1、元（目）：可以操作的資料或者表示式
2、三元運算子：可以同時操作三個表示式或者資料
3、定義格式：
表示式1 ? 表示式2 : 表示式3
4、說明：
（1）表示式1，一定是一個布林表示式（邏輯表示式），即運算結果一定是布林型別的值，true或者false
（2）表示式2和表示式3：可以是任意型別的資料或者表示式
5、執行流程：
（1）執行表示式1
（2）如果表示式1返回的結果是true，就執行表示式2，執行完畢後就結束了
（3）如果表示式1返回的結果是false，就執行表示式3，執行完畢後就結束了
程式碼示例
package com.offcn.demos;
public class Demo02_TernaryOperator {
public static void main(String[] args) {
//表示式1 ? 表示式2 : 表示式3
//判斷一個數是奇數還是偶數
/*int num = 13;
String result = num % 2 == 0 ? "偶數" : "奇數";
System.out.println(result);*/
int num = 11;
System.out.println(10 > num ? "666" : 10 + 1);
}
}
（三）三目運算子的練習
有四個int型別的變數，分別是int a = 10;int b = 20; int c = 30; int d = 40;通過三目運算子進行比較，獲取四個值中的最大值。
程式碼示例
package com.offcn.demos;
/**
* 有四個int型別的變數，
* 分別是int a = 10;int b = 20; int c = 30; int d = 40;
* 通過三目運算子進行比較，獲取四個值中的最大值。
*
*/
public class Demo03_Exercise {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
int d = 40;
//1.獲取a和b中較大的那個數字
int num1 = a > b ? a : b;
//2.獲取c和d中較大的那個數字
int num2 = c > d ? c : d;
//3.從num1和num2兩個比較大的數字中得出一個最大的數
int result = num1 > num2 ? num1 : num2;
System.out.println("最大值為：" + result);
}
}
二、鍵盤錄入
（一）概述
1、在程式的執行過程中，我們有時需要將某些資料通過鍵盤輸入到計算機中，參與運算，就可以通過鍵盤錄入的方式，將資料錄入到程式。
2、步驟：
（1）導包：在類的宣告上，書寫：import java.util.Scanner;
（2）建立掃描器物件並且關聯到鍵盤：Scanner sc = new Scanner(System.in);
（3）呼叫掃描器物件的nextInt()方法，進行鍵盤錄入，注意：只能錄入int型別的資料
int num = sc.nextInt();
（4）根據你的需求，對錄入好的資料進行操作
程式碼示例
package com.offcn.demos;
//1.導包
import java.util.Scanner;
public class Demo04_Scanner {
/*
* 鍵盤錄入的功能是java官方提供好的
* 我們使用鍵盤錄入的功能需要將java官方的資源引入到我們的程式碼中
* 之後就可以進行使用了
*
* */
public static void main(String[] args) {
//2.建立掃描器物件
Scanner sc = new Scanner(System.in);//此時掃描器物件建立完畢且關聯到了鍵盤
//3.呼叫掃描器物件sc的nextInt()方法（功能），進行鍵盤錄入的掃描
int num = sc.nextInt();//此功能只能用於錄入int型別的資料，其他的資料一概不能錄入
//4.可以將錄入好的資料結合你的業務邏輯進行操作
System.out.println("您錄入的資料為:" + num);
}
}
（二）練習1
鍵盤錄入兩個整數，計算他們的和
package com.offcn.demos;
//1.導包（引入官方的資源）
import java.util.Scanner;
//鍵盤錄入兩個整數，計算他們的和
public class Demo05_Exercise1 {
public static void main(String[] args) {
//2.建立掃描器，關聯到鍵盤，用於掃描鍵盤錄入的資料
Scanner sc = new Scanner(System.in);//System.in表示關聯到了鍵盤
//3.呼叫nextInt()方法，也就是使用掃描器掃描的方法，實現鍵盤錄入int型別資料的操作
System.out.println("請錄入第一個整數：");
int num1 = sc.nextInt();
System.out.println("請錄入第二個整數：");
int num2 = sc.nextInt();
//4.計算兩數的和
System.out.println("和為：" + (num1 + num2));
}
}
（三）練習2
鍵盤錄入三個整數，輸出三個整數中的最大值
package com.offcn.demos;
//1.導包
import java.util.Scanner;
//鍵盤錄入三個整數，輸出三個整數中的最大值
public class Demo06_Exercise2 {
public static void main(String[] args) {
//2.建立掃描器物件
Scanner sc = new Scanner(System.in);
//3.呼叫nextInt()方法，錄入int型別的資料
System.out.println("請錄入第一個整數：");
int num1 = sc.nextInt();
System.out.println("請錄入第二個整數：");
int num2 = sc.nextInt();
System.out.println("請錄入第三個整數：");
int num3 = sc.nextInt();
//4.通過三目運算子來獲取三個數中的最大值
//① 先獲取三個數中任意兩個數的較大值
int num = num1 > num2 ? num1 : num2;
//② 將較大值和第三個數字進行比較，就能得到最大值
int result = num > num3 ? num : num3;
System.out.println(result);
}
}
（四）練習3
鍵盤錄入一個整數，判斷該數字是奇數還是偶數
package com.offcn.demos;
//1.導包
import java.util.Scanner;
//鍵盤錄入一個整數，判斷該數字是奇數還是偶數
public class Demo07_Exercise3 {
public static void main(String[] args) {
//2.建立掃描器物件
Scanner sc = new Scanner(System.in);
//3.呼叫nextInt()方法錄入
System.out.println("請錄入一個整數:");
int num = sc.nextInt();
//4.判斷錄入的資料是奇數還是偶數
String result = num % 2 == 0 ? "偶數" : "奇數";
System.out.println(result);
}
}
三、流程控制
1、流程：程式碼在執行中的先後順序，就是程式碼執行的流程
2、流程控制：控制程式碼執行的先後順序
3、分類：
（1）順序結構：按照從上到下從左到右的順序依次執行
（2）分支結構：程式碼執行到達某個狀態時，存在多種情況的選擇，就需要準備多種情況的分支，具體滿足哪一個分支的條件，就執行哪一個分支。特點：程式碼寫的多，執行的少。
（3）迴圈結構：在程式碼執行中，如果有一部分程式碼邏輯相同或者相似，就相當於這段程式碼和邏輯在重複執行，我們就可以使用迴圈結構，讓一句或者幾句程式碼反覆執行。
四、分支結構
（一）分支結構的概述
1、程式碼到達某種狀態時，存在多種情況，每種情況都需要提前準備好，具體執行得到什麼結果，就執行對應的分支
2、實現格式：
（1）if語句
① if
② if...else
③ if...else if...else if...else
（2）switch語句
（二）if語句的第一種格式
1、if：假如
2、定義格式：
if(邏輯表示式) {
語句體；
}
3、注意事項：
（1）if後面的小括號中，只能是邏輯表示式，即執行結果必須是布林型別，不是true就是false
（2）語句體：當條件滿足的時候，要去執行的程式碼，可以是一句，也可以是多句
4、執行流程：
（1）執行if語句小括號中的邏輯表示式
（2）邏輯表示式的執行結果為true，就執行語句體
（3）邏輯表示式的執行結果為false，不做任何操作
程式碼示例
package com.offcn.demos;
public class Demo08_IfFirstStyle {
public static void main(String[] args) {
/*
* 定義格式：
* if(邏輯表示式) {
* 語句體;
* }
*
* */
//判斷一個數是否為偶數，如果是偶數就列印"偶數"，如果是奇數就不做任何操作
int num = 11;
if(num % 2 == 0) {
System.out.println("偶數");
}
System.out.println("========");
}
}
（三）if語句體的第二種格式
1、定義格式：
if(邏輯表示式) {
語句體1;
} else {
語句體2;
}
2、說明：
（1）語句體1和語句體2是達成不同情況的時候，要執行的不同的業務邏輯
（2）else：否則，關鍵字，表示出了if中情況以外的情況都需要執行
3、執行流程：
（1）執行邏輯表示式
（2）如果邏輯表示式返回true，就執行語句體1
（3）如果邏輯表示式返回false，就執行語句體2
4、注意事項：
（1）會不會有任何一個語句體都不執行的情況？不會。達成條件，即返回true，就執行語句體1，返回false，就執行語句體2
（2）會不會兩條語句都執行？不會。因為達成某種情況，就去執行某個語句體，該格式中，勢必會執行一個語句體，執行完後，整個if會全部結束，不會再去執行額外的語句體。
程式碼示例
package com.offcn.demos;
public class Demo09_IfSecondStyle {
public static void main(String[] args) {
//判斷一個數字是奇數還是偶數，如果是偶數就列印偶數，如果是奇數就列印奇數
int num = 11;
if(num % 2 == 0) {
System.out.println("偶數");
} else {
System.out.println("奇數");
}
System.out.println("=========");
}
}
（四）if語句的第三種格式
1、定義格式：
if(邏輯表示式1) {
語句體1;
} else if(邏輯表示式2) {
語句體2;
} else if(邏輯表示式3) {
語句體3;
}
....
} else if(邏輯表示式n) {
語句體n;
} else {
語句體n+1;
}
2、執行流程：
（1）執行邏輯表示式1，如果返回true，就執行語句體1，執行完畢後整個if都會結束
（2）如果執行邏輯表示式1，返回false，則按照從上到下的順序，一次執行邏輯表示式2到邏輯表示式n
（3）如果某一個邏輯表示式返回true，則執行其對應的語句體，執行完畢後整個if語句體都會結束
（4）如果所有的邏輯表示式都返回false，則執行else中的語句體n+1
程式碼示例
package com.offcn.demos;
//1.導包
import java.util.Scanner;
public class Demo10_IfThirdStyle {
public static void main(String[] args) {
//2.建立掃描器物件
Scanner sc = new Scanner(System.in);
//3.鍵盤錄入
System.out.println("老爺，時間不早了，該歇息了：");
int num = sc.nextInt();
if(num == 1) {
System.out.println("正宮夫人伺候老爺就就寢。。。");
} else if(num == 2) {
System.out.println("趙夫人伺候老爺就就寢。。。");
} else if(num == 3) {
System.out.println("錢夫人伺候老爺就就寢。。。");
} else if(num == 4) {
System.out.println("孫夫人伺候老爺就就寢。。。");
} else if(num == 5) {
System.out.println("李夫人伺候老爺就就寢。。。");
} else {
System.out.println("隨便找個好看的丫鬟吧。。。");
}
}
}
（五）if語句的注意事項
1、if後面的小括號裡，一定是邏輯表示式
2、if語句的小括號後面，不能隨便寫分號，如果加上分號，就將if判斷和語句體分割開了
3、if語句體只有一句的時候，可以省略大括號，如果為多句，不能省略大括號
程式碼示例
package com.offcn.demos;
public class Demo11_Notice {
public static void main(String[] args) {
int num = 11;
/*if(num++) {
}*/
/*if(num % 2 == 0); {
System.out.println("遙想公瑾當年，小喬初嫁了，使我不得開心顏。");
}*/
if(num % 2 == 0)
System.out.println("遙想公瑾當年，小喬初嫁了，使我不得開心顏。");
System.out.println("垂死病中驚坐起，談笑風生又一年");
}
}
（六）if語句的細節
package com.offcn.demos;
public class Demo12_Exercise {
public static void main(String[] args) {
int i = 10;
int j;
/*if(i < 0) {
j = 11;
} else if(i >=0 && i <= 100) {//在java程式碼中表示一個區間按照當前寫法書寫，不能寫成 0 <= i <= 100
j = 111;
} else if(i > 100) {
j = 1111;
}*/
/*if(i < 0) {
j = 11;
} else if(i >=0 && i <= 100) {//在java程式碼中表示一個區間按照當前寫法書寫，不能寫成 0 <= i <= 100
j = 111;
} else if(i > 100) {
j = 1111;
} else {
j = 0;
}*/
if(i < 0) {
j = 11;
} else if(i >=0 && i <= 100) {//在java程式碼中表示一個區間按照當前寫法書寫，不能寫成 0 <= i <= 100
j = 111;
} else {
j = 1111;
}
/*
* java程式碼需要先編譯後執行
*
* 所以，分為了編譯期和執行期
*
* java程式碼的編譯期，不檢測任何的邏輯，只檢測語法，大部分時候只是將人了語言寫成的程式碼編譯為機器能看懂的語言
*
* 真正檢查邏輯的時間是在程式碼執行期
*
* 我們此時出現的語法錯誤是屬於編譯期的錯誤：變數j沒有賦值，也就是違背了我們變數先賦值後使用的原則
*
* 雖然我們看似本段程式碼邏輯沒有遺漏，但是現在屬於編譯期，不檢測邏輯，只檢視語法，
* 編譯器認為，我們只有三個條件，如果三個條件都不滿足，j就無法被賦值
*
* 就算我們的邏輯沒有遺漏，也需要到執行期才能被執行，但是此時編譯都無法通過，就談不上執行
* */
System.out.println(j);
}
}
（七）switch語句
1、switch，關鍵字，意義：開關。switch語句中，有多種情況，每一種情況都像是一扇門，如果匹配到，門就打開了就可以去執行，如果沒有匹配到就不執行。
2、定義格式：
switch(表示式) {
case 常量1:
語句體1;
break;
case 常量2:
語句體2;
break;
case 常量3:
語句體3;
break;
......
case 常量n:
語句體n;
break;
default:
語句體n+1;
break;
}
3、執行流程：
（1）執行表示式
（2）將表示式和每一個case去按照從上到下的順序匹配
（3）如果匹配到某一個case，就去執行case中對應的語句體
（4）語句體執行完畢後，執行break;語句，結束整個switch
（5）如果所有的case都匹配不到，就會進入default中，執行default的語句體，執行完畢後，執行break;語句結束整個switch（defualt中可以不加break;，當defualt的語句體執行完畢的時候，遇到右大括號，也會結束整個switch）
程式碼示例
package com.offcn.demos;
import java.util.Scanner;
//鍵盤錄入一個int數字，輸出對應是星期幾的漢字
public class Demo13_switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請錄入一個數字：");
int num = sc.nextInt();
switch(num) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("輸入有誤，地球上沒這個日子");
//break;
}
System.out.println("==========");
}
}
（八）switch語句的注意事項
1、switch：開關，case：情況，break：破壞，default：預設
2、表示式：
（1）JDK1.5之前：byte、short、char、int
（2）JDK1.5：列舉型別
（3）JDK1.5之後：String
3、case後面只能跟常量，不能跟變數
4、switch語句的結束標誌：遇到break語句或者遇到右大括號
5、case穿透：case中語句體執行完畢後如果有break，就會將整個switch語句結束掉，如果case中沒有break語句，則會繼續向下執行下一個case的語句體，直到遇見第一個break;語句結束，或者遇到switch的右大括號結束
6、default語句可以寫在任意位置，都會最後才去執行，但是一般情況下，最好還是將deaflt語句寫在最後。另外，default語句可以省略不寫，不寫就不執行。
程式碼示例
package com.offcn.demos;
import java.util.Scanner;
public class Demo14_Notice {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請錄入一個數字：");
int num = sc.nextInt();
/*
* case穿透
* case中語句體執行完畢後如果有break，就會將整個switch語句結束掉
* 如果case中沒有break語句，則會繼續向下執行下一個case的語句體，
* 直到遇見第一個break;語句結束，或者遇到switch的右大括號結束
*
*
* */
switch(num) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
/*default:
System.out.println("輸入有誤，地球上沒這個日子");
//break;*/
}
/*int b = 1;
byte by = 6;
switch (b) {
case 1:
case 'z':
//case by:
}*/
/*short s = 3;
switch (s) {
}
char ch = 'z';
switch (ch) {
}*/
/*double dou = 3.5;
switch (dou) {
}*/
/*String str = "abc";
switch (str) {
}*/
}
}
（九）switch語句的練習
鍵盤錄入一個數字，表示月份，列印對應的季節
3、4、5表示春季，6、7、8表示夏季、9、10、11表示秋季，12、1、2表示冬季
程式碼示例
package com.offcn.demos;
import java.util.Scanner;
/**
* 鍵盤錄入一個數字，表示月份，列印對應的季節
3、4、5表示春季，6、7、8表示夏季、9、10、11表示秋季，12、1、2表示冬季
*
*/
public class Demo15_Exercise {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請錄入月份：");
int month = sc.nextInt();
switch(month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("地球上沒有這個月份！");
}
}
}
五、迴圈結構
（一）概述
1、對於某些需要重複執行的相同的、相似的或者相近的程式碼，使用某種個是來讓其重複執行，完成對程式碼的簡化。
2、迴圈結構：
for迴圈【常用】
while迴圈【常用】
do...while迴圈
（二）for迴圈
1、定義格式：
for(初始化變數; 邏輯表示式; 步進表示式) {
迴圈語句體；（需要重複執行的程式碼）
}
2、執行流程：
（1）執行初始化變數，有且僅有一次執行機會。初始化變數具有初始值，初始化變數就是用來最終記錄我們一件事兒完成了多少次的計數器。
（2）執行邏輯表示式，判斷當前迴圈次數，是否達到目標，如果返回true，即沒有達到目標，就執行迴圈語句體。
（3）如果邏輯表示式返回false，直接結束for迴圈
（4）接步驟2，迴圈語句體執行完畢後，會執行步進表示式，在初始化變數上，進行已經迴圈次數的增減
（5）再次執行邏輯表示式，判斷是否打成目標，如果邏輯表示式返回false，就停止迴圈，如果返回true，就繼續迴圈
3、執行流程圖：
4、說明：
（1）初始化語句有且僅有一次執行機會，在最開始執行
（2）邏輯表示式：結果必須是布林型別，返回true則執行迴圈語句體，返回false直接結束for迴圈
（3）迴圈語句體：要重複執行的程式碼，可以是一句，也可以是多句
（4）步進表示式：可以是增，可以是減，每次增減的幅度，可以根據業務邏輯來定
程式碼示例
package com.offcn.demos;
public class Demo16 {
public static void main(String[] args) {
/*
* 跑圈是重複的事情
*
* 需要使用一個計數器來記錄已經重複做了多少遍：初始化變數
*
* 我們重複做一件事情，是有遍數的，例如跑10圈，就是將跑圈重複10次，如果沒打成目標就繼續重複，打成了就結束：邏輯表示式
*
* 每次跑圈跑完一圈，就要在已經跑的基礎上，加上1圈：初始化變數的自增自減（步進表示式）
*
* for(初始化變數; 邏輯表示式; 步進表示式) {
* 迴圈語句體;(需要重複執行的程式碼)
* }
* */
//列印90-100的數字
for(int i = 90; i <= 100; i = i + 2) {
System.out.println(i);
}
/*for(int i = 1; i <= 10; i++) {
System.out.println("HelloWorld!");
}*/
/*System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");*/
}
}
（三）for迴圈的注意事項
1、初始化變數必須是變數，用於記錄迴圈次數的，在迴圈的最開始執行，有且僅有一次執行機會
2、邏輯表示式：結果必須是布林型別，返回true則執行迴圈語句體，返回false直接結束for迴圈
3、迴圈語句體：要重複執行的程式碼，可以是一句，也可以是多句
4、步進表示式：可以是增，可以是減，每次增減的幅度，可以根據業務邏輯來定
5、for迴圈的小括號後面不能加分號
6、當且僅當迴圈語句提只有一句的時候，for迴圈的大括號可以省略
程式碼示例
package com.offcn.demos;
public class Demo17_ForNotice {
public static void main(String[] args) {
/*for(int i = 1; i <= 10; i++);
{
System.out.println("HelloWorld!");
}*/
for(int i = 1; i <= 10; i++)
System.out.println("HelloWorld!");
System.out.println("=======");
}
}
（四）練習1
列印1到10的數字
程式碼示例
package com.offcn.demos;
//列印1到10的數字
public class Demo18_Exercise1 {
public static void main(String[] args) {
for(int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
}
（五）練習2
計算1+2+3+...+98+99+100的和
程式碼示例
package com.offcn.demos;
//計算1+2+3+...+98+99+100的和
public class Demo19_Exercise2 {
public static void main(String[] args) {
//定義一個計數器，用於記錄1-100的和
int sum = 0;//6
for(int i = 1; i <= 100; i++) {
//sum = sum + i;
sum += i;
}
System.out.println(sum);
}
}
（六）練習3
計算1-100的偶數和
程式碼示例
package com.offcn.demos;
//計算1-100的偶數和
public class Demo20_Exercise3 {
public static void main(String[] args) {
int sum = 0;
/*for(int i = 1; i <= 100; i++) {
if(i % 2 == 0) {
sum += i;
}
}*/
for(int i = 2; i <= 100; i += 2) {
sum += i;
}
System.out.println(sum);
}
}
（七）練習4
列印四葉玫瑰數及其個數。四葉玫瑰數：是一個四位數，它的各個位的四次方和等於它本身。
程式碼示例
package com.offcn.demos;
//列印四葉玫瑰數及其個數。四葉玫瑰數：是一個四位數，它的各個位的四次方和等於它本身。
public class Demo21_Exercise4 {
public static void main(String[] args) {
//定義計數器，用於記錄四葉玫瑰數的個數
int count = 0;
//通過for迴圈，獲取到每一個四位數
for(int i = 1000; i < 10000; i++) {
//將當前迴圈得到的四位數的各個位獲取下來
int unit = i % 10;
int ten = i / 10 % 10;
int hundred = i / 100 % 10;
int thousand = i / 1000;
//求每個位的四次方，之後加和
int sum = unit * unit * unit * unit +
ten * ten * ten * ten +
hundred * hundred * hundred * hundred +
thousand * thousand * thousand * thousand;
//四次方和等於它本身
if(sum == i) {
System.out.println(i);
count++;
}
}
System.out.println("四葉玫瑰數的個數位：" + count);
}
}
（八）while迴圈
1、定義格式：
初始化變數；
while(邏輯表示式) {
迴圈語句體；
步進表示式；
}
2、執行流程
（1）執行初始化變數
（2）執行邏輯表示式，如果判斷為true，就執行while迴圈的迴圈語句體，如果判斷為false，就結束while迴圈
（3）假設邏輯表示式為true，會執行迴圈語句體，迴圈語句體執行完畢後，執行步進表示式
（4）步進表示式執行完畢，重新執行步驟（2）
程式碼示例
package com.offcn.demos;
public class Demo22_while {
public static void main(String[] args) {
//列印1-10的數字，橫向列印，並且數字之間用空格隔開
//System.out.print();列印的時候不換行
//System.out.println();列印的時候換行
//特別的如果直接執行System.out.println();是會直接進行換行操作的
int i = 1;
while(i <= 10) {
System.out.print(i + " ");
i++;
}
}
}
（九）while迴圈的練習
使用while迴圈，列印1-100範圍內有多少數字可以被7整除
程式碼示例
package com.offcn.demos;
//使用while迴圈，列印1-100範圍內有多少數字可以被7整除(7的倍數)
public class Demo23_Exercise {
public static void main(String[] args) {
/*for(int i = 1; i <= 100; i++) {
System.out.println(i);
}*/
/*
* 初始化變數;
*
* while(邏輯表示式) {
* 迴圈語句體;
* 步進表示式;
* }
*
* */
//定義計數器用於記錄個數
int count = 0;
int i = 1;
while(i <= 100) {
if(i % 7 == 0) {
System.out.println(i);
count++;
}
i++;
}
System.out.println("7的倍數的個數位：" + count);
}
}