JAVA零基础入门笔记(六)-循环复习+break+continue

1，前一天的回顾

for循环：

格式：

for（初始化语句；条件判断语句；条件控制语句（步进表达式））{

	循环体；

}

执行过程：

首先会执行初始化语句，然后再执行条件判断语句。

	如果判断结果为真，则进入循环体。如果判断结果为假，整个循环停止。

	再来执行条件控制语句。再次进行条件判断。

案例：

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

快速生成方式：

在idea中适用的。 次数.fori + 回车。//从小到大

在idea中适用的。次数.forr + 回车。//从大到小

在for循环中变量作用范围：

情况一：

结论：当变量定义在循环外面的时候。其实跟循环没有任何关系的。

当循环结束之后，变量还是可以继续使用的。

 //变量的作用范围：变量只在所属的大括号中有效。
    
    //变量在for循环的外面
    int number = 10;
    for (int i = 0; i < 10; i++) {
        number++;
        System.out.println(number);
    }
    
    System.out.println("-----------------------------");
    //在15行代码中，number可以成功打印出来吗？如果可以，值为多少，如果不可以，为什么？
    System.out.println(number);//20

情况二：

 //变量i
        //当变量定义在初始化语句中时，跟循环有关的。
        //所以当循环结束之后，这个变量从内存中消失了。
        //循环结束之后，这个变量就不能再使用了。
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        System.out.println("-------------------------------");
        //1,循环结束之后，变量i，还能不能使用？
        System.out.println(i);

情况三：

 //变量的作用范围。
        //现在循环执行10次。
        //第一次循环的时候。开始执行循环体。
            //在循环体当中，定义了一个变量。给这个变量赋值为1.
            //然后给这个变量进行自增。并进行打印。
            //打印完毕之后，循环体结束，执行到右大括号。
            //所以此时，变量就已经从内存中消失了。

        //第二次循环的时候。开始执行循环体。
            //在循环体当中，定义了一个变量。给这个变量赋值为1.
            //此时定义的是一个新的变量number。
            //当第二次循环结束的时候，这个变量就会从内存中消失。

        //第三次循环的时候，开始执行循环体。
            //在循环体当中，再次定义了一个变量。给这个变量赋值为1.
            //....

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

总结：

第一种情况：变量定义在循环的外面。跟循环没有任何关系。循环结束，变量还可以继续使用。

第二种情况：变量定义在初始化语句中。跟循环有关系。不管循环多少次，使用的都是同一个变量。

当循环结束，初始化语句中的这个变量才会消失。在循环的外面，是无法进行输出的。

第三种情况：变量定义在循环体中。跟循环有关系。但是单次循环结束后，变量就会立马从内存中消失。

每次循环，都是一个新的变量。在循环的外面，是无法进行输出的.

while 循环:

简化格式：

while(条件判断语句){

		循环体；

	}

完整格式：

初始化语句；

	while(条件判断语句){

		循环体；

		条件控制语句；

	}

执行过程：

首先执行初始化语句，然后进行条件判断。

当条件判断为真的时候，才进入到循环体。再来执行条件控制语句。

回到上面再次条件判断。

快速生成方式：

先写循环体：System.out.println("helloworld");

再选中这行代码，按快捷键ctrl + alt + T 选择while将当前代码进行包裹。

do…while循环：（了解）

格式：

do{

		循环体;

	}while(条件判断语句);

执行过程：

先执行循环体，再执行条件判断语句。当条件判断语句为真，再次回到上面执行循环体。

如果条件判断语句为假，此时循环停止。

特点：

不管条件判断语句，是真，还是假。循环体，至少执行一次。

无限循环： 循环停不下来。

格式：

for（；；）{

}

解释说明：

• 初始化语句不写，表示循环开始的时候，不做任何事情。

• 条件判断语句不写，表示默认为true。

• 条件控制语句不写，表示循环结束之后，不做任何事情。

