1、for循环
 
（1）for 循环有一个基本固定的写法,for(int i = 0; i < 10; i++)，类似这样
 
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i);//循环十次，打印 i
            }
 
（2）for 循环简单应用，求 [0-100] 的偶数累加和：
 
			int sum = 0;//用于存结果
            for (int i = 0; i <= 100; i++)
            {
                if (i % 2 == 0)//判断是否为偶数
                {
                    sum += i;//与sum = sum + i 写法等同
                }
            }
 
（3）for 循环嵌套，经典百鸡百钱问题
 
问题：5文钱一只公鸡，3文钱1只母鸡，1文钱3只小鸡，总共100文钱要买100只鸡，小鸡不能分开买，输出所有可能的组合。
 
      for (int i = 0; i < 21; i++)//i表示公鸡的数量
        {
            for (int j = 0; j < 34; j++)//j表示母鸡的数量
            {
                int k = 100 - j - i;//k表示小鸡的数量
                if (i * 5 + j * 3 + k / 3 == 100 && k % 3 == 0)
                {
                    Console.WriteLine("公鸡{0} ,母鸡{1},小鸡{2}", i, j, k);
                }
            }
        }
 
 
 
2、while循环
 
		   int i = 0;
           while (i <= 100)
            {
                Console.WriteLine(i);//循环打印 i
            }
 
while循环中还有一种do while 循环
 
            int i = 0;
            do
            {
                Console.WriteLine(i);
                i++;
            } while (i < 0);
 
 
可以看出，do while循环，是先执行内部语句，再判断执行条件，所以说，即便一开始执行条件就不满足，也会执行一次内部语句
 
 
3、使用关键字跳出循环
 
（1）break 跳出当前所在循环
 例如
 
           int j = 0;
            for (int i = 0; i < 10; i++)
            {
                for (; j < 10; j++)
                {
                    if (j == 5)
                    {
                        break;
                    }
                }
                Console.WriteLine(j);
            }
 

 从上面的例子可以看出来break 的作用，是跳出当前所在的循环，如果是在嵌套中内层循环中使用，则只会跳出内层循环，外层循环仍然继续执行。
 
（2）continue 跳出本次循环
 
  			for (int i = 0; i <= 5; i++)
            {
                if (i == 3)
                {
                    continue;
                }
                Console.WriteLine(i);
            }
 

 从输出的的结果可以看出，程序遇到continue就不会执行本次循环中的其他语句，而是跳到下一次循环
 
（3）return 跳出整个方法或者函数
 
return与break有很大区别
 
           for (int i = 0; i <= 5; i++)
            {
                if (i == 3)
                {
                    return;
                }
                Console.WriteLine(i);
            }
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(i);
            }
 

 可以看出来，程序遇到return，其他的语句都不会执行，因为return是直接跳出整个方法或者函数，第二个for循环，虽然是和第一个for循环同级，但都处于同一个主函数内，所以不会执行

跳出while循环的三种方法（以Python代码为例）
 


 
文章目录
 
跳出while循环的三种方法（以Python代码为例）
方法1: break语句
方法2: 标志位
方法3: 判断不结束
   
  
 


 在《Python编程从入门到实践》书中有这么一道习题：
比萨配料: 编写一个程序，提示用户输入一系列的比萨配料，并在用户输入’quit’时结束循环，说我们会在比萨中添加这种配料。
 
这道题主要考察while循环。
 
方法1: break语句
 
# 方法1
pizza = []
while True:
    message = input("你要加入什么佐料？")
    if message == 'quit':
        break

    pizza.append(message)
    print("已加入" + message)

print(pizza)
 
方法2: 标志位
 
# 方法2
active = True
pizza = []
while active:
    message = input("你要加入什么佐料？")
    if message == 'quit':
        active = False
    else:
        pizza.append(message)
        print("已加入" + message)

print(pizza)
 
方法3: 判断不结束
 
# 方法3
message = ""
pizza = []
while message != 'quit':
    message = input("你要加入什么佐料？")
    if message != 'quit':
        pizza.append(message)
        print("已加入" + message)

print(pizza)
 
我在这里简单的写一下，这算是基本原理吧。实际应用可能更加复杂。但要有这些思路和小技巧。希望能对你有些启发。
 
一个简单的运行示例：
 

 
目录
 
1：while循环简介
2：指定条件的三种形式
2.1：直接使用条件表达式式来作为指定条件的判断
2.2：使用变量来作为指定条件的判断
2.3：使用标志的方法作为指定条件的判断
 

 
1：while循环简介
 
当条件没有满足指定条件的时候，循环体一直执行，当满足循环指定条件的时候循环体停止执行
语法：
 
a = 1
while a < 5:
    print(a)
    a += 1
------------------------------------
输出：
1
2
3
4 
 
2：指定条件的三种形式
 
2.1：直接使用条件表达式式来作为指定条件的判断
 
语法：
 
a = 1
b = 2
while a + b < 10:
    print(a + b)
    a += 2
    b += 2
