JAVA基础4——流程控制语句

JAVA基础4——流程控制语句

  • 流程控制语句
    • 顺序语句
    • 选择语句
      • if语句
      • switch语句
    • 循环结构
      • for语句
      • while语句
      • do...while语句
      • 三种循环语句的区别
      • 无限循环
      • 循环嵌套
      • 代码优化
      • 控制跳转语句(break&continue)

流程控制语句

流程控制语句:可以控制程序的执行流程。
流程控制语句的分类

  • 顺序结构
  • 选择结构
  • 循环结构

顺序语句

执行流程
从上往下,依次执行。

选择语句

选择结构的分类

  • if语句
  • switch语句

if语句

if语句的格式1

if(比较表达式) {
			语句体;
		}
public class Dome_if {
    public static void main(String[] args){
        int age=12;
        if (age >= 18) {
            System.out.println("允许访问此网站");
        }
        System.out.println("禁止访问此网站");
    }
}

执行流程:
先计算比较表达式的值,看其返回值是true还是false。
如果是true,就执行语句体;
如果是false,就不执行语句体;

注意事项

  • 比较表达式无论简单还是复杂,结果必须是boolean类型
  • if语句控制的语句体如果是一条语句,大括号可以省略;
    如果是多条语句,就不能省略。建议永远不要省略。
  • 一般来说:有左大括号就没有分号,有分号就没有左大括号

if语句的格式2

if(比较表达式) {
		语句体1;
	}else {
		语句体2;
	}
import java.util.Scanner;
public class Dome_if {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的年龄");
        int x=sc.nextInt();
        if (x >= 18) {
            System.out.println("允许访问此网站");
        }
        else{
            System.out.println("禁止访问此网站");
        }
    }
}

执行流程:
首先计算比较表达式的值,看其返回值是true还是false。
如果是true,就执行语句体1;
如果是false,就执行语句体2;

  • 注意事项:else后面是没有比较表达式的,只有if后面有。

if语句和三元运算符完成同一个效果
三元运算符实现的,都可以采用if语句实现。反之不成立。

什么时候if语句实现不能用三元改进呢?
当if语句控制的操作是一个输出语句的时候就不能。
为什么呢?因为三元运算符是一个运算符,运算符操作完毕就应该有一个结果,而不是一个输出。

if语句的格式3:

if(比较表达式1) {
	语句体1;
	}else if(比较表达式2) {
	语句体2;
	}else if(比较表达式3) {
	语句体3;
	}
	...
	else {
	语句体n+1;
	}

执行流程:

  • 首先计算比较表达式1看其返回值是true还是false,
  • 如果是true,就执行语句体1,if语句结束。
  • 如果是false,接着计算比较表达式2看其返回值是true还是false,
  • 如果是true,就执行语句体2,if语句结束。
  • 如果是false,接着计算比较表达式3看其返回值是true还是false,
  • 如果都是false,就执行语句体n+1。
    注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示