• 此时，就可以无限，重复的执行大括号中的循环体。 ```

while(true){

}

解释说明：

• 小括号中的true必须要写，不能省略。

• 就可以无限，重复的执行大括号中的循环体。

do{

}while(true);

解释说明：(了解)

• 先执行循环体，再到while当中看判断。

• 就可以无限，重复的执行大括号中的循环体。

使用区别：

• for：知道了循环次数的时候，可以使用for循环。

• while：不知道循环次数，但是能知道循环结束条件的时候。

2，continue关键字

用法：

• 只能作用在循环当中。

• 在循环的过程中，如果遇到了continue关键字，表示立马结束本次循环，开始继续下次循环。

案例：

//循环1 ~10
//如果当前的数字是偶数，就不打印。 --- 只打印奇数
/*for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) {
                System.out.println(i);
            }
        }*/

for (int i = 1; i <= 10; i++) {
    if(i % 2 == 0){
        //那么就表示，当前的数字是偶数
        //如果是偶数，那么立马结束本次循环，下面的输出语句不会执行
        //跳到i++，开始下一次循环。
        continue;
    }
    System.out.println(i);
}

使用注意点：

continue关键字下面不能写其他代码，因为永远执行不到

 for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            //那么就表示，当前的数字是偶数
            //如果是偶数，那么立马结束本次循环，下面的输出语句不会执行
            //跳到i++，开始下一次循环。
            continue;
            //当if的条件满足，执行语句体。
            //执行完continue后，本次循环立马结束，跳转到i++。
            //那么这个输出语句永远执行不到。所以，continue下面不能写其他语句。
    		System.out.println(i);
        }   
    }

    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            //那么就表示，当前的数字是偶数
            //如果是偶数，那么立马结束本次循环，下面的输出语句不会执行
            //跳到i++，开始下一次循环。
            continue;
        }  
        //把输出语句写在外面就ok了。
        //因为当if的判断条件不成立的时候，此时输出语句还是可以执行到的。
        System.out.println(i);
    }

3，break关键字

用法：

• 可以使用在switch语句，还有循环中。
• 不管用在哪里，都表示结束，停止的意思。

下面我们以循环为例，

在循环的过程中，如果遇到了break，那么整个循环到这个地方就会全部结束。

4，总结

 //相亲
    //1,在自我介绍之后，我就觉得，你不是我的菜。
    //  赶紧结束本次相亲，我好再去相第二个。
    while(true){
        System.out.println("自我介绍");
        if(不入眼){
            continue;
        }
        System.out.println("互留微信");
        System.out.println("尬聊");
        System.out.println("约会");
    }
    System.out.println("结婚");

    //相亲
    //1,在自我介绍之后，我就觉得，遇到了生命中的另一半。
    //那么咱们就没必要再继续浪费时间，直接结婚就好了。
    while(true){
        System.out.println("自我介绍");
        if(遇到了生命中的另一半){
            break;
        }
        System.out.println("互留微信");
        System.out.println("尬聊");
        System.out.println("约会");
    }
    System.out.println("结婚");

5，练习：逢七过

//1 ~100

1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过 …

//只要是7的倍数。 i % 7 == 0

//或者包含7. 个位数是7 ， 十位数是7

那么都要喊过

i % 7 == 0 || 个位数是7 || 十位数是7

还是只要满足其中一个就喊过

 //逢七过的小案例
    //循环1~100之间的数字。 只要是7的倍数，或者包含7，那么就要喊过
    
    //循环1~100
    for (int i = 1; i < 100; i++) {
        //i表示这个范围中的每一个数字
        //要对每一个数字进行判断
        //只要满足其中一个条件，就需要喊过
        int ge = i % 10;
        int shi = i / 10 % 10;
        if (i % 7 == 0 || ge == 7 || shi == 7) {
            System.out.println("过");
            continue;
        }
        System.out.println(i);
    }

6，输出语句：

  System.out.println("abc");//表示先打印小括号里面的内容，再进行换行操作。
    System.out.print("abc");//表示打印小括号里面的内容，不进行换行操作。
    System.out.println();//表示什么都不打印，只换行。
    -------------------------------------------------------------------
    System.out.print();//如果有，表示不打印，不换行。所以没有这种写法。

7，循环嵌套

• 循环嵌套就是，循环当中还有其他循环。

• 这个知识点，是从helloworld开始，到目前为止，最难的。

案例1：打印一个矩形

//打印矩形
//外面的循环 --- 外循环
//里面的循环 --- 内循环
//内循环 其实 是 外循环的 循环体。
for (int i = 1; i <= 4; i++) {
    //在一行中打印5个星
 	for (int j = 1; j <= 5; j++) {
        System.out.print("*");
    }
	//打印完毕之后，再进行换行操作
    System.out.println();
}

//理解代码小技巧：
//首先要能明白，内循环是干嘛的。
//然后再看外循环，外循环，就是把里面要做的事情，重复执行N遍。

当外循环中i = 1的时候，其实就是打印第一行内容。此时1 <=4满足条件，进入循环体当中。

此时外循环的循环体就是内循环。j = 1 ，j<=5满足条件。再次进入内循环的循环体。打印了一个*。然后j++

							  j  = 2，j<=5满足条件。再次进入内循环的循环体。打印了一个*。然后j++

							  j  = 3，j<=5满足条件。再次进入内循环的循环体。打印了一个*。然后j++

							  j  = 4，j<=5满足条件。再次进入内循环的循环体。打印了一个*。然后j++

							  j  = 5，j<=5满足条件。再次进入内循环的循环体。打印了一个*。然后j++

							到目前为止，相当于在第一行，打印了5个*

							  j = 6， j<=5  不成立了，此时，内循环执行完毕。执行换行操作。

 当换行结束之后，表示什么？表示外循环的循环体已经执行完毕了。

此时执行到外循环的i++，变成2。

---

当外循环中i = 2 的时候，其实就是开始打印第二行内容。此时 2 <= 4 满足条件，进入循环体当中。

此时外循环的循环体就是内循环。而内循环做的事情就是在一行打印5个*，然后换行。当第二行的5个星打印	

 完毕之后。表示此时外循环的循环体已经执行完毕了。

再执行到外循环的i++，变成3.

---

开始第三次循环 i = 3. 相当于开始打印第三行的内容

…

---

开始第四次循环 i = 4，相当于开始打印第四行的内容

总结：

• 外循环，控制了，一共打印几行。

• 内循环，控制了，在每一行打印多少个星。

案例2：打印一个直角三角形

  //外循环，控制了行数，现在打印5行
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print("*");
        }
        System.out.println();
    }

理解代码小技巧：

首先要能明白，内循环是干嘛的。

然后再看外循环，外循环，就是把里面要做的事情，重复执行N遍。

执行过程：

当外循环i=1的时候，表示现在打印的是第一行。1<=5满足，进入循环体。
此时，内循环，就相当于

 for (int j = 1; j <= 1; j++) {
        System.out.print("*");
    }
 System.out.println();

就是打印一个星，然后再换行。此时内循环和换行都执行完毕了，那么就要执行到外循环的i++。

---

当外循环i=2的时候，表示现在打印的是第二行。2<=5满足，进入循环体。
此时，内循环，就相当于

 for (int j = 1; j <= 2; j++) {
        System.out.print("*");
    }
 System.out.println();

就是打印两个星，然后再换行。此时内循环和换行都执行完毕了，那么就要执行到外循环的i++。

---

当外循环的i=3的时候，表示现在打印的是第三行。3<=5满足，进入循环体。
此时，内循环，就相当于

   for (int j = 1; j <= 3; j++) {
            System.out.print("*");
        }
     System.out.println();

就是打印三个星，然后再换行。此时内循环和换行都执行完毕了，那么就要执行到外循环的i++。

---

当外循环的i=4的时候，表示现在打印的是第四行。4<=5满足，进入循环体。
此时，内循环，就相当于

for (int j = 1; j <= 4; j++) {
    System.out.print("*");
}
System.out.println();

就是打印四个星，然后再换行。此时内循环和换行都执行完毕了，那么就要执行到外循环的i++。

---

当外循环的i=5的时候，表示现在打印的是第五行。5<=5满足，进入循环体。
此时，内循环，就相当于

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

就是打印五个星，然后再换行。此时内循环和换行都执行完毕了，那么就要执行到外循环的i++。

---

5行都打印完毕了，外循环结束，最终的直角三角形也搞定了。

案例3：打印99乘法表

步骤：

1，打印一个9行9列的矩形。

2，把上面的矩形改成一个直角三角形。

此时就跟99乘法表的样子有点像了。

3，修改里面输出的内容。

  for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j + "*" + i + "=" + (i * j) + "\t");
        }
        System.out.println();
    }

分享了两个小技巧：

• \t 制表符，在键盘中就是一个tab。
  就是一个大空格，但是第二行的tab会跟上一行自动的对齐。

• 如何更巧妙的拼接一个字符串。

    1，先把最终的结果写在字符串中。
  
    2，把其中有可能发生变化的值用变量替代
  
    3，固定套路,把变量挪到外面
  

8，生成随机数

生成随机数的代码，Java已经帮我们写好了，不需要我们自己单独再实现了。

Java写好的这个类叫做Random，所以，我们直接使用这个类就可以了。

使用步骤：

1，导包

2，创建对象

3，获取随机数

案例：

 package com.itheima.demo1;
    //1，导包 --- 告诉虚拟机这个类在哪 --- idea自动生成
    import java.util.Random;
    public class RandomDemo1 {
        public static void main(String[] args) {
            //获取一个随机数，范围：0-10  包含0，不包含10
            //2. 创建对象 ---- 跟虚拟机打个招呼，我要用这个类了。
            Random r = new Random();
            //3.获取随机数 ---- 才是真正生成随机数的代码
            int number = r.nextInt(10);//把随机数的范围写在小括号中
            System.out.println(number);
        }
    }

注意点：

nextInt的小括号中表示了获取随机数的范围。

这个范围一定是从0开始的。但是不包含小括号里面的数字。

nextInt(10)；实际是从0-9之间获取的随机数。

判断技巧：

起始范围一定是从0开始的。

结束范围是到指定的数字结束的，但是不包含小括号中的数字。

案例1：

  //我要从 0 ~ 100 之间获取随机数 （包含0，包含100）
    //2. 创建对象 ---- 跟虚拟机打个招呼，我要用这个类了。
    Random r = new Random();
    
    //3.获取随机数 ---- 才是真正生成随机数的代码
    int number = r.nextInt(101);//把随机数的范围写在小括号中
    
    System.out.println(number);

案例2：

  //  0 ~ 17 之间的随机数 （包含0，但是不包含17）
    Random r = new Random();
    int number = r.nextInt(17);
    System.out.println(number);

案例3：

 // 获取一个 1 ~100之间的随机数。包含1，也要包含100
    Random r = new Random();
    int number = r.nextInt(100) + 1;
    System.out.println(number);

案例4：

 // 获取10个 1 ~100之间的随机数。包含1，也要包含100
    Random r = new Random();
    for (int i = 0; i < 10; i++) {
        int number = r.nextInt(100) + 1;
        System.out.println(number);
    }

注意点：

Random r = new Random(); 这行代码不需要放到循环当中。但是放到循环中，也不会出错。

因为这行代码相当于给虚拟机打个招呼。打招呼，只要打一次就可以了。但是打10次也没错，只不过代码运行的效率会变低。

案例5：

技巧：获取任意数到任意数之间的随机数

//获取1个 5 ~ 10 之间的随机数。包含5，也要包含10
Random r = new Random();
//推荐一个方法：
//小技巧
//用于求任意数到任意数之间的随机数
//  5 ~ 10
//1，头尾都减去一个值。让这个范围从0开始。 -5
// 0 ~ 5
//2，尾巴 + 1   // 5 + 1 = 6  -- 就写在小括号中。
//3. 最终的结果再加上第一步减去的值 
int number = r.nextInt(6) + 5;
System.out.println(number);

案例6：

//求 7 ~ 15 之间的随机数  包含7 包含15
Random r = new Random();
//小技巧
//1，头尾都减去一个值。让这个范围从0开始。   -7
// 0 ~ 8
//2，尾巴 + 1      // 8 + 1 = 9
//3. 最终的结果再加上第一步减去的值
int number = r.nextInt(9) + 7 ;
System.out.println(number);

案例7：

//求任意数到任意数之间的随机数
// 获取一个 15 ~ 21之间的随机数 （包含15，也包含21）
// 15 16 17 18 19 20 21
//小技巧：
//1.拿着这个范围减去一个数，让这个范围从0开始。
//15 ~ 21       -15       0 ~ 6
//2.尾巴+1 ----   6 + 1 = 7 --- 7写在nextInt的小括号中。
//3.再加上第一步减去的值。
Random r = new Random();
int number = r.nextInt(7) + 15; 
System.out.println(number);

9，猜数字小游戏

//1，在1~100之间生成一个随机数
Random r = new Random();
//randomNumber就是生成的随机数 --- 50
int randomNumber = r.nextInt(100) + 1;
//相当于是作弊器，把生成的随机数给打印出来。
System.out.println(randomNumber);

//2,键盘录入数字，进行比较。
//键盘录入的数字，就是我们要猜的数字。
Scanner sc = new Scanner(System.in);

//因为不知道次数，所以使用while循环
while(true){
    //键盘录入数字
    System.out.println("老铁，输入一个数字，开始猜吧");
    int guessNumber = sc.nextInt();
    //比较
    if(guessNumber > randomNumber){
        System.out.println("大了");
    }else if(guessNumber < randomNumber){
        System.out.println("小了");
    }else{
        System.out.println("恭喜你，猜中了");
        //如果猜中了，就不需要再猜了，循环结束
        break;
    }
}

注意点：

1，生成随机数的代码一定要写在循环外面。

		如果写在循环里面，那么每次循环都是一个新的随机数，很难猜中。

2，键盘录入的代码一定要写在循环里面。

		如果写在循环外面，那么只能输入一次，在循环的过程中，就不会让你再次输入其他数字了。

下面的代码不需要掌握，了解即可。

public class RandomDemo9 {
    //猜到第3次，必中。
    public static void main(String[] args) {
        //1，在1~100之间生成一个随机数
        Random r = new Random();

        //randomNumber就是生成的随机数
        int randomNumber = r.nextInt(100) + 1;
        System.out.println("当前要猜的数字为" + randomNumber);//33

        //2,键盘录入数字，进行比较。
        //键盘录入的数字，就是我们要猜的数字。
        Scanner sc = new Scanner(System.in);

        //统计猜了多少次。
        int count = 0;

        //因为不知道次数，所以使用while循环
        while (true) {
            //键盘录入数字
            System.out.println("老铁，输入一个数字，开始猜吧");
            int guessNumber = sc.nextInt();//50
            count++;
            if(count == 3){
                System.out.println("恭喜你，猜中了");
                //如果猜中了，就不需要再猜了，循环结束
                break;
            }
            //比较
            if (guessNumber > randomNumber) {
                System.out.println("大了");
            } else if (guessNumber < randomNumber) {
                System.out.println("小了");
            } else {
                System.out.println("恭喜你，猜中了");
                //如果猜中了，就不需要再猜了，循环结束
                break;
            }
        }
    }
}