--------------------------------------------
输出：
3
7
 
2.2：使用变量来作为指定条件的判断
 
语法：
 
a = 1
b = 2
c = a + b
while c < 10:
    print(c)
    a += 2
    b += 2
-----------------------------------------
输出：
3
7
 
2.3：使用标志的方法作为指定条件的判断
 
语法：
 
a = 1
b = 2 
c = a + b
sign = True
while sign:
    print(c)
    if c < 10:
        pass
    else:
        sign = False
------------------------------------
输出：
3
7

       流程控制对任何一门编程语言都是至关重要的，它为我们提供了控制程序步骤的基本手段。常见对主要分为，条件语句、循环语句、跳转语句。
 
1、if语句
 
if 语句是一种判断语句。
 
语法：
 
if(条件){
    条件成立时执行的代码
}
 
 
 
if...else 语句当条件成立时，则执行 if 部分的代码块； 条件不成立时，则进入 else 部分。例如，如果一个月天数大于 30 天，则为大月，否则为小月。
 
语法：
 
if(条件){
    代码块1
}
else{
    代码块2
}
 
 
 
多重 if 语句，在条件 1 不满足的情况下，才会进行条件 2 的判断，以此向下；当前面的条件均不成立时，最终执行 else 块内的代码。
 
语法：
 
if(条件1){
    代码块1
}
else if(条件2){
    代码块2
}
...
else {
    代码块n
}
 
 
 
 
 
注意：如果 if（或 else if，或 else) 条件成立时的执行语句只有一条，是可以省略大括号的！但如果执行语句有多条，那么大括号就是不可或缺的。
 
 
比如：
 
int days = 31;
if(days > 30)
    System.out.println("本月是大月");
else
    System.out.println("本月是小月");
 
if 语句是可以在内层进行嵌套的。嵌套 if 语句，只有当外层 if 的条件成立时，才会判断内层 if 的条件。
 
语法：
 
if(条件1){
    if(条件2){
        代码块1
    }
    else{
        代码块2
    }
}
else{
    代码块3
}
 
 
 
if 语句练习：小明考了 78 分，60 分以上及格，80 分以上为良好，90 分以上为优秀，60 分以下要重考，编写源代码 ScoreJudge.java，输出小明的情况。
 
参考代码如下：
 
public class ScoreJudge {
    public static void main(String[] args){
        int score = 78;
        if(score >= 60){
            if(score >= 80){
                if(score >= 90){
                    System.out.println("成绩优秀");
                }
                else{
                    System.out.println("成绩良好");
                }
            }
            else{
                System.out.println("成绩及格");
            }
        }
        else{
            System.out.println("需要补考");
        }
    }
}
 
 
 
注：所有的条件语句都是利用条件表达式的真或假来决定执行路径，Java 里不允许将一个数字作为布尔值使用，虽然这在 C 和 C++ 是允许的，如果要在布尔测试里使用一个非布尔值，需要先用一个条件表达式将其转换成布尔值，其他控制语句同理。
 
 
编译执行：
 
$ javac ScoreJudge.java
$ Java ScoreJude
成绩及格
 
2、switch 语句
 
当需要对选项进行等值判断时，使用 switch 语句更加简洁明了。比如：摇号摇到 1 的得一等奖，摇到 2 的得二等奖，摇到 3 的得三等奖，摇到其他的没有奖。
 
语法：
 
switch(表达式){
    case 值1:
        代码块1
        break;
    case 值2:
        代码块2
        break;
    ...
    default:
        默认执行的代码块
}
 
当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。
 
defualt 块不是必须的，默认为空。
新建一个源代码文件Draw.java。
 
public class Draw {
    public static void main(String[] args){
        int num = 2;
        switch(num){
        case 1:
            System.out.println("恭喜你，获得了一等奖");
            break;
        case 2:
            System.out.println("恭喜你，获得了二等奖");
            break;
        case 3:
            System.out.println("恭喜你，获得了三等奖");
            break;
        default:
            System.out.println("很遗憾，下次再来");
        }
    }
}
 
编译运行：
 
$ javac Draw.java
$ java Draw
恭喜你，获得了二等奖
 
while 和 do-while 语句
 
3、while语法：
 
while(条件){
    代码块
}
 
while 的执行过程是先判断，再执行。
 
判断 while 后面的条件是否成立 ( true or false )
当条件成立时，执行循环内的代码。
然后重复执行 1、2， 直到循环条件不成立为止。
 
 
4、 do-while 语法：
 
do{
    代码块
}while(条件);
 
do-while 的执行过程是先执行一次，再循环判断（所以循环内的代码至少会执行一次）。
 
先执行一遍循环操作，然后判断循环条件是否成立。
如果条件成立，继续执行1、2，直到循环条件不成立为止。
 
 如：
 
int i = 0;
while(i < 100){
    System.out.println("I love ShiYanlou!");
    i++;
}
 
int i = 0;
do {
    System.out.println("I love ShiYanlou!");
    i++;
} while(i < 100);
 
