控制语句-for

一、循环结构

  1. 在程序当中总有一些需要反复的/重复的执行代码,假设没有循环结构,那么这段需要重复执行的代码自然是需要重复执行编写的。代码无法得到重复使用。所以多数变成语言都是支持循环结构的。将来吧需要反复执行的代码片段放到“循环体”,再联合“计数器”,共同控制这段需要反复执行的代码。

  2. 基本上所有的编程语言支持的循环包括三种:

    • for循环
    • while循环
    • do…while循环
  3. 当前示例主要讲解for循环。for循环的语法结构是什么呢?

    • 语法结构:
      for(初始化表达式;布尔表达式;更新表达式){
      //是需要重复执行的代码片段【循环体:由java语句构成】
      }
  4. for循环的执行过程/执行原理?【*****】
    4.1、初始化表达式、布尔表达式、更新表达式都不是必须的!【但是两个分号是必须的】
    4.2、初始化表达式最先执行。并且整个for循环当中只执行一次。
    4.3、布尔表达式必须是true/false,不能是其他值。
    4.4、for的执行过程:

布尔表达式true
	- 执行循环体
		- 执行更新表达式
		- 布尔表达式的结果是true还是false
		- 布尔表达式true
			*	执行循环体
			*	执行更新表达式
			*	判断布尔表达式的结果是true还是false
			*	......
		- 布尔表达式false
			* 循环结束
布尔表达式false
	- 循环结束 

代码测试(一)

public class ForTest01 {
    public static void main(String[] args) {
        /*
         * 需求:输出数字1~10
         * 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);
         * */

        //使用循环结构来代替以上需要反复执行的代码块。
        //使用循环语句可以让代码量减少。
        //将以上代码修改为for循环

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

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

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

        //死循环
        for (;;){
            System.out.println("出错了!");
        }
    }
}

代码测试(二)

public class ForTest02 {
    public static void main(String[] args) {
        //以下的for循环当中的“i”变量的作用域仅限于当前for循环内部使用。
        for (int i = 0; i < 10; i++) {
            System.out.println("i--->" + i);
        }

        //以下的for循环当中的“i”变量的作用域仅限于当前for循环内部使用。
        for (int i = 0; i <= 10; i++) {
            System.out.println("i--->>" + i);
        }

        //这个i变量可以在main方法的作用域当中调用吗?无法访问
        //System.out.println("i = " + i);//编译错误

        //main方法作用域当中的i变量,只要main方法没有结束,这里的i就能用。
        int i = 0;

        for (; i < 10; i++) {
            System.out.println("i = " + i);
        }

        //这里可以访问main方法作用域当中的i变量
        System.out.println("i ====>" + i);

        int j;

        for (j = 1; j < 10; j++) {
            System.out.println("j -->" + j);
        }

        System.out.println(j);
    }
}

代码测试(三)

public class ForTest03 {
    public static void main(String[] args) {
        //输出1~10中所有的奇数
        for (int i = 1; i <= 10; i += 2) {
            System.out.println("i -->" + i);//1 3 5 7 9
        }

        //输出1~10中所有的偶数
        for (int i = 2; i <= 10; i += 2) {
            System.out.println("i -->" + i);
        }

        for (int i = 10; i > 0; i--) {
            System.out.println("i ===>" + i);//10 9 8 7 6 5 4 3 2 1
        }

        for (int i = 100; i >= 50; i -= 10) {
            System.out.println("i ===>" + i);//100 90 80 70 60 50
        }

        for (int i = 0; i < 10; ) {
            System.out.println("计数器 ===>" + i);
            i++;
        }

        for (int i = 0; i < 10; ) {
            i++;
            System.out.println("计数器 ===>" + i);//1 2 3 4 5 6 7 8 9 10
        }
    }
}

代码测试(四)

public class ForTest04 {
    /*
     * 循环语句和条件判断语句嵌套使用【for和if的嵌套】
     * */
    public static void main(String[] args) {
        //找出1~100所有的奇数
        //第一种方案:从1开始,每次递增2,这样每一个数字一定是奇数。
        for (int i = 1; i <= 100; i += 2) {
            System.out.println("奇数-->" + i);
        }

        //第二种方案:从1开始,以1递增,每一个数据都进行判断,判断标准是该数字对2求余数
        for (int i = 1; i <= 100; i++) {

            //System.out.println("i -->" + i);

            //判断i是否为奇数,是奇数的时候输出
            //i % 2 == 0//偶数
            //i % 2 == 1//奇数
            //i % 2 != 1//奇数
            if (i % 2 != 0) {
                System.out.println(i);
            }
        }

        //以上两种方案:优先选择第一种方案:代码少;循环次数少;效率较高
    }
}