/*需求:
        * 键盘录入x的值,计算出y的并输出。
        * x>=3	    y = 2 * x + 1;
        * -1
import java.util.Scanner;
public class Dome_if1 {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入X的值");
        int x=sc.nextInt();
        int y=0;
        if(x>=3){
            y = 2 * x + 1;
        }else if(x<3&&x>-1){
            y = 2 * x;
        }else if(x<=-1){
            y = 2 * x - 1;
        }else {
            System.out.println("请输入正确的实数");
        }
        System.out.println("y的值为"+y);
    }
}

if语句的嵌套使用

需求:获取三个数据中的最大值

import java.util.Scanner;
public class Dome_if2 {                                     //需求:获取三个数据中的最大值
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请用回车键分别提交三个整数");
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        if(a>b){        //a>b
            if(a>c){    //a>b & a>c
                System.out.println("最大值为:"+a);
            }else{      //a>b & c>=a
                System.out.println("最大值为:"+c);
            }
        }else{          //b>=a
            if (b>c){   //b>=a & b>c
                System.out.println("最大值为:"+b);
            }else{      //b>=a & c>=b
                System.out.println("最大值为:"+c);
            }
        }
    }
}

switch语句

switch语句的格式

switch(表达式) {
	case 值1:
	语句体1;
	break;
	case 值2:
	语句体2;
	break;
	 …
	default:	
	语句体n+1;
	break;
}

执行流程

  • 先计算表达式的值
  • 然后和case后面的匹配,如果有就执行对应的语句,否则执行default控制的语句
import java.util.Scanner;
public class Dome_switch {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("AI智能预测你喜欢的人");
        System.out.println("请输入你的名字:");
        String name=sc.next();
        switch (name){
            case "圆圆":System.out.println(name+"喜欢糖糖");
            break;
            case "糖糖":System.out.println(name+"喜欢圆圆");
            break;
            default:System.out.println("我他妈管你喜欢谁");
            break;
        }
    }
}

switch用于定义选择结构范围。
表达式:被选择的结果,该表达式只能有四种类型:byte,short,int,char
注意:在JDK5以后,还支持一个叫做枚举的类型(enum);JDK7以后,还支持String类型。
case:被选择的答案
break:跳出,结束switch语句。
default:默认的意思。当所有的case都不匹配时,执行default里面的内容。相当于if语句中的else。

注意事项

  • case后面只能是常量,不能是变量,而且,多个case后面的值不能出现相同的
  • default可以省略吗?
    • 可以省略,但是不建议,因为它的作用是对不正确的情况给出提示。
    • 特殊情况:
      • case就可以把值固定。
      • A,B,C,D
  • break可以省略吗?
    • 最后一个可以省略,其他最好不要省略
    • 会出现一个现象:case穿透。
    • 最终我们建议不要省略
  • default一定要在最后吗?
    • 不是,可以在任意位置。但是建议在最后。
  • switch语句的结束条件
    • 遇到break就结束了
    • 执行到switch的右大括号就结束了

练习:
看程序写结果:

public class switch1 {
    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);
    }
}

输出结果如下:y=4

public class switch1 {
    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);
    }
}

输出结果如下:y=6

两段代码的不同之处在于default下面break的有无,第二段代码利用了case穿透

if语句和switch语句的区别:

  • 如果是对具体的个数的数值进行判断两种皆可,
    建议使用switch,因为它会将被选答案加载进内存,选择效率会稍高。
  • switch建议判断固定值的时候用
  • if建议如果运算结果是Boolean类型或者判断区间或范围的时候用

练习:
分别用switch语句和if语句实现下列需求:
键盘录入月份,输出对应的季节
if语句

import java.util.Scanner;
public class Text_if {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入月份");
        int month=sc.nextInt();
        if(month==3 |month==4 | month==5){
            System.out.println(month+"月是春季");
        }else if (month==6 |month==7 | month==8){
            System.out.println(month+"月是夏季");
        }else if (month==9 |month==10 | month==11){
            System.out.println(month+"月是秋季");
        }else if (month==12 |month==1 | month==2){
            System.out.println(month+"月是冬季");
        }else{
            System.out.println("请输入正确的月份");
        }
    }
}

switch语句

import java.util.Scanner;
public class Text_switch {
    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(month+"月是春季");
            break;
            case 6:
            case 7:
            case 8: System.out.println(month+"月是夏季");
            break;
            case 9:
            case 10:
            case 11: System.out.println(month+"月是秋季");
            break;
            case 12:
            case 1:
            case 2: System.out.println(month+"月是冬季");
            break;
            default:System.out.println("请输入正确的月份");
            break;
        }
    }
}

循环结构

  • 循环结构的分类
    for,while,do...while

for语句

for语句的格式:

for(初始化表达式;条件表达式;循环后的操作表达式) {
	循环体;
}

例子

for(int x=0;x<10;x++){
	System.ot.println("输出语句");
	}

执行流程:

  1. 执行初始化语句
  2. 执行判断条件语句,看其返回值是true还是false
    如果是true,就继续执行
    如果是false,就结束循环
  3. 执行循环体语句;
  4. 执行循环后的操作表达式
  5. 回到2继续。

练习

  • 需求:求出1-10之间整数之和
  • 需求:求出1-100之间偶数和
  • 需求:求出1-100之间奇数和
public class Dome_for {
    public static void main(String[] args){
        int sum=0;
        for(int i=1;i<=10;i++){
            sum=sum+i;
        }
        System.out.println("sum="+sum);

        System.out.println("-----------------------");  /*上下定义相同变量i没有关系,for语句中定义的变量,使用过后就释放了*/

        int sum1=0;
        for(int i=0;i<=100;i+=2){
            sum1=sum1+i;
        }
        System.out.println("100以内偶数的和="+sum1);

        System.out.println("------------------------");  /*上下定义相同变量i没有关系,for语句中定义的变量,使用过后就释放了*/

        int sum2=0;
        for(int i=1;i<=100;i+=2){
            sum2=sum2+i;
        }
        System.out.println("100以内奇数的和="+sum2);
    }
}

