你需要的是什麼，直接評論留言。
學習交流請加java幫幫交流qq群553841695
分享是一種美德，分享更快樂！
1:switch語句(掌握)
(1)格式：
switch(表達式) {
case 值1:
語句體1;
break;
case 值2:
語句體2;
...
default:
語句體n+1;
}
格式解釋說明：
switch:說明這是switch語句。
表達式:可以是byte,short,int,char
jdk5以後可以是枚舉
jdk7以後可以是字元串
case:後面的值就是要和表達式進行比較的值
break:表示程式到這裡中斷，跳出switch語句
default:如果所有的情況都不比對,就執行這裡,相當于if語句中的else
(2)面試題
switch語句的表達式可以是byte嗎?可以是long嗎?可以是string嗎?
可以,不可以,jdk7以後可以
(3)執行流程:
a:首先計算表達式的值
b:和每一個case進行比對，如果有就執行對應的語句體，看到break就結束。
c:如果沒有比對，就執行default的語句體n+1。
(4)注意事項:
a:case後面隻能是常量，不能是變量，而且，多個case後面的值不能出現相同的
b:default可以省略嗎?
可以省略，但是不建議，因為它的作用是對不正确的情況給出提示。
特殊情況：
case就可以把值固定。
a,b,c,d
c:break可以省略嗎?
可以省略，但是結果可能不是我們想要的。
會出現一個現象：case穿透。
最終我們建議不要省略
d:default一定要在最後嗎?
不是，可以在任意位置。但是建議在最後。
e:switch語句的結束條件
a:遇到break就結束了
b:執行到末尾就結束了
import java.util.scanner;
class switchdemo2 {
public static void main(string[] args) {
//建立鍵盤錄入對象
scanner sc = new scanner(system.in);
//控制鍵盤錄入資料
system.out.println("請輸入一個資料(1-7):");
int week = sc.nextint(); //3
//定義常量
//int number = 3;
//然後把case後面的值改為number，就會報錯
//switch判斷語句
switch(week) {
case 1:
system.out.println("星期一");
case 2:
system.out.println("星期二");
case 3:
system.out.println("星期三");
case 4:
system.out.println("星期四");
case 5:
system.out.println("星期五");
case 6:
system.out.println("星期六");
case 7:
system.out.println("星期日");
system.out.println("你輸入的資料有誤");
//break;
(5)案例：
a:鍵盤錄入一個數字(1-7),輸出對應的星期幾。
b:單項選擇題
c:鍵盤錄入一個字元串的問題
string s = sc.nextline();
d:根據給定的月份,案例：
/* a：
鍵盤錄入一個資料，根據這個資料，我們輸出對應的星期?
鍵盤錄入1,對應輸出星期一
鍵盤錄入2,對應輸出星期二
鍵盤錄入7,對應輸出星期日
分析：
1:鍵盤錄入，用scanner實作
2:判斷我們既可以使用if語句，也可以使用我們要講解的switch語句
注意：
a:遇到左大括号縮進一個tab的位置。
b:關聯不是很大的語句間空行
*/
class switchdemo {
/* b:
模拟單項選擇題。
a:出一個選擇題，然後供你選擇。
b:鍵盤錄入選擇的資料。
c:根據選擇來給出你選擇的結論。
class switchtest2 {
//出一個選擇題，然後供你選擇。
//由于我們現在沒有辦法鍵盤錄入得到一個'a','b'
//這樣的東西，我就用65，66這樣的值替代
//将來我們擷取到這樣的值以後，強制轉換為字元類型
system.out.println("下面的幾個人你最愛誰?");
system.out.println("65 林青霞");
system.out.println("66 張曼玉");
system.out.println("67 劉德華");
system.out.println("68 王力宏");
//鍵盤錄入選擇的資料。
system.out.println("請輸入你的選擇：");
int choicenumber = sc.nextint();
//強制轉換為字元類型
char choice = (char) choicenumber;
switch(choice) {
case 'a':
system.out.println("恭喜你,選擇正确");
case 'b':
system.out.println("不好意思，你選擇有誤");
case 'c':
case 'd':
system.out.println("沒有該選項");
/* c:
根據你鍵盤錄入的字元串，判斷是否有滿足要求的，如果有就輸出。
否則，提示有誤。
class switchtest3 {
//錄入資料
system.out.println("請輸入你要判斷的字元串：");
switch(s) {
case "hello":
system.out.println("你輸入的是hello");
case "world":
system.out.println("你輸入的是world");
case "java":
system.out.println("你輸入的是java");
system.out.println("沒有找到你輸入的資料");
/* d:
用switch語句實作鍵盤錄入月份，輸出對應的季節
a:鍵盤錄入一個月份，用scanner實作
b:用switch語句實作即可
if語句和switch語句的差別?
if語句：
a:針對結果是boolean類型的判斷
b:針對一個範圍的判斷
c:針對幾個常量值的判斷
switch語句：
針對幾個常量值的判斷
class switchtest4 {
system.out.println("請輸入月份(1-12)：");
int month = sc.nextint();
/*
switch(month) {
system.out.println("冬季");
system.out.println("春季");
system.out.println("夏季");
case 8:
case 9:
system.out.println("秋季");
case 10:
case 11:
case 12:
system.out.println("你輸入的月份有誤");
//這樣寫太麻煩了，我們使用一個我們不想使用的東西：case穿透
擴充
看程式寫結果
class switchtest {
int x = 2;
int y = 3;
switch(x){
y++;
system.out.println("y="+y);
system.out.println("---------------");
int a = 2;
int b = 3;
switch(a){
b++;
system.out.println("b="+b);
(6)if語句和switch語句各自的場景
a:if
針對boolean類型的判斷
針對一個範圍的判斷
針對幾個常量的判斷
b:switch
2:循環語句(掌握)
(1)有三種:for,while,do...while
(2)for循環語句
a:格式
for(初始化語句;判斷條件語句;控制條件語句){
循環體語句;
執行流程：
a:執行初始化語句
b:執行判斷條件語句
如果這裡是true，就繼續
如果這裡是false，循環就結束
c:執行循環體語句
d:執行控制條件語句
e:回到b
b:注意事項
a:判斷條件語句無論簡單還是複雜，結果是boolean類型
b:循環體語句如果是一條，可以省略大括号，但是不建議
c:有分号就沒有左大括号，有左大括号就沒有分号
c:案例
a:輸出10次helloworld
b:輸出1-10的資料
c:輸出10-1的資料
d:求1-10的和
e:求1-100的和,求1-100的偶數和,求1-100的奇數和
f:求5的階乘
g:在控制台列印水仙花數
h:統計水仙花個數
i:改進版的回文數
一個五位數
個位 = 萬位
十位 = 千位
個位 + 十位 + 千位 + 萬位 = 百位
j:統計1-1000之間同時滿足如下條件的資料有多少個
x%3==2
x%5==3
x%7==2
/* a:
循環語句：for循環,while循環,do...while循環。
for循環格式：
for(初始化語句;判斷條件語句;控制條件語句) {
b:執行判斷條件語句,看其傳回值是true還是false
如果是true，就繼續執行
如果是false，就結束循環
c:執行循環體語句;
e:回到b繼續。
注意事項：
a:判斷條件語句無論簡單還是複雜結果是boolean類型。
b:循環體語句如果是一條語句，大括号可以省略；如果是多條語句，大括号不能省略。建議永遠不要省略。
c:一般來說：有左大括号就沒有分号，有分号就沒有左大括号
需求：請在控制台輸出10次"helloworld"
class fordemo {
//最原始的做法
system.out.println("helloworld");
system.out.println("----------");
//這種做法不好,代碼的重複度太高。
//是以呢，我們用循環改進
for(int x=1;x<=10;x++) {
需求：請在控制台輸出資料1-10
class fordemo2 {
//原始做法
system.out.println(1);
system.out.println(2);
system.out.println(3);
system.out.println(4);
system.out.println(5);
system.out.println(6);
system.out.println(7);
system.out.println(8);
system.out.println(9);
system.out.println(10);
system.out.println("-------------");
//如何改進呢?用循環改進
for(int x=1; x<=10; x++) {
system.out.println(x);
//從0開始
for(int x=0; x<10; x++) {
system.out.println(x+1);
需求：求出1-10之間資料之和
0+1=1
1+2=3
3+3=6
6+4=10
10+5=15
由此可見我們要定義兩個變量：
一個變量用于存儲第一個加數，第一個加數其實儲存的是以前的所有資料和。預設初始化值應該是0。
一個變量用于存儲第二個加數，第二個加數其實就是每次的資料變化的值。
求和思想。
class fordemo3 {
system.out.println(1+2+3+4+5+6+7+8+9+10);
//定義第一個加數
int sum = 0;
//這裡的x其實是第二個加數
sum = sum + x;
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
//sum += x;
system.out.println("sum:"+sum);
/* e:
需求：
a:求1-100之和。
b:求出1-100之間偶數和
c:求出1-100之間奇數和(自己做)
class fordemo4 {
//求1-100之和。
int sum1 = 0;
for(int x=1; x<=100; x++) {
sum1 +=x;
system.out.println("1-100之和是："+sum1);
system.out.println("------------------");
//求出1-100之間偶數和
//方式1
int sum2 = 0;
if(x%2 == 0) {
sum2 += x;
system.out.println("1-100偶數之和是："+sum2);
//方式2
int sum3 = 0;
for(int x=0; x<=100; x+=2) {
sum3 += x;
system.out.println("1-100偶數之和是："+sum3);
/* f:
需求：求5的階乘。
什麼是階乘呢?
n! = n*(n-1)! 規則
n! = n*(n-1)*(n-2)*...*3*2*1
求階乘思想。
class fordemo5 {
//定義最終結果變量
int jc = 1;
//這裡的x其實可以直接從2開始
//for(int x=1; x<=5; x++)
for(int x=2; x<=5; x++) {
jc *=x;
system.out.println("1-5的階乘是："+jc);
/* g:
天将降大任于斯人也,必先盜其qq,封其微網誌,收其wifi,奪其手機。讓其靜心學習java歐耶。
需求：在控制台輸出所有的”水仙花數”
我們都不知道什麼叫"水仙花數"，你讓我怎麼做呢?
所謂的水仙花數是指一個三位數，其各位數字的立方和等于該數本身。
舉例：153就是一個水仙花數。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
a:三位數其實是告訴了我們範圍。
b:通過for循環我們就可以實作擷取每一個三位數
但是麻煩是如何擷取這個三位數的個,十,百位上的資料
我們如何擷取一個資料的個,十,百呢?
假設有個一個資料:153
ge: 153%10 = 3
shi: 153/10%10 = 5
bai：153/10/10%10 = 1
qian：x/10/10/10%10
wan: x/10/10/10/10%10
c:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該資料比較
如果相同，就把該資料在控制台輸出。
class fordemo6 {
//三位數其實是告訴了我們範圍。
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該資料比較
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果相同，就把該資料在控制台輸出。
/* h:
需求：統計”水仙花數”共有多少個
a:首先必須知道什麼是水仙花數
b:定義統計變量，初始化值是0
c:三位數告訴了我們範圍，用for循環就可以搞定
d:擷取每一個三位數的個，十，百的資料
e:按照要求進行判斷
f:如果滿足要求就計數。
class fordemo8 {
//定義統計變量，初始化值是0
int count = 0;
//三位數告訴了我們範圍，用for循環就可以搞定
//擷取每一個三位數的個，十，百的資料
//按照要求進行判斷
//如果滿足要求就計數。
count++;
system.out.println("水仙花數共有"+count+"個");
/* i：
練習：
請在控制台輸出滿足如下條件的五位數
個位等于萬位
十位等于千位
個位+十位+千位+萬位=百位
a:五位數就告訴了我們範圍。
b:分解每一個五位數的個，十，百，千，萬位上的資料
c:按照要求進行判斷即可
class fordemo7 {
//五位數就告訴了我們範圍。
for(int x=10000; x<100000; x++) {
//分解每一個五位數的個，十，百，千，萬位上的資料
int bai = x/10/10%10;
int qian = x/10/10/10%10;
int wan = x/10/10/10/10%10;
//按照要求進行判斷即可
if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
/* j:
需求：請統計1-1000之間同時滿足如下條件的資料有多少個：
對3整除餘2
對5整除餘3
對7整除餘2
a:定義統計變量,初始化值是0
b:1-1000之間是一個範圍，用for很容易就可以實作。
c:每個資料要同時滿足如下要求
d:如果滿足條件，統計資料++即可，最後輸出統計變量
class fordemo9 {
//定義統計變量,初始化值是0
//1-1000之間是一個範圍，用for很容易就可以實作。
for(int x=1; x<=1000; x++) {
每個資料要同時滿足如下要求
if(x%3==2 && x%5==3 && x%7==2) {
//輸出資料
system.out.println("滿足這樣條件的資料共有："+count+"個");
(3)while循環
a:基本格式
while(判斷條件語句) {
擴充格式：
初始化語句;
while(判斷條件語句){
控制條件語句;
通過檢視這個格式，我們就知道while循環可以和for循環等價轉換。
while循環的基本格式：
while(判斷條件語句) {
通過這個格式，我們就可以看到其實和for循環是差不多的。
class whiledemo {
//輸出10次"helloworld"
//for語句版
system.out.println("--------------");
//while語句版
int x=0;
while(x<10) {
x++;
b:while的練習
把for語句的練習用while改進
練習：用while循環實作
左邊：求出1-100之和
右邊：統計水仙花數有多少個
class whiledemo2 {
//求出1-100之和
//for語句版本
sum+=x;
system.out.println("--------");
//while語句版本
int y=1;
while(y<=100) {
sum2+=y;
system.out.println("sum2:"+sum2);
需求：統計水仙花數有多少個
class whiledemo3 {
//for循環版本
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
system.out.println("count:"+count);
system.out.println("------------");
//while循環版本
int count2 = 0;
int y = 100;
while(y<1000) {
int ge = y%10;
int shi = y/10%10;
int bai = y/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
count2++;
system.out.println("count2:"+count2);
c:for和while的差別
a:使用上的差別
for語句的那個控制條件變量,在循環結束後不能在使用了。
而while的可以繼續使用。
b:了解上的差別
for适合于一個範圍的判斷
while适合次數不明确的
舉例:吃葡萄
while循環和for循環的差別?
使用差別：如果你想在循環結束後，繼續使用控制條件的那個變量，用while循環，否則用for循環。不知道用for循環。
因為變量及早的從記憶體中消失，可以提高記憶體的使用效率。
其實還有一種場景的了解:
如果是一個範圍的，用for循環非常明确。
如果是不明确要做多少次，用while循環較為合适。
舉例：吃葡萄。
class whiledemo4 {
//for循環實作
system.out.println("學習java技術哪家強,中國北京傳智播客");
//這裡不能在繼續通路了
//system.out.println(x);
//while循環實作
int y = 0;
while(y<10) {
//這裡是可以繼續通路的
system.out.println(y);
}
d:案例：
a:珠穆朗瑪峰問題
b:小芳存錢問題(break以後才能做)
我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。
請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
a:定義一個統計變量，預設值是0
b:最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
c:我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
折疊一次有什麼變化呢?就是厚度是以前的2倍。
d:隻要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
e:輸出統計變量。
class whiledemo5 {
//定義一個統計變量，預設值是0
//最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
//我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
//為了簡單，我把0.01變成1，同理8848就變成了884800
int end = 884800;
int start = 1;
while(start<end) {
//隻要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
//折疊一次有什麼變化呢?就是厚度是以前的2倍。
start *= 2;
system.out.println("第"+count+"次厚度是"+start);
//輸出統計變量。
system.out.println("要疊"+count+"次");
需求：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，
每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
請問，經過多少天，小芳才可以存到100元錢。
a:小芳的媽媽每天給她2.5元錢
double daymoney = 2.5;
b:她都會存起來
double daysum = 0;
c:從第一天開始存儲
int daycount = 1;
d:經過多少天，小芳才可以存到100元錢。
double result = 100;
e:這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
說明要判斷daycount的值，如果對5整除就減去6元錢。
daysum -= 6;
由此還隐含了一個問題，就是如果不是5的倍數天的話，錢要累加
daysum += daymoney;
f:因為不知道是多少天，是以我用死循環，一旦超過100元我就退出循環。
//每天要存儲的錢是2.5元
//存錢的初始化值是0
//從第一天開始存儲
//最終存儲不小于100就不存儲了
int result = 100;
//因為不知道是多少天，是以我用死循環，
while(true) {
//累加錢
//一旦超過100元我就退出循環。
if(daysum >= result) {
system.out.println("共花了"+daycount+"天存儲了100元");
if(daycount%5 == 0) {
//花去6元錢
system.out.println("第"+daycount+"天花了6元錢");
//天數變化
daycount++;
(4)do...while循環
do {
}while(判斷條件語句);
通過檢視格式，我們就可以看出其實三種循環的格式可以是統一的。
do...while循環的基本格式：
擴充格式；
class dowhiledemo {
//輸出10次helloworld。
int x = 0;
}while(x<10);
//求和1-100
int a = 1;
sum += a;
a++;
}while(a<=100);
system.out.println(sum);
b:三種循環的差別
a:do...while循環至少執行一次循環體
b:for和while必須先判斷條件是否是true，然後後才能決定是否執行循環體
循環語句的差別:
do...while循環至少執行一次循環體。
而for,while循環必須先判斷條件是否成立，然後決定是否執行循環體語句。
那麼，我們一般使用哪種循環呢?
優先考慮for，其次考慮while，最後考慮do...while
class dowhiledemo2 {
int x = 3;
while(x < 3) {
system.out.println("我愛林青霞");
}while(y < 3);
(5)循環使用的注意事項(死循環)
a:一定要注意修改控制條件,否則容易出現死循環。
b:最簡單的死循環格式
a:while(true){...}
b:for(;;){}
注意死循環：
a:一定要注意控制條件語句控制的那個變量的問題，不要弄丢了，否則就容易死循環。
b:兩種最簡單的死循環格式
while(true){...}
for(;;){...}
class dowhiledemo3 {
while(x < 10) {
system.out.println("今天我很高興，學習了死循環");
for(;;){
//system.out.println("--------------");
(6)循環嵌套
需求：請輸出一個4行5列的星星(*)圖案。
結果：
*****
循環嵌套：就是循環語句的循環體本身是一個循環語句。
通過結果我們知道這樣的一個結論：
外循環控制行數
内循環控制列數
class forfordemo {
system.out.println("*****");
//雖然可以完成需求，但是不是很好
//如果是多行多列就會比較麻煩
//是以我們準備改進
//如何改進呢?
//我先考慮如何實作一行*的問題
//system.out.println("*****");
//我們要想的是如何實作一次輸出一顆*的問題
//system.out.println("*");
//現在雖然可以一次一顆*，但是卻換行了，我要求不能換行，怎麼辦呢?
//輸出語句的另一種格式：system.out.print(); 這個是不帶換行的
//system.out.print("*");
//如果我要在一行上打出多顆*，比較麻煩，而代碼是重複的，是以我決定用循環改進
for(int x=0; x<5; x++) {
system.out.print("*");
//我們可以通過空的輸出語句實作換行：system.out.println();
system.out.println();
//既然我可以打出一行，我就可以打出第二行
//同理打出第三行，第四行
system.out.println("-----------------");
//同樣的代碼出現了4次，說明我們程式寫的不好，用循環改進
for(int y=0; y<4; y++) {
需求：請輸出下列的形狀
*
**
***
****
class forfordemo2 {
//通過簡單的觀察，我們看到這是一個行是5，列數是變化的形狀
//我們先列印出一個5行5列的形狀
for(int y=0; y<5; y++) {
//我們實作了一個5行5列的形狀
//但是這不是我們想要的
//我們要的是列數變化的
//列數是如何變化的呢?
//第一行：1列
y=0,y<=0,y++
//第二行：2列
y=0,y<=1,y++
//第三行：3列
y=0,y<=2,y++
//第四行：4列
y=0,y<=3,y++
//第五行：5列
y=0,y<=4,y++
//在看外循環x的變化，恰好就是x=0,1,2,3,4
//是以這個最終版的程式就是如下
for(int y=0; y<=x; y++) {
需求：在控制台輸出九九乘法表。
首先我們寫出九九乘法表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6
3*3=9
1*4=4 2*4=8
3*4=12 4*4=16
1*9=9 2*9=18
3*9=27 ...
我們先把這個九九乘法表看出是這樣的一個形狀：
******
*******
********
*********
'\x' x表示任意，這種做法叫轉移字元。
'\t' tab鍵的位置
'\r' 回車
'\n' 換行
class forfordemo3 {
for(int x=0; x<9; x++) {
//為了使用資料，我們從1開始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
system.out.print(y+"*"+x+"="+y*x+"\t");
3:控制跳轉語句(掌握)
(1)break:中斷的意思
a:用在循環和switch語句中，離開此應用場景無意義。
b:作用
a:跳出單層循環
b:跳出多層循環，需要标簽語句的配合
控制跳轉語句：
break:中斷
continue:繼續
return:傳回
break:中斷的意思
使用場景：
a:switch語句中
b:循環語句中。
(循環語句中加入了if判斷的情況)
注意：離開上面的兩個場景，無意義。
如何使用呢?
b:跳出多層循環
要想實作這個效果，就必須知道一個東西。帶标簽的語句。
格式：
标簽名: 語句
class breakdemo {
//在 switch 或 loop 外部中斷
//跳出單層循環
if(x == 3) {
system.out.println("over");
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
if(y == 2) {
//break nc;
break wc;
(2)continue:繼續
a:用在循環中，離開此應用場景無意義。
a:跳出單層循環的一次，可以繼續下一次
c:填空題
if(x%3 == 0) {
//補齊代碼
system.out.println("java基礎班");
如何讓控制台輸出2次：java基礎班
如何讓控制台輸出7次：java基礎班
如何讓控制台輸出13次：java基礎班
循環中。離開此場景無意義。
測試，找到和break的差別：
break:跳出單層循環
continue:跳出一次循環，進入下一次的執行
練習題：
if(x%3==0) {
//在此處填寫代碼
system.out.println(“java基礎班”);
我想在控制台輸出2次:“java基礎班“
我想在控制台輸出7次:“java基礎班“
continue;
我想在控制台輸出13次:“java基礎班“
class continuedemo {
(3)return:傳回
a:用于結束方法的，後面還會在繼續講解和使用。
b:一旦遇到return,程式就不會在繼續往後執行。
其實它的作用不是結束循環的，而是結束方法的。
class returndemo {
if(x == 2) {
system.out.println("退出");
//continue;
return;
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)