代码测试(五)

public class ForTest05 {
    /*
     * 在前一个程序的基础之上,计算1~100所有奇数的和
     *   1 + 3 + 5 + 7 + 9 + ... + 99 累加
     * 运算符 += 就是专门完成追加的。*/
    public static void main(String[] args) {
        //定义一个变量【盒子】,初始值为0
        int sum = 0;

        for (int i = 1; i <= 100; i += 2) {
            //i一定是奇数
            //累加求和
            //System.out.println("i-->" + i);

            //sum存储的是最终求和的结果
            //不能每一次执行到这里,都把求和结果归零。
            //定义sum变量不能放到这里,因为这里是是循环体。
            //int sum = 0;

            sum += i;

            //输出语句放到这里表示每循环一次就输出一个数据
            //System.out.println("sum = " + sum);
        }

        //以上的for循环结束之后,最终输出求和的结果
        System.out.println("sum = " + sum);

        //====================================================================
        //归零
        sum = 0;

        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                sum += i;
            }
        }

        System.out.println(sum);
    }
}

代码测试(六)

public class ForTest06 {
    /*
     * for循环嵌套for循环
     * */
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {//共循环10次

            //循环体中可以编写其他的控制语句
            //控制语句可以嵌套使用
            //控制语句可以是:if、if...else、switch、for、while、do...while
            /*
            if(){
                for(){
                    while(){
                        if(){
                            for(){

                            }
                         }
                     }
                 }
            }
             */

            //最好不要想太多,即使循环体当中是一个for循环,不要将这个for特殊化,也只是一个普通的for循环,只不过是一段符合java语法的代码

            //内层循环,内层循环中的变量名和外层循环中的变量名不能重名。
            /*
            for (int i = 100; ; ) {

            }
            */

            //System.out.println("i ---> " + i);

            //这是循环体,无论这个循环体当中编写了什么样的代码,这堆代码也需要执行10遍。
            for (int j = 0; j < 3; j++) {
                System.out.println("j --> " + j);
            }
        }
    }
}

代码测试(七)

public class ForTest07 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {//循环十次
            System.out.println("Begin");

            //这里的代码片段执行十遍
            for (int j = 0; j < 1; j++) {
                System.out.println("j --> " + j);
            }

            System.out.println("Over");
        }

        /*
        结果:
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
            Begin
            0
            Over
         */
        for (int i = 1; i <= 5; i++) {
            System.out.println("开始");

            for (int j = 1; j < 5; j++) {
                //System.out.println(j);
                System.out.println(i * j);
            }

            System.out.println("结束");
        }
        /*
        *   结果:
        *       开始
        *       1 1*1
        *       2 1*2
        *       3 1*3
        *       4 1*4
        *       5 1*5
        *       结束
        *       开始
         *       1 2*1
         *       2 2*2
         *       3 2*3
         *       4 2*4
         *       5 2*5
         *       结束
         *       开始
         *       1 3*1
         *       2 3*2
         *       3 3*3
         *       4 3*4
         *       5 3*5
         *       结束
         *       开始
         *       1 4*1
         *       2 4*2
         *       3 4*3
         *       4 4*4
         *       5 4*5
         *       结束
         *       开始
         *       1 5*1
         *       2 5*2
         *       3 5*3
         *       4 5*4
         *       5 5*5
         *       结束
        * */
    }
}

代码测试(八)

public class ForTest08 {
    /*
        使用for循环输出九九乘法表:
        1 * 1 = 1
        2 * 1 = 2 2 * 2 = 4
        3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
        4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
        .............................................
        9 * 1 = 9 .....................................9 * 9 = 81
     */
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {//外层循环9次
            //i是行号
            //System.out.println(i);

            //循环体当中的程序主要的任务是什么?
            //处理当前行,将程序行中所有的项目全部输出
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + " ");
            }

            //换行
            System.out.println();
            //System.out.print("\n");
        }
    }
}

资料来源
【Java零基础教程视频(适合Java 0基础,Java初学入门)】 https://www.bilibili.com/video/BV1Rx411876f/?p=74&share_source=copy_web&vd_source=9bce191eb50f06ae83cb422d8b7f8f31

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不背完3500个考研英语词汇不改名

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值