精华内容
下载资源
问答
  • Java流程控制语句-循环结构

    万次阅读 多人点赞 2019-09-28 23:01:08
    包括while循环语句、do···while循环语句和for循环语句。 分类 for循环语句 执行流程 执行流程图 执行流程说明 A:执行初始化语句 B:执行判断条件语句,看其结果是true还是false 如果是false,循环结束。 如果是...

    定义

    循环语句就是在满足一定条件的情况下反复执行某一个操作。包括while循环语句、do···while循环语句和for循环语句。

    分类

    for循环语句

    执行流程

    执行流程图

    在这里插入图片描述

    执行流程说明

    A:执行初始化语句
    B:执行判断条件语句,看其结果是true还是false
    如果是false,循环结束。
    如果是true,继续执行。
    C:执行循环体语句
    D:执行控制条件语句
    E:回到B继续

    格式

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

    举例

    public 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");
    		}
    	}
    }
    

    foreach循环语句

    执行流程

    执行流程说明

    和for循环执行流程相似

    格式

    for (声明语句 : 表达式) {
      //代码句子
    }

    举例

    public class Test {
        public static void main(String args[]) {
            int [] numbers = {10, 20, 30, 40, 50};
            
            for ( int x : numbers ) {
                System.out.print( x );
                System.out.print(",");
            }
            
            System.out.print();
            String [] names = {"James", "Larry", "Tom", "Lacy"};
            
            for ( String name : names ) {
                System.out.print( name );
                System.out.print(",");
            }
        }
    }
    

    定义

    它是Java5后新增的for语句的特殊简化版本,并不能完全替代for语句,但所有foreach语句都可以改写为for语句。foreach语句在遍历数组等时为程序员提供了很大的方便。

    while循环语句

    格式

    基本格式
    while(判断条件语句) {
    循环体语句;
    }
    扩展格式
    初始化语句;
    while(判断条件语句) {
    循环体语句;
    控制条件语句;
    }

    执行流程

    执行流程图

    在这里插入图片描述

    执行流程说明

    while循环语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。

    举例

    public class WhileDemo {
    	public static void main(String[] args) {
    		//输出10次HelloWorld
    		/*
    		for(int x=1; x<=10; x++) {
    			System.out.println("HellloWorld");
    		}
    		*/
    		
    		//while循环实现
    		int x=1;
    		while(x<=10) {
    			System.out.println("HellloWorld");
    			x++;
    		}
    	}
    }
    

    do…while循环语句

    格式

    基本格式
    do {
    循环体语句;
    }while((判断条件语句);
    扩展格式
    初始化语句;
    do {
    循环体语句;
    控制条件语句;
    } while((判断条件语句);

    执行流程

    执行流程图

    在这里插入图片描述

    执行流程说明

    A:执行初始化语句;
    B:执行循环体语句;
    C:执行控制条件语句;
    D:执行判断条件语句,看是true还是false
    如果是true,回到B继续
    如果是false,就结束

    举例

    public class DoWhileDemo {
    	public static void main(String[] args) {
    		//输出10次 HelloWorld
    		/*
    		for(int x=1; x<=10; x++) {
    			System.out.println("HelloWorld");
    		}
    		*/
    		
    
    		//do...while改写
    		int x=1;
    		do {
    			System.out.println("HelloWorld");
    			x++;
    		}while(x<=10);
    	}
    }
    

    三种循环的区别

    虽然可以完成同样的功能,但是还是有小区别:
    do…while循环至少会执行一次循环体。
    for循环和while循环只有在条件成立的时候才会去执行循环体
    for循环语句和while循环语句的小区别:
    使用区别:控制条件语句所控制的那个变量,在for循环结束后,就不能再被访问到了,而while循环结束还可以继续使用,如果你想继续使用,就用while,否则推荐使用for。原因是for循环结束,该变量就从内存中消失,能够提高内存的使用效率。

    跳转语句(控制循环结构)

    定义

    Java语言中提供了3种跳转语句,分别是break语句、continue语句和return语句。

    分类

    break

    break的使用场景:
    在选择结构switch语句中

    ​ 在循环语句中

    break的作用:跳出单层循环

    注意:离开使用场景是没有意义的。

    举例

    /*
     * break:中断的意思
     * 使用场景:
     * 		A:switch语句中
     * 		B:循环中
     * 注意:
     * 		离开使用场景是没有意义的。
     * 作用:
     * 		跳出循环,让循环提前结束
     */
    public class BreakDemo {
    	public static void main(String[] args) {
    		//break;
    		
    		for(int x=1; x<=10; x++) {
    			if(x == 3) {
    				break;
    			}
    			System.out.println("HelloWorld");
    		}
    	}
    }
    
    continue

    continue的使用场景:在循环语句中

    continue的作用:结束一次循环,继续下一次的循环

    注意:离开使用场景的存在是没有意义的

    continue与break区别:
    break 退出当前循环
    continue 退出本次循环

    举例

    /*
     * continue:继续的意思
     * 使用场景:
     * 		循环中
     * 注意:
     * 		离开使用场景是没有意义的
     * 作用:
     * 		结束一次循环,继续下一次的循环
     * 区别:
     * 		break:退出循环
     * 		continue:结束一次循环,继续下一次的循环
     */
    public class ContinueDemo {
    	public static void main(String[] args) {
    		//continue;
    		
    		for(int x=1; x<=10; x++) {
    			if(x == 3) {
    				//break;
    				continue;
    			}
    			System.out.println("HelloWorld");
    		}
    	}
    }
    
    return

    return的使用场景:
    在循环语句中
    在方法中

    return的作用:

    ​ 可以从一个方法返回,并把控制权交给调用它的语句。
    ​ 直接结束整个方法,从而结束循环。

    举例

    public class ReturnDemo {
    	public static void main(String[] args) {
    		getStr();
    	}
    
    	public String getStr() {
            return "Hello";
        }
    
    }
    
    展开全文
  • 循环结构

    2019-03-23 22:10:31
    循环结构 循环结构:程序反复执行某个或某些操作,直到某条件为假(或真)时才停止循环 特别注意:循环结构必须给出循环出口,否则就是死循环。 Switch循环语句 while型结构:先判断条件,当条件为真时执行循环体,...

    循环结构

    循环结构:程序反复执行某个或某些操作,直到某条件为假(或真)时才停止循环
    特别注意:循环结构必须给出循环出口,否则就是死循环。

    Switch循环语句

    while型结构:先判断条件,当条件为真时执行循环体,并且在循环体结束时自动返回到循环入口处,再次判断循环条件;
    如果条件为假,则退出循环体到达流程出口处。即“先判断,后执行”;
    在这里插入图片描述
    语法结构:

    while(boolean){
     
    } 
    

    while 执行流程:
    当程序执行到 while 循环时 , 会首先判断小括号里的值 ,如果值
    为假 :结束while语句 , 程序继续向下走 (1)
    为真 :会把while 循环里大括号里的所有内容执行一次 , 全部执行完毕之后 ,会再度来到条件处 (2)
    判断小括号里的值 , 如果值
    为假 (1)
    为真 (2)
    注意: 如果没有 break return ,条件一直为true , 那么循环会一直循环下去

    循环输出1到100

    /**
     * @author Amanda
     *switch循环输出1到100
     */
    public class Test {
    	public static void main(String[] args){
    		int i = 1;
    		while( i <= 100){
    			System.out.println(i);
    			i++;
    		}
    		System.out.println("mian-gg");
    	}
    }
    

    Switch循环输出累加和

    /**
     * @author Amanda
     *switch循环输出累加和
     */
    public class Test {
    	public static void main(String[] args){
    		int i = 1;
    		int sum = 0;
    		while( i <= 100){
    			sum += i;
    			i++;
    		}
    		System.out.println("sum = " + sum);
    		System.out.println("mian-gg");
    	}
    }
    

    练习:1-100累加 输出 1-100 内的奇数和偶数 求出所有的水仙花数

    
    /**
     * @author Amanda
     *	1-100累加
    	输出 1-100 内的奇数和偶数  并对偶数求和
    	求出所有的水仙花数
     */
    public class Test {
    	public static void main(String[] args){
    		sum();
    		printWord();
    		Narcissus();
    		System.out.println("mian-gg");
    	}
    
    	private static void Narcissus() {
    		// 水仙花数  某个三位数的 个位 十位 百位 各取立方 , 它们的和等于自身
    		int i = 100;
    		int x,y,z;
    		while(i < 1000){
    			x = i / 1 % 10;
    			y = i / 10 % 10;
    			z = i / 100 % 10;
    			
    //			if((x^3 + y^3 + z^3) ==i)   //^为异或,应用Math.pow(a, b)方法,a的b次幂
    //			if( x*x*x + y*y*y + z*z*z == i)  //方法1
    			if(Math.pow(x, 3) + Math.pow(y, 3) + Math.pow(z, 3) == i)  //方法2
    				System.out.println(i);
    			i++;
    		}
    		
    	}
    
    	private static void printWord() {
    		// TODO Auto-generated method stub
    		int sum = 0;
    		int sum1 = 0;
    		int y = 1;
    		while(y <= 100){
    			if(y % 2 == 0){
    				System.out.println("偶数" + y);
    				sum += y;
    			}else{
    				System.out.println("奇数.." + y);
    				sum1 += y;
    			}
    			y++;
    		}
    		System.out.println("偶数和为:" + sum);
    		System.out.println("奇数和为:" + sum);
    	}
    
    	private static void sum() {
    		// TODO Auto-generated method stub
    		int i = 1;
    		int sum = 0;
    		while( i <= 100){
    			sum += i;
    			i++;
    		}
    		System.out.println("sum = " + sum);
    	}
    }
    

    .

    do-while循环

    在这里插入图片描述
    语法结构

    do{
        //循环体;
        //步进语句;
    }while(布尔值); //分号不能省
    

    执行流程:
    当程序执行到 dowhile时 , 它们是一个整体 ;
    程序会首先执行 大括号的内容 , 这是循环体 ;
    然后进行条件判断 , 如果小括号的值
    为假 : 结束循环 程序继续向下走 (1)
    为真 : 执行循环体一次 , 循环体整体结束了 , 再到条件判断处进行条件判断 (2)
    为假 :(1)
    为真 :(2)

    注意: do while 循环保证了循环体至少被执行一次

    例:

    public static void main(String[] args) {
    		// do-while循环
    		int i = 10; //循环初始条件
    		do{ //进入循环体
    			System.out.println("loop:" + i);
    			i--; //步进语句
    		}while(i < 0); //执行一次循环体后才判断条件
    
    	}
    

    练习:1-200的累加

    public static void main(String[] args) {
    		// do-while循环
    		int i = 1; //循环初始条件
    		int sum = 0;
    		do{ //进入循环体
    			System.out.println(i);
    			sum += i;
    			i++; //步进语句
    		}while(i <= 200); //执行一次循环体后才判断条件
    		System.out.println("sum = " + sum);
    	}
    

    for循环

    在这里插入图片描述
    语法格式:

    for(初始化语句;循环条件(布尔值);循环步进语句(++或--)){
        //循环执行体
    }
    

    执行流程:
    第一步:初始化语句;该语句只在循环开始前执行一次,在此处可以声明一个或多个同类型的变量,作用域只在for中
    第二步:每次执行循环体前,先判断循环条件的值,如果循环条件为真,则进入第三步,条件为假则进入第五步;
    第三步:执行循环体一次;
    第四步:执行循环步进语句(表达式3)后进入第二步;
    第五步:结束循环;

    联系:1-100的累加

    public static void main(String[] args){
    		int sum = 0;
    		for(int i = 0; i <= 100;i++){
    			sum += i;
    		}
    		System.out.println("sum = " + sum);
    	}
    

    练习: for输出1-100 , 奇数偶数分别添加标识

    /**
     * for输出1-100 , 奇数偶数分别添加标识
     * @author Acer
     *
     */
    public class TestOddEven {
    	public static void main(String[] args){
    		for(int i = 1; i <= 100;i++){
    			if(i % 2 == 0)
    				System.out.println("偶数" + i);
    			else{
    				System.out.println("..奇数" + i);
    			}
    		}
    	}
    }
    

    for循环省略

    1. 大括号可以省略 但是省略之后只对之后第一条语句产生作用
    2. 表达式1 可以省略 , 省略之后 , 往往放在for循环之前 , 如无特殊需求最好不这么写
    3. 表达式3 可以省略 , 省略之后会写在 循环体中
    4. 达式2 , 即条件也可以省略 , 但是省略之后会更复杂 往往要在循环体中 增加 if和break 结合 营造出循环的出口
    		int i = 1;
    		for(;;){
    			if(i == 101)
    				break;
    			System.out.println(i++);
    		}
    

    练习:完成一个功能 , 键盘录入用户名 , 用户名必须是 100-10000 之间的数字 ,用户可能录入失败 , 那么让他再度录入 直至成功;

    
    import java.util.Scanner;
    
    /**
     * 完成一个功能 , 键盘录入用户名 用户名必须是 100-10000 之间的数字 用户可能录入失败 , 那么让他再度录入 直至成功
     * @author Amanda
     */
    public class UserInfo {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		boolean b = true;
    
    		/*// 使用 常量 + break 来解决问题
    		for (;;) {
    			System.out.println("请录入100-10000之间的用户名");
    			int next = sc.nextInt();
    			if (100 <= next && next <= 10000)
    				break;
    			else 
    				System.out.println("不合法");
    		}
    		System.out.println("录入了合法的用户名");*/
    		
    		//使用变量完成改功能
    		while(b){
    			System.out.println("请录入100-10000之间的用户名");
    			int next = sc.nextInt();
    			if(100 <= next && next <= 10000)
    				b = false;
    			else
    				System.out.println("不合法");
    		}
    		System.out.println("录入了合法的用户名");
    		
    	}
    }
    
    

    **

    操作循环的关键字

    **

    使用break结束循环 break可以终止循环 和 switch语句的运行

    break用于结束一个循环,即跳出循环体,执行循环体之后的代码;

    /**
     * break用于结束一个循环,即跳出循环体,执行循环体之后的代码
     * @author Amanda
     *
     */
    public class TestBreak {
    	public static void main(String [] args){
    		//break 语句的应用 break用于结束循环,执行循环体后面的语句
    		for(int i = 1; i <= 5; i++){
    			if(i == 4) break;//当满足条件是,跳出整个循环体,执行输出语句Hello
    			System.out.println("i = " + i);
    		}
    		System.out.println("Hello!");
    	}
    }
    

    使用continue提前结束本次循环

    /**
     * 使用continue提前结束本次循环
     * @author Acer
     *
     */
    public class TestContinue {
    	public static void main(String[] args){
    		//测试continue语句的应用 continue终止本次循环,不跳出整个循环体,继续下次循环
    		for(int i = 1; i <= 5; i++){
    			if(i == 3) continue; //结束本次循环 但还是会开始下一次循环
    			System.out.println("i = " + i);
    		}
    	}
    }
    
    

    continue与break的区别:
    在这里插入图片描述

    使用return结束方法

    return关键字不是专门用于结束循环,return的功能时结束一个方法。当一个方法遇到return语句时,这个方法将被结束。
    方法结束 , 执行权回到方法调用处 ;

    public class TestReturn {
    
    	/**
    	 * 使用return结束方法
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		for(int i = 0;i < 5;i++){
    			if(i == 2){
    				return; //结束方法
    			}
    			System.out.println(i);
    		}
    		System.out.println("main方法");
    	}
    
    }
    
    

    嵌套循环:

    把一个循环放到另一个循环体内,就形成了嵌套循环;
    嵌套循环:各种类型的循环都可以作为外层循环或内层循环
    执行流程 : 外循环执行一次 , 内循环执行全部 ; 内循环就是外循环的循环体的一部分 ;

    /**
     * 把一个循环放到另一个循环体内,就形成了嵌套循环;
     * @author Amanda
     * 执行流程 :  外循环执行一次  ,  内循环执行全部 ;   内循环就是外循环的循环体的一部分 ;
     */
    public class NestedLoop {
    	public static void main(String[] args){
    		//嵌套循环
    		for(int line = 0;line < 5; line++){//外层循环控制行数
    			for(int space = 0;space < (5 - 1 - line);space++){//内层循环控制列数,打印空格
    				System.out.print(" ");
    			}
    			for(int star = 0;star < (line + 1); star++){//内层训话控制列数,打印*号
    				System.out.print("*");
    			}
    			System.out.println();//打印完每行后进行换行
    		}
    	}
    }
    
    


    使用break continue 只能控制单层循环 , 如果出现在嵌套循环的内循环中 , 那么操作的就是内循环 ;
    break continue 不仅可以结束其所在循环,还可以直接结束外层循环。
    此时需要在break continue 后紧跟一个标签,借助于标签可以操作一个外层循环。
    Java中的标签就是 标识符+冒号 ,只有放在循环语句之前才有作用。

    public class test02 {
    
    	/**
    	 * 标签:标识符+:
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    test:		for(int i = 1;i < 10; i++){
    			for(int j = 1; j <= i;j++){
    				if(j == 3)
    					break test; //使用的时候 在外面加上标签的名字
    				System.out.print(i + "*" + j + "=" + (i * j) + "\t");
    			}
    			System.out.println();
    		}
    	}
    
    }
    

    案例:

    /**
    	 * int 值  转  二进制
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int i = 31;
    		int num = 127;
    		while(i >= 0){
    			System.out.println(num >> i-- & 1);
    		}
    	}
    
    展开全文
  • C#循环结构语句

    2020-05-19 16:40:44
    C#中用来实现循环结构语句有三个: ①while语句 ②do语句 ③for语句 while循环是一种简单的循环: while(表达式) 语句 计算从1累加到N的和,其中N为大于1的自然数。 循环结构有三要素:循环初始、循环条件和...

    C#中用来实现循环结构的语句有三个:
    ①while语句
    ②do语句
    ③for语句
    while循环是一种简单的循环:
    while(表达式)
    语句
    计算从1累加到N的和,其中N为大于1的自然数。
    在这里插入图片描述
    循环结构有三要素:循环初始、循环条件和循环控制

    编写循环程序,就要精确设计三要素。循环初始发生在循环 之前,使得循环“就绪”;循环条件是循环得以继续或终止的判 定,而循环控制是在循环内部实现循环条件的关键过程。循环 体可以直接或间接利用三要素来达到计算目的,也可以与三要 素无关。

    1. while语句的循环体必须是“一个语句”的语法形式。
    2. while语句所形成的循环结构可以抽象为顺序结构的一步。 提示我们在编程时可以先抽象设计顺序结构的一步,再使用循 环结构细化。
      在循环中应该有使while表达式趋向假的操作,否则表达式恒为真,循环永不结束,成为死循环。
    3. 在循环中应该有使while表达式趋向假的操作,否则表达式 恒为真,循环永不结束,成为死循环。
    4. 如果表达式的值始终为假,则循环一次也不执行,失去了循 环的意义。
    5. while语句后面的圆括号是语法规定必须有的,循环条件可 以是C#语言中结果为bool类型的任意表达式。
    6. 从循环结构来看,while语句前应有循环初始,循环体内应 有循环控制。

    do语句

    1. do语句先执行循环体的语句,然后再计算给定的表达式值, 根据结果判定是否循环执行。
    do 
    	语句 
    while(表达式)

    计算从1累加到N的和,其中N为大于1的自然数。
    在这里插入图片描述
    for语句
    for语句是实现循环功能的又一个语句:

    for(初始化表达式;测试表达式;迭代表达式) 
    	语句
    

    使用for语句实现1到N的累加和代码片段如下:

    intN,i,sum;
    N = Convert.ToInt32(Console.ReadLine());//从键盘接收N
    for(i=1,sum=0;i<=N;i++) 
    sum = sum +i; 
    Console.WriteLine("sum is {0}",sum);
    
    1. for语句中初始化表达式只被执行一次,并且在for语句中任 何其他部分之前执行。它常用来声明和初始化循环中使用的本 地变量;
    2. 测试表达式可能会被多次求值,以决定循环体中的语句被执 行还是被跳过,它必须是bool类型;
    3. 迭代表达式在循环体的语句执行之后且在返回循环的顶端并 执行,迭代表达式执行后会立即再对测试表达式求值;
    4. for语句中的初始化表达式、测试表达式和迭代表达式都是 可选的。省略其中任何的表达式都不能省略中间的分号。

    几种循环语句的比较
    1.共同点
    ①while、do、for循环在逻辑上是相同的,一般情况下可以相互替换。
    ②作为循环结构,while、do-while、for循环一般地都需要设置循环的初始值、循环结束条件的判定、循环增量(或减量)的计算。
    2.不同点
    在这里插入图片描述

    1. do-while循环至少执行循环体一次。而while循环、for循环 可能一次也不执行。
    2. for循环的循环处理功能强。while、do-while均可用for循 环。

    循环的控制

    break语句
    break语句不能单独使用,它可以用于switch语句中,还能 用于for语句、while语句、do语句中。
    在这些语句的语句体中,break只结束包含它的switch语句 和循环语句,不会将所有嵌套语句结束。因此,使用break语 句可以提前结束循环,或者避免无限循环。

    循环语句的结束就有两个手段:

    一是循环条件。

    二是应用break语句。由于循环体中使用break语句通常附带条 件,所以仍可以将break的应用理解为循环三要素的循环条件。

    continue语句
    continue语句导致程序执行转到最内层循环的顶端,它可用 在while语句、do语句、for语句中
    continue语句与break语句一样,不能单独使用,而且 continue语句只对包含它的循环语句起作用。

    在while语句和do语句循环体中执行continue语句,程序会 转到“表达式”继续运行,在for语句循环体中执行continue 语句,程序会转到“迭代表达式”继续运行,循环体中余下 的语句被跳过了。

    所以continue语句的实际效果就是将一次循环结束,开始新 的一次循环。

    continue语句在编程时不是必不可少的,因为借助于恰当的 条件设置,也可以达到在某种情况下本次循环提前结束的效果。

    展开全文
  • 循环结构:循环是程序设计语言反复执行某些代码的一种计算机处理过程 分支结构 If语句: 当if 内的条件成立时,则运行if内的语句 当if 内条件不成立时,不运行if内的语句 语句0 if(逻辑表达式) { 语句1; 语句2; ...

    任何复杂的程序逻辑都可以通过“顺序”、“分支”、“循环”三种基本的程序结构实现
    顺序结构:语句按照顺序依次编译
    分支结构:根据不同的条件运行不同的结果
    循环结构:循环是程序设计语言中反复执行某些代码的一种计算机处理过程

    1 分支结构

    If语句:
    当if 内的条件成立时,则运行if内的语句
    当if 内条件不成立时,不运行if内的语句

    语句0
    if(逻辑表达式) {
        语句1;
        语句2;
    }
    语句3
    
    1. 执行语句0;
    2. 判断逻辑表达式的值:
      若值为true,则执行if语句块中的语句;
      若值为false,则不执行if语句块中的语句;
    3. 执行语句3。

    if-else语句

     语句0;	
      if(逻辑表达式) {
        语句块1;
     } else {
        语句块2;
     }
     语句3;
    

    else-if语句
    当程序的分支数大于2时,可以用if-else嵌套的方式解决,即:else语句块中又包含if语句(或if-else语句)
    在这里插入图片描述
    实例

    import java.util.Scanner;
    public class LevelForIf {
    public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入该学员的分数(0-100):");
            int score = scanner.nextInt();
            scanner.close();
    	        if(score<0 || score>100){
    	            System.out.println("请输入0到100以内的分数");
    	        }else if (score >= 90) {
    	            System.out.println("A");
    	        } else if (score >= 80) {
    	            System.out.println("B");
    	        } else if (score >= 60) {
    	            System.out.println("C");
    	        } else {
    	            System.out.println("D");
    	        }
    	    }
    	}
    

    switch-case语句
    switch-case语句是一种特殊的分支结构,可以根据一个整数表达式的不同取值,从不同的程序入口开始执行。
    在这里插入图片描述
    通常case1、case2、…、caseN对应完全不同的操作,可以和break语句配合使用,执行完相应语句后即退出switch块,不继续执行下面的语句。

    优势:
    • switch-case常常和break语句结合使用实现分支的功能。
    • switch-case在实现分支功能时和if-else的主要区别在于:switch-case结构的效率更高、结构更清晰。
    • 从JDK 7.0开始,switch-case支持字符串表达式。

    import java.util.Scanner;
    public class Month {
        public static void main(String[] args) {
            Scanner console = new Scanner(System.in);
            int month = console.nextInt();
            switch (month) {
                // case 后接的是要对比的值
                // case 是具有穿透性的,除非遇到break
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    System.out.println(month + "月,一共有31天");
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    System.out.println(month + "月,一共有30天");
                    break;
                case 2:
                    System.out.println(month + "月,一共有28天");
                    break;
                default:
                    System.out.println(month + "月不存在");
                    break;
            }
        }
    }
    

    2 循环结构

    什么是循环
    循环是程序设计语言中反复执行某些代码的一种计算机处理过程,是一组相同或相似语句被有规律的重复性执行。
    循环的要素:
    – 循环体(相同或相似的语句)
    – 循环条件(继续执行循环的条件,某些情况下循环条件以循环次数的方式体现)

    for语句
    for语句的执行逻辑

    for(表达式1; 表达式2; 表达式3){
    	语句块(循环体)
    }
    
    1. 计算表达式1的值;
    2. 计算表达式2(表达式2为逻辑表达式)的值,如果为true则执行循环体,否则退出循环;
    3. 执行循环体;
    4. 执行表达式3;
    5. 计算表达式2,如果为true则执行循环体,否则退出循环;
    6. 如此循环往复,直到表达式2的值为false。
    7. 循环是可以嵌套的
      在这里插入图片描述
      实例
      有一对兔子,从第3个月开始,每个月再生一对兔子,每个月有多少只兔子, 10个月后一共有多少只兔子
    public class Rabbit {
        public static void main(String[] args) {
            int f1 = 1; // 上上个月
            int f2 = 1; // 上个月
            int sum ;
            // for循环体
            for (int i = 3; i <= 10; i++) {
                // 当前这个月的总数,应该是前面两个月的数量和
                sum = f1 + f2;
                f1 = f2;
                f2 = sum;
                System.out.println("第" + i + "个月的兔子总数是:" + sum);
            }
        }
    }
    

    while语句
    8. 计算boolean表达式的值
    9. 如果值为true则执行语句块;语句块执行完后再次判断boolean表达式的值,如果为true则继续执行语句块;如此循环往复,直到boolean为false时退出while循环。
    在这里插入图片描述
    在这里插入图片描述
    PS:一般情况下,循环操作中会存在使得循环条件不满足的可能性,否则将成为“死循环”。

    实例
    猜数字游戏
    用户每猜测一次,由系统提示猜测结果:大了、小了或者猜对了;-> if
    直到用户猜对结果,则提示游戏结束。-> 当用户没猜对,就继续猜
    用户可以提前退出游戏,即,游戏过程中,如果用户录入数字0,则游戏终止。

    public class Guess {
        public static void main(String[] args) {
            int num = 666;//这里假设一个数为随机数
            Scanner console = new Scanner(System.in);
            int a;
            // 当用户没猜对,就继续猜
            while (a != num){
                // 1.猜数字
                a = console.nextInt();
                // 1.5 判断是不是0
                if (a == 0) {
                    // 提前退出循环
                    break;
                }
                // 2.判断结果
                if (a < num) {
                    System.out.println("太小了!");
                } else if (a > num) {
                    System.out.println("太大了!");
                } else {
                    System.out.println("恭喜你,猜对了!");
                }
            } 
        }
    }
    

    do-while语句

    1. 先执行语句块
    2. 再计算boolean表达式的值,如果值为true,再次执行语句块;如此循环往复,直到boolean为false为止。
      在这里插入图片描述
      在这里插入图片描述
      while和do-while语句的区别
      1.while循环先判断再执行;
      2.do-while循环先执行一次,再判断;
      当初始情况不满足循环条件时,while循环一次都不会执行;do-while循环不管任何情况都会至少执行一次。

    while(条件): 当…的时候, 就…
    特点: 不确定循环次数
    先随机生成一个1~1000的整数, 用户猜数字[控制台输入]
    打印结果:大了还是小了
    do-while(条件): 做… 直到…
    在一定程度上,两种循环可以互相替换
    特殊: 在第一次循环条件就不满足的时候

    展开全文
  • 循环结构 这里最简单最常用的就是顺序结构,即语句从上至下一一执行。 1、分支语句 顺序结构的程序虽然能解决计算、输出等问题,但不能做判断选择。对于要先做判断选择的问题就要使用分支结构。 1.1、单...
  • 循环结构总结

    千次阅读 2014-07-31 22:50:42
    循环结构 本讲内容:while 循环 do.while 循环 for 循环 程序的执行顺序: 顺序执行语句 通过进行一个判断在两个可选的语句序列之间选择执行(分支)。 循环结构 特点:在给定的条件成立时,反复执行某段程序,直到...
  • 第四单元 循环结构程序设计 第一课 while语句(理解循环结构的含义,掌握while语句的格式和功能,应用。) 在程序设计,经常需要反复...在C++循环结构有三种实现语句:while语句、do-while语句和for语句。 ...
  • 在java有3种流程控制结构:顺序结构、选择结构、循环结构 顺序结构:顺序结构是指程序从上到下依次执行每条语句的结构,中间没有任何的判断和跳转,前面的示例都采用顺序结构。 选择结构:选择结构是根据条件...
  • Java循环结构的使用

    2020-02-11 11:37:48
    Java 提供了一种称为循环的功能强大的结构,用来控制...Java循环结构有如下三种: while:事先不需要知道循环执行多少次 do-while:同上,只是至少要执行一次(先做,后判断) for:需要知道循环次数 while循环 ...
  • 看视频学,感觉学的不太系统,不过这三种循环的结构还是差不多能了解到是怎么应用的,而且感觉各类语言的循环结构好像都大同小异,最初接触循环结构还是在学校学Access数据库时,接下来总结一下在C#如何应用。...
  • JS循环结构5

    2017-08-01 19:05:12
    5.1 循环结构的概念先来看看生活的一些场景; (1)食堂阿姨打菜:接过顾客的餐盘→询问菜品→打菜→递回餐盘,重复以上过程,直到所有顾客的菜都打完。 (2)快递员送快递:查看送件地址→赶往目的地→电话告知...
  • java03循环结构

    2018-09-11 15:20:56
    1.内容回顾: 1.1运算符 算术运算符 关系运算符 逻辑运算符 赋值运算符 byte b = 3; b+=1; 正确的 = b+1; 错误的 字符串连接运算符 三目运算符 ...2.循环结构: 问题:输出10次hello ...
  • 选择结构与循环结构

    2021-05-11 16:35:20
    在Java有三种流程结构:顺序结构,选择结构,循环结构。 if控制语句 if控制语句共有三种不同的形式,分别是单分支结构,双分支结构和多分枝结构。 if语句由条件表达式和紧随其后的语句组成。如果if条件表达式...
  • C语言学习笔记——循环结构

    千次阅读 2018-07-01 14:06:08
    循环结构:(C语言三种基本结构顺序结构 选择结构 循环结构 之一)1.三种循环语句 while 一般形式为 while(表达式) 语句 一般表达式是循环条件 ,语句是循环体 eg1: 求1-100 的和例程:分别使用while与do whileint ...
  • C语言入门系列之5.循环控制结构程序

    千次阅读 多人点赞 2020-04-24 11:19:48
    循环结构在给定条件成立时,反复执行某程序段,包括循环条件和循环体。goto语句是一种无条件转移语句,需要用标号来指定跳转的位置。...break用于提前结束循环;continue用于跳过本次循环,继续执行后面的循环语句
  • 04.01_Java语言基础(循环结构概述和for语句的格式及其使用) A:循环结构的分类 for,while,do…while B:循环结构for语句的格式: for(初始化表达式;条件表达式;循环后的操作表达式) { 循环体; } ...
  • 循环控制结构在日常生活经常会遇到需要重复处理的问题,这就需要用到循环控制结构,通过循环来重复一件事。C语言有三大循环:while循环、do while循环、for循环。while循环语法:while(条件判断){………………...
  • 在生活有许多事情需要反复去做,才能达到预期的目的。比如学习的过程,我对陌生的知识通过学习,然后在经过反复...循环结构可以看成是一个条件判断语句和一个向回转向语句的组合。循环结构组成三要素:循环变量、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,269
精华内容 7,707
关键字:

在循环结构中提前结束循环的语句是