注意事项:
上下定义相同变量i没有关系,for语句中定义的变量,使用过后就释放了

练习:
需求1:在控制台输出所有的”水仙花数”

所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。
举例:153就是一个水仙花数。
153 = 1×1×1 + 5×5×5 + 3×3×3 = 1 + 125 + 27 = 153

需求2:统计”水仙花数”共有多少个

public class Dome_for1 {
    public static void main(String[] args){
        int count=0;
        for (int num=100;num<1000;num++){
            if (num==(num%10)*(num%10)*(num%10)+(num/10%10)*(num/10%10)*(num/10%10)+(num/100)*(num/100)*(num/100)){
                count++;						//计数器思想,满足条件就自增
                System.out.println("第"+count+"个水仙数是"+num);
            }
        }
    }
}

运行结果:

1个水仙数是1532个水仙数是3703个水仙数是3714个水仙数是407

while语句

while语句的基本格式:

while(判断条件语句) {
	循环体语句;
}

完整格式:

初始化语句;
while(判断条件语句) {
	循环体语句;
	控制条件语句;
}

执行流程:

  1. 执行初始化语句
  2. 执行判断条件语句,看其返回值是true还是false
    如果是true,就继续执行
    如果是false,就结束循环
  3. 执行循环体语句;
  4. 执行控制条件语句
  5. 回到2继续。

例:控制台输出数据1-10

int x=1;
while(x<=10){
	System.out.println("x="+x)
	x++;
}

练习:

  • 求和思想
    求1-100之和
  • 统计思想
    统计”水仙花数”共有多少个
/*
 * A:求和思想
 * 求1-100之和
 * B:统计思想
 * 统计”水仙花数”共有多少个
 */
public class Dome_While {
    public static void main(String[] args){
        int i=1;
        int sum=0;
        while (i<=100){
            sum+=i;
            i++;
        }
        System.out.println("100以内和为:"+sum);
        System.out.println("-----------------------"); 
        int count=0;
        int num=100;
        while (num<=999){
            if (num==(num%10)*(num%10)*(num%10)+(num/10%10)*(num/10%10)*(num/10%10)+(num/100)*(num/100)*(num/100)){
                count++;
            }
            num++;
        }
        System.out.println("水仙花数有"+count+"个");
    }
}

注意事项:

  • while(条件表达式)不要加分号,否则结果很可能不是你想要的。
  • while所控制的语句是一条的时候,也可以省略大括号,但是不建议。

do…while语句

do…while语句的基本格式:

do {
	循环体语句;
}while(判断条件语句);

完整格式:

初始化语句;
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

执行流程:

  1. 执行初始化语句
  2. 执行循环体语句;
  3. 执行控制条件语句
  4. 执行判断条件语句,看其返回值是true还是false
    如果是true,就继续执行
    如果是false,就结束循环
  5. 回到2继续

