Java中代码执行的顺序
1)顺序结构
Java中代码默认执行顺序，从上往下，一行一行地执行。入口方法main，Java程序都是从main方法开始执行，中间调用其它方法，进入方法执行，方法执行结束再回到main，main方法中的所有代码都执行完了，程序就终止。
2)选择分支
根据条件进行判断，选择其中的部分代码进行执行。
if…else
switch…case
3)循环结构
根据条件进行判断，重复多次地执行同一块代码
while
do···while
for
一、选择分支语句
If 语句
语法：
if (boolean) {
代码块
} else if (boolean) {
代码块
} else if (boolean) {
代码块
} else { // 默认情况
代码块
}
执行过程：
- 计算条件表达式，得到一个布尔型值
- 如果条件表达式地值是true，执行if后的代码块
- 如果条件表达式的值是false，执行else后的代码块
2.变形
1）else可以省略
2）{}可以省略。如果if/else后面跟的是一行代码，一个块，这时{}可以省略。
2）if可以嵌套
=90 <=100 优秀
=80 <90 良好
=70 <80 一般
=60 <70 及格
<60 不及格
@Test
public void test9() {
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();
// 卫操作 把非法输入和合法输入分开，非法输入直接在前面拦截
if (score > 100 || score < 0) {
System.out.println("非法输入");
return;
}
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score < 90) {
System.out.println("良好");
} else if (score >= 70 && score < 80) {
System.out.println("一般");
} else if (score >= 60 && score < 70) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
计算某年是不是闰年：
1、能被4整除，但是不能被100整除
||
2、能被400整除
采用结构
if (() || ()) {
}
@Test
public void test14() {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
if (year <= 0) {
System.out.println("违法输入，请输入正确的年份");
return;
}
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
System.out.println("该年份是闰年");
} else {
System.out.println("该年份不是闰年");
}
}
switch语句
switch： 可以接受的值(int byte 整数类型，char，String)
switch(2) {
case 1:
…
break;
case 2:
…
break;
…
default:
…
break;
}
执行过程：
- 计算条件表达式的值，条件表达式只能是byte,short,int char,String，枚举
- 依次对比条件表达式的值是否与case后的常量值相等，如果与case后的常量值相等，则进入该case后的代码块执行，当遇到break才会结束switch。
如果条件表达式的值与case后的常量不相等，跳过这个case病区比较下一个case。 - 如果条件表达式的值与所有case后的常量都不相等，进入default执行。
注意：
- 条件表达式只能是byte,short,int,char,String,枚举
- case后的常量值不能重复
- 在执行case后的代码块时，只有遇到break才会结束switch.
如果没有遇到break,进入下一个case/default里的代码执行 - default可以没有
练习
输入月份、年份判断天数：
1、3、5、7、8、10、12 -------- 31天
4、6 、9、11--------------------30天
2----------------------------------28/29天
@Test
public boolean isLeapYear(int year){
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
@Test
public void test5() {
// 输入月份、年份判断天数：
// 1、3、5、7、8、10、12 -------- 31天
// 4、6 、9、11--------------------30天
// 2----------------------------------28/29天
Scanner scanner = new Scanner(System.in);
System.out.println("输入月份");
int month = scanner.nextInt();
int year = 0;
int day = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
System.out.println( month + "月份共有：" + day + "天");
break;
case 4:
case 6:
case 9:
case 11:
day = 30;
System.out.println( month + "月份共有：" + day + "天");
break;
case 2:
System.out.println("输入年份");
year = scanner.nextInt();
if (isLeapYear(year)) {
day = 29;
System.out.println(year + "是闰年" + month + "月份有：" + day + "天");
} else {
day = 28;
System.out.println(year + "不是闰年" + month + "月份有：" + day + "天");
}
break;
default:
System.out.println("违法输入");
}
}
任何复杂的程序逻辑都可以通过“顺序”、“分支”、“循环”这三种基本结构来实现。
二、循环语句
循环的三要素：
1、循环条件的初始化
2、循环条件的控制
3、循环条件的改变
1.while语句
1、语法
while(条件表达式){
循环体
}
** 执行过程：**
- 计算表达式的值必须是一个布尔类型的
- 条件表达式的值为true，进入循环体执行，循环体执行完成之后，回到步骤1.
- 条件表达式的值为false，循环结束，跳过循环体，执行while结构后面的代码
```
@Test
public void test1() {
// 1. 循环条件的初始化
int i = 1;
// 2、循环条件的控制
while (i <= 5) {
System.out.println(“HelloWorld”);
// 3、循环条件的改变
i++;
}
}
```
2.do…while语句
1.语法
do{
循环体
}while(条件表达式);
执行过程：
- 进入循环体执行
- 循环体执行结束后，计算条件表达式的值，只能是布尔值
- 当条件表达式的值是true，回到步骤1
- 当条件表达式的值是false，循环结束
while和do…while的区别:
- 从语法上：while条件在前，循环体在后，do…while循环体在前，条件在后。
- 执行顺序：while先判断条件再执行循环，do…while先执行循环体再判断条件
- 结果上：while的循环体可能一次也不会执行，do…while的循环体至少会执行一次
3. for循环（最常用）
for(初始化表达式;条件表达式;迭代表达式){
循环体
}
初始化表达式：为循环状态进行初始化。通常都是对迭代变量定义和初始化，一般都写int i=0;
迭代表达式：对迭代变量进行迭代处理
一般都写i++ i-- i+=2
执行过程：
- 执行初始化表达式，对循环的初始状态进行设置，初始化表达式只在循环刚开始的时候执行一次
- 计算条件表达式的值，必须是布尔类型
- 当条件表达式的值是true，进入循环体执行，循环体执行结束后，执行迭代表达式
迭代表达式执行结束后,回到步骤2 - 当条件表达式的值式false，循环结束
4.无限循环/死循环
循环条件一直成立，循环永远都不会结束
while(true){
}
for(; ; ){
}
do{
}while(true);
@Test
public void test4(){
for(byte i=1;i<=100;i--){
System.out.println(i);
}
byte i= (byte) (-128-1);
System.out.println(i);
}
这不是死循环，在自减的过程中，i的值会溢出变成127.
5.关键字
5.1break
1.用在switch语句中
结束switch语句
2.用在循环中
直接结束循环，执行循环后的代码
跳出离他最近的那层循环
5.2continue：
用在循环中，跳出本次循环，继续下一次循环
5.2return
1）结束方法：return;
2）可以为方法提供一个返回值
如果在循环中使用return，方法都结束了，循环也就没有生存的空间了。
6.嵌套循环
在一个循环中包含了另外的一个循环。
在嵌套循环中，break和continue针对的是所在的循环。
如果要跨层起作用，可以使用标签
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
for (int k = 0; k < 5; k++) {
System.out.print(i + " ");
System.out.print(j + " ");
System.out.print(k + " ");
System.out.println();
if (k == 3) {
break;
}
}//结束所在的一层循环
}
}
}
for (int i = 0; i < 5; i++) {
sec: for (int j = 0; j < 5; j++) {
for (int k = 0; k < 5; k++) {
System.out.print(i + " ");
System.out.print(j + " ");
System.out.print(k + " ");
System.out.println();
if (k == 3) {
break sec;
}
}//结束所在的一层循环
}
}
三、练手（选择分支加循环）
while、for循环主要是两类题目：
1、累加思想（1+2+3+… + 100）
@Test
//1.累加思想(1+2+3+...+100)
public void test3() {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
}
2、统计思想，数一下符合条件的有多少个（计算1-100以内7的倍数的个数）
@Test
//2、统计思想，数一下符合条件的有多少个（计算1-100以内7的倍数的个数）
public void test4() {
int count = 0;
for (int i = 1; i <100 ; i++) {
if(i%7==0){
System.out.println(i);
count++;
}
}
System.out.println(count);
}
3、计算1-100以内所有奇数的和以及所有偶数的和，分别打印出来
@Test
public void test9() {
// 奇数和
int oddNumberNum=0;
// 偶数和
int evenNmberNum=0;
for (int i = 1; i <=100; i++) {
if(i%2==0){
evenNmberNum+=i;
}else {
oddNumberNum+=i;
}
}
System.out.println("奇数和:"+oddNumberNum+" "+"偶数和:"+evenNmberNum);
}
4、用for循环输出1—1000之间能被5整除的数，且每行输出3个
@Test
public void test10() {
int count = 0;
for (int i = 1; i < 100; i++) {
if (i % 5 == 0) {
System.out.print(i + " ");
count++;
// if (count == 3) {
// System.out.println();
// count = 0;
// }
if (count % 3 == 0) {
System.out.println();
}
}
}
}
5、使用循环打印100-200之间所有的素数（只能被1和自己整除的数叫素数）
@Test
public void test12() {
for (int i = 100; i <= 200; i++) {
boolean isTrue = true;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
isTrue = false;
break;
}
}
if (isTrue) {
System.out.println(i);
}
}
}
运用continue、break
1、编写一个收银台收款程序
1.1、编写一个收银台收款程序，if
定义输入----单价、数量、用户输入金额
定义输出----应收金额、找零
使用double类型变量 scanner.nextDouble();
1.2、当总价>=500时候打八折
1.3、考虑程序出现异常的情况，如：收款金额小于应收金额
若收款金额大于等于应收金额，则计算找零后输出
若收款金额小于应收金额，输出错误信息。
@Test
public void test15() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入单价");
double price = scanner.nextDouble();
System.out.println("请输入数量");
double count = scanner.nextDouble();
System.out.println("请输入用户金额");
// 用户输入金额
double userInputAmount = scanner.nextDouble();
// 应收金额
double totalPrice = price * count;
if(userInputAmount<0){
System.out.println("输入信息违法,请重新输入");
while (userInputAmount<0){
userInputAmount = scanner.nextDouble();
}
}
while (userInputAmount>=0){
if (userInputAmount < totalPrice) {
System.out.println("付款金额不够,请重新输入付款金额或者 输入0退出购买");
userInputAmount = scanner.nextDouble();
continue;
}
if(totalPrice>0 && totalPrice<500){
System.out.println("应收金额："+totalPrice+"元"+" "+"找零:"+(userInputAmount-totalPrice)+"元");
break;
} else if(totalPrice>=500){
System.out.println("应收金额:"+(totalPrice*0.8)+"元"+" "+"找零:"+(userInputAmount-totalPrice*0.8)+"元");
break;
}
}
}
猜数随机生成一个整数1-1000
用户输入一个整数，程序给出与存储的数字是“大”或者“小”，知道用户猜到这个数字位置。
如果中途用户希望程序退出，输入0可以退出。
int num = 200;
猜吧！
300
太大了
猜吧！
180
太小了
猜吧！
200
恭喜你，猜对了
@Test
// 例题：随机生成一个整数1-1000
// 用户输入一个整数，程序给出与存储的数字是“大”或者“小”，知道用户猜到这个数字位置。
public void test5() {
Scanner scanner = new Scanner(System.in);
// int random=new Random().nextInt(1000)+1;
int a = (int) (Math.random() * 1000 + 1);
System.out.println(a);
while (true) {
int b = scanner.nextInt();
if (a > b && b > 0) {
System.out.println("太小了");
System.out.println("猜吧");
continue;
}
if (a < b) {
System.out.println("太大了");
System.out.println("猜吧");
continue;
}
if (b == 0) {
System.out.println("已退出");
break;
}
if (a == b) {
System.out.println("恭喜你猜对了");
break;
}
}
}
双重for循环（重点）
双重for循环：
外层循环控制行数，数一下有几行就能确定外层循环。
内层循环控制列数，这一行打印多少个，到底要打印多少个要找出和当前行之间的一个关系。
1、
@Test
public void test4(){
for (int i = 1; i <=3; i++) {
// 外层循环 代表行
// 内层循环 代表列
for(int j=1;j<=4;j++){
System.out.print("*");
// if (j==4){
// System.out.println();
// }
}
System.out.println();
}
}
2、
*
**
@Test
public void test7(){
for (int i = 1; i <=5; i++) {
// 外层循环 代表行
// 内层循环 代表列
for(int j=1;j<=5;j++){
if(i==j){
System.out.print("*"+" ");
break;
}
System.out.print("*"+" ");
}
System.out.println();
}
}
@Test
public void test9(){
for (int i = 1; i <=5; i++) {
// 外层循环 代表行
// 内层循环 代表列
for(int j=1;j<=i;j++){
System.out.print("*"+" ");
}
System.out.println();
}
}
@Test
public void test8(){
for (int i = 1; i <=9; i++) {
// 外层循环 代表行
// 内层循环 代表列
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+(j*i)+" ");
}
System.out.println();
}
}
打印正三角形
@Test
public void test13(){
for (int i=1;i<=6;i++){
// i=1 j=5
// i=2 j=4
// i=3 j=3
// i=4 j=2
// i=5 j=1
// i=6 j=0
for (int k=1;k<=(6-i);k++){
System.out.print(" "+" ");
}
// i=1 j=1
// i=2 j=3
// i=3 j=5
// i=4 j=7
// j=2*i-1
for (int j=1;j<=2*i-1;j++){
System.out.print("*"+" ");
}
System.out.println();
}
}
6794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