练习：分别用 while 和 do-while 两种方法，编写代码，文件名为： SumOfEven.java。实现计算 1-1000 中所有偶数的和，并输出。验证一下两种方法你输出的结果是一致吗？
 
参考代码如下：
 
public class SumOfEven {
    public static void main(String[] args){
        int i1 = 1, i2 = 1;
        int sum1 = 0, sum2 = 0;

        while (i1 <= 1000){     //循环1000次
            if(0 == i1 % 2){   //判断是否为偶数
                sum1 += i1;    //将偶数加入到总数里
            }
            i1++;              //i自增1
        }
        System.out.println("用while，1到1000中，所有偶数的和为："+sum1);

        do {
            if (0 == i2 % 2){   //在条件语句中，将数值写在前面是为了防止将==写成了=
                sum2 += i2;
            }
            i2++;
        } while(i2 <= 1000);
        System.out.println("用do-while，1到1000中，所有偶数的和为："+sum2);
    }
}
 
编译运行：
 
$ javac SumOfEven.java
$ java SumOfEven
用while，1到1000中，所有偶数的和为：250500
用do-while，1到1000中，所有偶数的和为：250500
 
5、for 语句
 
for 语法：
 
for(循环变量初始化①; 循环条件②; 循环变量值操作③){
    循环操作④
}
 
for 相比 while 和 do-while 语句结构更加简洁易读，它的执行顺序：
 
执行循环变量初始化部分（1），设置循环的初始状态，此部分在整个循环中只执行一次。
进行循环条件的判断（2），如果条件为 true，则执行循环体内代码（4）；如果为 false ，则直接退出循环。
执行循环变量值操作部分（3），对循环变量的值进行修改，然后进行下一次循环条件判断（2）。
整个循环的流程可以简化为：
 
(1) -> [(2)->(4)->(3)] -> [(2)->(4)->(3)] -> ... => (2) 结果为 false, 退出循环。
 
 
 例如，计算 100 以内不能被 3 整除的数之和：
 
    int sum = 0; // 保存不能被3整除的数之和
    // 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环
    for (int i = 1;i<=100;i++) {
    // 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除
        if (i % 3 != 0) {
            sum = sum + i; // 累加求和
        }
    }
    System.out.println("1到100之间不能被3整除的数之和为：" + sum);
 
练习：编写代码，文件名为： SumOfEven.java，实现计算 1-1000 中所有偶数的和，并输出。
 
参考代码如下：
 
public class SumOfEven {
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1; i <= 1000; i++){
            if(0 == i % 2){
                sum += i;
            }
        }
        System.out.println("用for，1到1000中，所有偶数和为："+sum);
    }
}
 
编译运行：
 
$ javac SumOfEven.java
$ java SumOfEven
用for，1到1000中，所有偶数和为：250500
 
6、跳转语句
 
break终止循环执行循环体下面的代码 
 return终止循环并且退出循环所在的方法 
 continue终止当前循环,进行下一次循环
 
break 关键字经常用在条件和循环语句中，用来跳出循环语句。
 
continue关键字的作用是跳过循环体中剩余的语句执行下一次循环。 新建一个源代码文件Jump.java。
 
public class Jump{
    public static void main(String[] args){
        //break 练习
        for(int i = 1; i <= 10; i++){
            System.out.println("循环第"+i+"次");
            if(0 == i % 3){
                break;
            }
            if(0 == i % 5){
                System.out.println("我进来了！");
            }
        }
        //continue练习 打印10以内的所有奇数
        for(int i = 1; i <= 10; i++){
            if(0 == i % 2) //判断i是否为偶数
                continue;  //通过continue结束本次循环
            System.out.println(i);
        }
    }
}
 
编译运行：
 
$ javac Jump.java
$ java Jump
循环第1次
循环第2次
循环第3次
1
3
5
7
9
 
练习：打印星期
 
新建一个源代码文件PrintWeek.java。
 
你需要实现当输入 1-7 的数字时返回对应的星期：
 
从控制台获取一个整型参数
当输入数字 1 时输出今天是星期一
当输入数字 2 时输出今天是星期二
以此类推
 
示例：
 
输入：
    1
输出：
    今天是星期一
 
 
提示：java.util.Scanner可以获取控制台输入。
 
Scanner in =new Scanner(System.in);
//获取int值
int x=in.nextInt();
 
 参考答案：
 
import java.util.Scanner;

public class PrintWeek {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //获取int值
        int x = in.nextInt();
        switch (x) {
            case 1:
                System.out.println("今天是星期一");
                break;
            case 2:
                System.out.println("今天是星期二");
                break;
            case 3:
                System.out.println("今天是星期三");
                break;
            case 4:
                System.out.println("今天是星期四");
                break;
            case 5:
                System.out.println("今天是星期五");
                break;
            case 6:
                System.out.println("今天是星期六");
                break;
            case 7:
                System.out.println("今天是星期天");
                break;
        }
    }
}
 
 
以上为流程控制语句的整理笔记。