例:
需求:请在控制台输出数据1-10

int i=1;
do{
	System.out.println("i="+i);
	i++;
}while(i<=10);

三种循环语句的区别

for , while , do...while
三种循环语句的区别:

while 和do while的区别:

  • while后面有分号
  • do…while循环至少执行一次循环体。
  • 而for,while循环必须先判断条件是否成立,然后决定是否执行循环体语句,可能一次都不执行。
public class Dome_difference {
    public static void main(String[] args) {
        //while 和do while的区别
        int i = 11;
        do {
            System.out.println("i = " + i);
            i++;
        }
        while (i <= 10); //细节 ;
        
        System.out.println("---------------------");

        int j = 11;
        while (j <= 10) {
            System.out.println("j = " + j);
            j++;
        }
    }
}

运行结果如下:

i = 11
---------------------

for和while的区别:

  • for语句执行后变量会被释放,不能再使用
  • while语句执行后,初始化变量还可以继续使用
public class Dome_difference {
    public static void main(String[] args) {
		for (int a = 1;a <= 5 ;a++ ) {
			System.out.println("a = " + a);
		}
		//a在这里没有作用,已经消失
		System.out.println("a = " + a);			//for语句执行后变量会被释放,不能再使用
        
		System.out.println("-------------------");

        int b=1;
		while (b <= 5) {
			System.out.println("b = " + b);
			b++;
		}

		System.out.println("-------------------");

		System.out.println("b = " + b);			//while语句执行后,初始化变量还可以继续使用
    }
}

运行结果如下:
在这里插入图片描述
这是因为for语句执行后变量会被释放,不能再使用

注释掉错误代码后,运行结果如下:

a = 1
a = 2
a = 3
a = 4
a = 5
-------------------
b = 1
b = 2
b = 3
b = 4
b = 5
-------------------
b = 6

while循环和for循环是等价的

  • 变量的生命周期不一样。一般来说,只在它所属的{}内有效。
  • 当你定义的初始化变量只为递增而存在,那么就用for循环,效率较高。
  • 当你定义的初始化变量,操作完后,还得继续使用,用while循环。
  • 因为变量及早的从内存中消失,可以提高内存的使用效率。

无限循环

两种最简单的死循环格式
while(true){...}//while语句的最简单无限循环格式true
for(;;){...}//for语句的最简单无限循环格式-----条件表达式默认为true
注意:一定要注意控制条件语句控制的那个变量的问题,不要弄丢了,否则就容易死循环。

while无限循环

public class Dome_InfiniteLoop {            		//InfiniteLoop无限循环
    public static void main(String[] args){
        while (true){
            System.out.println("InfiniteLoop");
        }
        System.out.println("InfiniteLoop");			//因为上面的语句无限循环,所以这一句无法执行
    }
}

输出结果:
JAVA基础4——流程控制语句_第1张图片
这是由于上面的语句无限循环,所以这一句无法执行
修改后的结果如下:
JAVA基础4——流程控制语句_第2张图片
for无限循环

public class Dome_InfiniteLoop {            //InfiniteLoop无限循环
    public static void main(String[] args){
        for (;;){
            System.out.println("Infinite   Loop");
        }
    }
}

输出结果:
JAVA基础4——流程控制语句_第3张图片

public class Dome_InfiniteLoop {            //InfiniteLoop无限循环
    public static void main(String[] args){
        int x = 1;
        for(System.out.println("a");x<3;System.out.println("c")){
            System.out.println("d");
        }
    }
}

输出结果:
JAVA基础4——流程控制语句_第4张图片
输出结果为a d c d c
这里涉及到for语句的执行顺序

循环嵌套

  • 外循环执行一次,内循环执行多次。
  • 如果是打印形状等,外循环控制行数,内循环控制列数。
//需求:请输出一个4行5列的星星(*)图案

