選擇結構switch語句的格式及其解釋
1:switch語句(掌握)
(1)格式：
switch(表達式) {
case 值1:
語句體1;
break;
case 值2:
語句體2;
break;
...
default:
語句體n+1;
break;
}
格式解釋說明：
switch:說明這是switch語句。
表達式:可以是byte,short,int,char
JDK5以後可以是枚舉
JDK7以後可以是字符串
case:後面的值就是要和表達式進行比較的值
break:表示程序到這裏中斷，跳出switch語句
default:如果所有的情況都不匹配,就執行這裏,相當於if語句中的else
(2)面試題
switch語句的表達式可以是byte嗎?可以是long嗎?可以是String嗎?
可以,不可以,JDK7以後可以
選擇結構switch語句的基本實用
package stephencurry;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個整數：");
int week = sc.nextInt();
switch(week)
{
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語句的注意事項
注意事項：
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("星期一");
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語句練習1看程序寫結果
/*
看程序寫結果
*/
class SwitchTest {
public static void main(String[] args) {
int x = 2;
int y = 3;
switch(x){
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
System.out.println("---------------");
int a = 2;
int b = 3;
switch(a){
default:
b++;
case 3:
b++;
case 4:
b++;
}
System.out.println("b="+b);
}
}
結果是：y=4；b=6
選擇結構switch語句練習2單項選擇題
/*
模擬單項選擇題。
分析：
A:出一個選擇題，然後供你選擇。
B:鍵盤錄入選擇的數據。
C:根據選擇來給出你選擇的結論。
*/
import java.util.Scanner;
class SwitchTest2 {
public static void main(String[] args) {
//出一個選擇題，然後供你選擇。
//由於我們現在沒有辦法鍵盤錄入得到一個'A','B'
//這樣的東西，我就用65，66這樣的值替代
//將來我們獲取到這樣的值以後，強制轉換爲字符類型
System.out.println("下面的幾個人你最愛誰?");
System.out.println("65 林青霞");
System.out.println("66 張曼玉");
System.out.println("67 劉德華");
System.out.println("68 王力宏");
//鍵盤錄入選擇的數據。
Scanner sc = new Scanner(System.in);
System.out.println("請輸入你的選擇：");
int choiceNumber = sc.nextInt();
//強制轉換爲字符類型
char choice = (char) choiceNumber;
switch(choice) {
case 'A':
System.out.println("恭喜你,選擇正確");
break;
case 'B':
System.out.println("不好意思，你選擇有誤");
break;
case 'C':
System.out.println("不好意思，你選擇有誤");
break;
case 'D':
System.out.println("不好意思，你選擇有誤");
break;
default:
System.out.println("沒有該選項");
break;
}
}
}
選擇結構switch語句練習3表達式求字符串
/*
根據你鍵盤錄入的字符串，判斷是否有滿足要求的，如果有就輸出。
否則，提示有誤。
String s = sc.nextLine();
*/
import java.util.Scanner;
class SwitchTest3 {
public static void main(String[] args) {
//創建鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//錄入數據
System.out.println("請輸入你要判斷的字符串：");
String s = sc.nextLine();
switch(s) {
case "hello":
System.out.println("你輸入的是hello");
break;
case "world":
System.out.println("你輸入的是world");
break;
case "java":
System.out.println("你輸入的是java");
break;
default:
System.out.println("沒有找到你輸入的數據");
//break;
}
}
}
選擇結構switch和if語句的各自使用場景
/*
用switch語句實現鍵盤錄入月份，輸出對應的季節
分析：
A:鍵盤錄入一個月份，用Scanner實現
B:用switch語句實現即可
if語句和switch語句的區別?
if語句：
A:針對結果是boolean類型的判斷
B:針對一個範圍的判斷
C:針對幾個常量值的判斷
switch語句：
針對幾個常量值的判斷
*/
import java.util.Scanner;
class SwitchTest4 {
public static void main(String[] args) {
//創建鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//錄入數據
System.out.println("請輸入月份(1-12)：");
int month = sc.nextInt();
/*
switch(month) {
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;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
case 12:
System.out.println("冬季");
break;
default:
System.out.println("你輸入的月份有誤");
}
*/
//這樣寫太麻煩了，我們使用一個我們不想使用的東西：case穿透
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
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;
default:
System.out.println("你輸入的月份有誤");
}
}
}
循環結構循環語句概述
/*
需求：請在控制檯輸出10次"HelloWorld"
*/
class Demo {
public static void main(String[] args) {
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語句的格式和基本使用
/*
循環語句：for循環,while循環,do...while循環。
for循環格式：
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
執行流程：
A:執行初始化語句
B:執行判斷條件語句,看其返回值是true還是false
如果是true，就繼續執行
如果是false，就結束循環
C:執行循環體語句;
D:執行控制條件語句
E:回到B繼續。
需求：請在控制檯輸出10次"HelloWorld"
*/
class ForDemo {
public static void main(String[] args) {
//最原始的做法
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("----------");
//這種做法不好,代碼的重複度太高。
//所以呢，我們用循環改進
for(int x=1;x<=10;x++) {
System.out.println("HelloWorld");
}
}
}
循環結構for語句的注意事項
注意事項：
A:判斷條件語句無論簡單還是複雜結果是boolean類型。
B:循環體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。
C:一般來說：有左大括號就沒有分號，有分號就沒有左大括號
循環結構for語句練習1獲取數據
/*
需求：請在控制檯輸出數據1-10
*/
class ForDemo2 {
public static void main(String[] args) {
//原始做法
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);
}
System.out.println("-------------");
//從0開始
for(int x=0; x<10; x++) {
System.out.println(x+1);
}
}
}
循環結構for語句練習2求和思想
/*
需求：求出1-10之間數據之和
分析：
0+1=1
1+2=3
3+3=6
6+4=10
10+5=15
...
由此可見我們要定義兩個變量：
一個變量用於存儲第一個加數，第一個加數其實保存的是以前的所有數據和。默認初始化值應該是0。
一個變量用於存儲第二個加數，第二個加數其實就是每次的數據變化的值。
求和思想。
*/
class ForDemo3 {
public static void main(String[] args) {
//原始做法
System.out.println(1+2+3+4+5+6+7+8+9+10);
//定義第一個加數
int sum = 0;
for(int x=1; x<=10; x++) {
//這裏的x其實是第二個加數
sum = sum + x;
/*
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
...
*/
//sum += x;
}
System.out.println("sum:"+sum);
}
}
循環結構for語句練習3偶數和
/*
需求：
A:求1-100之和。
B:求出1-100之間偶數和
C:求出1-100之間奇數和(自己做)
*/
class ForDemo4 {
public static void main(String[] args) {
//求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;
for(int x=1; x<=100; x++) {
if(x%2 == 0) {
sum2 += x;
}
}
System.out.println("1-100偶數之和是："+sum2);
System.out.println("------------------");
//方式2
int sum3 = 0;
for(int x=0; x<=100; x+=2) {
sum3 += x;
}
System.out.println("1-100偶數之和是："+sum3);
System.out.println("------------------");
}
}
循環結構for語句練習4階乘
/*
需求：求5的階乘。
什麼是階乘呢?
n! = n*(n-1)! 規則
n! = n*(n-1)*(n-2)*...*3*2*1
求和思想。
求階乘思想。
*/
class ForDemo5 {
public static void main(String[] args) {
//定義最終結果變量
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);
}
}
循環結構for語句練習5水仙花數
/*
天將降大任於斯人也,必先盜其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 {
public static void main(String[] args) {
//三位數其實是告訴了我們範圍。
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)) {
//如果相同，就把該數據在控制檯輸出。
System.out.println(x);
}
}
}
}
循環結構for語句練習6改進版的迴文數
/*
練習：
請在控制檯輸出滿足如下條件的五位數
個位等於萬位
十位等於千位
個位+十位+千位+萬位=百位
分析：
A:五位數就告訴了我們範圍。
B:分解每一個五位數的個，十，百，千，萬位上的數據
C:按照要求進行判斷即可
*/
class ForDemo7 {
public static void main(String[] args) {
//五位數就告訴了我們範圍。
for(int x=10000; x<100000; x++) {
//分解每一個五位數的個，十，百，千，萬位上的數據
int ge = x%10;
int shi = x/10%10;
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)) {
System.out.println(x);
}
}
}
}
循環結構for語句練習7統計思想
/*
需求：統計”水仙花數”共有多少個
分析：
A:首先必須知道什麼是水仙花數
所謂的水仙花數是指一個三位數，其各位數字的立方和等於該數本身。
舉例：153就是一個水仙花數。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
B:定義統計變量，初始化值是0
C:三位數告訴了我們範圍，用for循環就可以搞定
D:獲取每一個三位數的個，十，百的數據
E:按照要求進行判斷
F:如果滿足要求就計數。
*/
class ForDemo8 {
public static void main(String[] args) {
//定義統計變量，初始化值是0
int count = 0;
//三位數告訴了我們範圍，用for循環就可以搞定
for(int x=100; x<1000; x++) {
//獲取每一個三位數的個，十，百的數據
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//按照要求進行判斷
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果滿足要求就計數。
count++;
}
}
System.out.println("水仙花數共有"+count+"個");
}
}
循環結構for語句練習8同時取餘問題
/*
需求：請統計1-1000之間同時滿足如下條件的數據有多少個：
對3整除餘2
對5整除餘3
對7整除餘2
分析：
A:定義統計變量,初始化值是0
B:1-1000之間是一個範圍，用for很容易就可以實現。
C:每個數據要同時滿足如下要求
x%3==2
x%5==3
x%7==2
D:如果滿足條件，統計數據++即可，最後輸出統計變量
*/
class ForDemo9 {
public static void main(String[] args) {
//定義統計變量,初始化值是0
int count = 0;
//1-1000之間是一個範圍，用for很容易就可以實現。
for(int x=1; x<=1000; x++) {
/*
每個數據要同時滿足如下要求
x%3==2
x%5==3
x%7==2
*/
if(x%3==2 && x%5==3 && x%7==2) {
count++;
System.out.println(x);
}
}
//輸出數據
System.out.println("滿足這樣條件的數據共有："+count+"個");
}
}
循環結構while語句的基本格式和使用
/*
while循環的基本格式：
while(判斷條件語句) {
循環體語句;
}
擴展格式：
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
通過這個格式，我們就可以看到其實和for循環是差不多的。
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
*/
class WhileDemo {
public static void main(String[] args) {
//輸出10次"HelloWorld"
//for語句版
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
//while語句版
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}
}
}
循環結構while語句的練習1求和思想
/*
練習：用while循環實現
左邊：求出1-100之和
右邊：統計水仙花數有多少個
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
*/
class WhileDemo2 {
public static void main(String[] args) {
//求出1-100之和
//for語句版本
int sum = 0;
for(int x=1; x<=100; x++) {
sum+=x;
}
System.out.println("sum:"+sum);
System.out.println("--------");
//while語句版本
int sum2 = 0;
int y=1;
while(y<=100) {
sum2+=y;
y++;
}
System.out.println("sum2:"+sum2);
System.out.println("--------");
}
}
循環結構while語句的練習2統計思想
/*
需求：統計水仙花數有多少個
*/
class WhileDemo3 {
public static void main(String[] args) {
//for循環版本
int count = 0;
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
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++;
}
y++;
}
System.out.println("count2:"+count2);
}
}
循環結構while語句和for語句的區別
/*
while循環和for循環的區別?
使用區別：如果你想在循環結束後，繼續使用控制條件的那個變量，用while循環，否則用for循環。不知道用for循環。
因爲變量及早的從內存中消失，可以提高內存的使用效率。
其實還有一種場景的理解:
如果是一個範圍的，用for循環非常明確。
如果是不明確要做多少次，用while循環較爲合適。
舉例：吃葡萄。
*/
class WhileDemo4 {
public static void main(String[] args) {
//for循環實現
for(int x=0; x<10; x++) {
System.out.println("學習Java技術哪家強,中國北京傳智播客");
}
//這裏不能在繼續訪問了
//System.out.println(x);
//while循環實現
int y = 0;
while(y<10) {
System.out.println("學習Java技術哪家強,中國北京傳智播客");
y++;
}
//這裏是可以繼續訪問的
System.out.println(y);
}
}
循環結構while語句和練習珠穆朗瑪峯
/*
我國最高山峯是珠穆朗瑪峯：8848m，我現在有一張足夠大的紙張，厚度爲：0.01m。
請問，我摺疊多少次，就可以保證厚度不低於珠穆朗瑪峯的高度?
分析：
A:定義一個統計變量，默認值是0
B:最高山峯是珠穆朗瑪峯：8848m這是最終的厚度
我現在有一張足夠大的紙張，厚度爲：0.01m這是初始厚度
C:我摺疊多少次，就可以保證厚度不低於珠穆朗瑪峯的高度?
摺疊一次有什麼變化呢?就是厚度是以前的2倍。
D:只要每次變化的厚度沒有超過珠穆朗瑪峯的高度，就摺疊，統計變量++
E:輸出統計變量。
*/
class WhileDemo5 {
public static void main(String[] args) {
//定義一個統計變量，默認值是0
int count = 0;
//最高山峯是珠穆朗瑪峯：8848m這是最終的厚度
//我現在有一張足夠大的紙張，厚度爲：0.01m這是初始厚度
//爲了簡單，我把0.01變成1，同理8848就變成了884800
int end = 884800;
int start = 1;
while(start<end) {
//只要每次變化的厚度沒有超過珠穆朗瑪峯的高度，就摺疊，統計變量++
count++;
//摺疊一次有什麼變化呢?就是厚度是以前的2倍。
start *= 2;
System.out.println("第"+count+"次厚度是"+start);
}
//輸出統計變量。
System.out.println("要疊"+count+"次");
}
}
循環結構do…while語句的格式和基本使用
/*
do...while循環的基本格式：
do {
循環體語句;
}while(判斷條件語句);
擴展格式；
初始化語句;
do {
循環體語句;
控制條件語句;
}while(判斷條件語句);
*/
class DoWhileDemo {
public static void main(String[] args) {
//輸出10次HelloWorld。
int x = 0;
do {
System.out.println("HelloWorld");
x++;
}while(x<10);
System.out.println("--------------");
//求和1-100
int sum = 0;
int a = 1;
do {
sum += a;
a++;
}while(a<=100);
System.out.println(sum);
}
}
循環結構三種循環語句的區別
/*
循環語句的區別:
do...while循環至少執行一次循環體。
而for,while循環必須先判斷條件是否成立，然後決定是否執行循環體語句。
那麼，我們一般使用哪種循環呢?
優先考慮for，其次考慮while，最後考慮do...while
*/
class DoWhileDemo2 {
public static void main(String[] args) {
int x = 3;
while(x < 3) {
System.out.println("我愛林青霞");
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println("我愛林青霞");
y++;
}while(y < 3);
}
}
循環結構循環注意事項之死循環
/*
注意死循環：
A:一定要注意控制條件語句控制的那個變量的問題，不要弄丟了，否則就容易死循環。
B:兩種最簡單的死循環格式
while(true){...}
for(;;){...}
*/
class DoWhileDemo3 {
public static void main(String[] args) {
int x = 0;
while(x < 10) {
System.out.println(x);
x++;
}
System.out.println("------------");
/*
while(true) {
System.out.println("今天我很高興，學習了死循環");
}
*/
for(;;) {
System.out.println("今天我很高興，學習了死循環");
}
}
}
循環結構循環嵌套輸出4行5列的星星
/*
需求：請輸出一個4行5列的星星(*)圖案。
結果：
*****
*****
*****
*****
循環嵌套：就是循環語句的循環體本身是一個循環語句。
通過結果我們知道這樣的一個結論：
外循環控制行數
內循環控制列數
*/
class ForForDemo {
public static void main(String[] args) {
//原始做法
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.print(); 這個是不帶換行的
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//如果我要在一行上打出多顆*，比較麻煩，而代碼是重複的，所以我決定用循環改進
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我們可以通過空的輸出語句實現換行：System.out.println();
System.out.println();
//既然我可以打出一行，我就可以打出第二行
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我們可以通過空的輸出語句實現換行：System.out.println();
System.out.println();
//同理打出第三行，第四行
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我們可以通過空的輸出語句實現換行：System.out.println();
System.out.println();
//既然我可以打出一行，我就可以打出第二行
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++) {
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我們可以通過空的輸出語句實現換行：System.out.println();
System.out.println();
}
}
}
循環結構循環嵌套輸出直角三角形
/*
需求：請輸出下列的形狀
*
**
***
****
*****
*/
class ForForDemo2 {
public static void main(String[] args) {
//通過簡單的觀察，我們看到這是一個行是5，列數是變化的形狀
//我們先打印出一個5行5列的形狀
for(int x=0; x<5; x++) {
for(int y=0; y<5; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------");
//我們實現了一個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 x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
循環結構九九乘法表
/*
需求：在控制檯輸出九九乘法表。
首先我們寫出九九乘法表：
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 {
public static void main(String[] args) {
for(int x=0; x<9; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------");
//爲了使用數據，我們從1開始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
控制跳轉語句break語句
package stephencurry;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
for(int x=0; x<10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
System.out.println("over");
System.out.println("-------------");
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
if(y == 2) {
//break nc;
break wc;
}
System.out.print("*");
}
System.out.println();
}
}
}
控制跳轉語句continue語句
/*
continue:繼續
使用場景：
循環中。離開此場景無意義。
測試，找到和break的區別：
break:跳出單層循環
continue:跳出一次循環，進入下一次的執行
練習題：
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此處填寫代碼
}
System.out.println(“Java基礎班”);
}
我想在控制檯輸出2次:“Java基礎班“
break;
我想在控制檯輸出7次:“Java基礎班“
continue;
我想在控制檯輸出13次:“Java基礎班“
System.out.println(“Java基礎班”);
*/
class ContinueDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 3) {
//break;
continue;
}
System.out.println(x);
}
}
}
控制跳轉語句return語句
/*
return:返回
其實它的作用不是結束循環的，而是結束方法的。
*/
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 2) {
System.out.println("退出");
//break;
//continue;
return;
}
System.out.println(x);
}
System.out.println("over");
}
}
while語句和break結合使用之小芳存錢
/*
需求：小芳的媽媽每天給她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元我就退出循環。
*/
class WhileDemo {
public static void main(String[] args) {
//每天要存儲的錢是2.5元
double dayMoney = 2.5;
//存錢的初始化值是0
double daySum = 0;
//從第一天開始存儲
int dayCount = 1;
//最終存儲不小於100就不存儲了
int result = 100;
//因爲不知道是多少天，所以我用死循環，
while(true) {
//累加錢
daySum += dayMoney;
//一旦超過100元我就退出循環。
if(daySum >= result) {
System.out.println("共花了"+dayCount+"天存儲了100元");
break;
}
if(dayCount%5 == 0) {
//花去6元錢
daySum -= 6;
System.out.println("第"+dayCount+"天花了6元錢");
}
//天數變化
dayCount++;
}
}
}