public class Dome_forfor {
    public static void main(String[] args){
        for (int a=1;a<=4;a++){                 //外循环决定行数
            for (int b=1;b<=5;b++){             //内循环决定列数
                System.out.print("*");
            }
            System.out.println();				//每打印一行就换行
        }
    }
}

输出结果:
JAVA基础4——流程控制语句_第5张图片
例:
打印正三角 :
内循环的循环条件表达式变化
内循环的循环条件表达式随着外循环的变化而变化。

  • 外:(int x=0;x<5;x++)
  • 内:(int y=0;y<=x;y++)

打印倒三角 :
内循环的初始化表达式变化
内循环的初始化表达式随着外循环的变化而变化。

  • 外:(int x=0;x<5;x++)
  • 内:(int y=x;y<5;y++)
public class Dome_forfor1 {
    public static void main(String[] args){
        for (int a=1;a<=4;a++){                 //外循环决定行数
            for (int b=1;b<=a;b++){             //内循环决定列数
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("-----------------");

        for (int a=4;a>0;a--){
            for (int b=1;b<=a;b++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

输出结果:
JAVA基础4——流程控制语句_第6张图片

乘法表

public class Dome_forfor2 {
    public static void main(String[] args) {
        for (int a = 1; a <= 9; a++) {                 
            for (int b = 1; b <= a; b++) {
                int sum=a*b;
                System.out.print(a+"×"+b+"="+sum+'\t');
            }
            System.out.println();
        }
    }
}

JAVA基础4——流程控制语句_第7张图片
累加思想与计数器思想

  • 通过变量记录每次 变化的结果;通过循环进行累加动作。
  • 通过变量记录数据的状态变化,也需通过循环完成。
    • 计数器的条件根据实际情况而定

注意:一定要注意哪些语句参与循环,哪些语句不参与循环。

代码优化

注意:
'\x' x表示任意,\是转义符号,这种做法叫转移字符。
'\t' tab键的位置
'\r' 回车
'\n' 换行
'\"' 输出双引号
'\'' 输出单引号

控制跳转语句(break&continue)

break的使用场景
只能在switch和循环中

continue的使用场景
只能在循环中

continue和break异同

  1. 都有自己的应用范围
    1. continue用于循环
    2. break用于选择结构和循环结构
    单独使用:他们单独使用时,无意义,并且下面不可以有语句,因为执行不到。
  2. break结束当前所在循环,continue结束本次循环,进入下一次循环。
    标号可以改变跳出的循环。但是一般不用

标号:标记某个循环对其控制
标号组成规则:其实就是合法的标识符

public class Dome_mark {
    public static void main(String[] args){
        System.out.println("mark的使用");
        http://www.csdn.com
        System.out.println("不要被误导了");
    }
}

输出结果:

mark的使用
不要被误导了

注意
这里编译器没有报错,因为看似http://www.csdn.com是一个网址;
其实是一个标号为http的语句//后面则是注释。

练习:

for(int x=1; x<=10; x++) {
			if(x%3==0) {
				//在此处填写代码
			}
			System.out.println(“Java基础班”);
		}
		
		我想在控制台输出2次:“Java基础班“
		我想在控制台输出7次:“Java基础班“
		我想在控制台输出13次:“Java基础班“

JAVA基础4——流程控制语句_第8张图片
JAVA基础4——流程控制语句_第9张图片
JAVA基础4——流程控制语句_第10张图片
完整代码如下:

public class Text_1 {
    public static void main(String[] args){
        for(int x=1; x<=10; x++) {
            if(x%3==0) {
                //break;          //在控制台输出2次:“Java基础班“
                //continue;       //在控制台输出7次:“Java基础班“
                System.out.println("Java基础班");
            }
            System.out.println("Java基础班");
        }
    }
}

return的作用

  • 返回
  • 其实它的作用不是结束循环的,而是结束方法的。

return和break以及continue的区别?

  • return是结束方法
  • break是跳出循环
  • continue是终止本次循环继续下次循环

你可能感兴趣的:(Java基础)