当型
直到型---用的比较少
while循环
for循环
语法结构：
while(布尔表达式){
循环体;
}
/*
特点：
在while里面判断，判断完以后再回到开头在判断(没有break的情况下)
*/
if(布尔表达式){
内容;
}
/*
if里面是判断，判断完继续往下执行
*/
流程如图：
实例：
/**
* 测试while循环
* @author Lucifer
*/
public class TestWhile {
public static void main(String arguments[]){
//计算1+2+3+4+..+100的累加的和(高斯小学就做出来了)
int i = 0;
int sum = 0;
while(i<=100){
sum = sum+i; //第一次i是0进入到结构体，算好赋值给sum
i++;
// break; //如果在这里加了break以后再第一次执行完结构体就会跳出然后到输出语句
}
/*
一个while循环的组成部分：
1.while外层初始化。---在while循环外层定义i的值
2.条件判断。---在while后进行描述
3.执行循环体。---执行结构体里面的内容，在结构题内写出步径迭代
4.goto第二步
执行过程：
1.先执行初始化。---初始化语句
2.执行完初始化之后做判断。---条件判断
3.判断完之后执行循环体。---结构体的内容
4.执行完之后执行步径迭代。
5.goto第二步继续进行条件判断
*/
?
System.out.println(sum);
?
int j = 0;
int nsum = 0;
do{
nsum += j;
j++;
}while(j<=100);
?
System.out.println(nsum);
?
}
}
分析：
while上面给i定义了初始值
while里面写了布尔表达式(这里没有定义i的变化趋势)
在while结构体里面定义了sum的变化和while的变化
特点：
先判断再执行
判断不为true也不会执行
因为while循环的特点是先判断布尔表达式然后执行结构体，执行完毕后回到布尔表达式去判断true和false选择是否执行结构体的模式。
while、if构成了所有系统的核心
语法结构：
do{
内容
}while(布尔表达式);
特点：
无论开始是true还是false，先执行一遍，在进行判断
一开始一定会先跑一遍，不管条件符不符合。
实例：
/**
* 测试while循环
* @author Lucifer
*/
public class TestWhile {
public static void main(String arguments[]){
//计算1+2+3+4+..+100的累加的和(高斯小学就做出来了)
int i = 0;
int sum = 0;
while(i<=100){
sum = sum+i; //第一次i是0进入到结构体，算好赋值给sum
i++;
// break; //如果在这里加了break以后再第一次执行完结构体就会跳出然后到输出语句
}
?
System.out.println(sum);
?
int j = 0;
int nsum = 0;
do{
nsum += j;
j++;
}while(j<=100);
?
System.out.println(nsum);
?
}
}
特点：
支持迭代的一种通用结构，是最有效、最灵活的循环结构
结构简单、清晰、容易些
实例：
/**
* 测试for循环
* @author Lucifer
*/
public class TestFor {
public static void main(String arguments[]){
int sum = 0;
for(int i = 0; i<=100; i++){
sum = sum + i;
}
/*
一个for循环的组成部分：
1.初始化语句。初始化变量的值。
2.条件判断。
3.步径迭代
执行过程：
1.先执行初始化。---初始化语句
2.执行完初始化之后做判断。---条件判断
3.判断完之后执行循环体。---结构体的内容
4.执行完之后执行步径迭代。
5.goto第二步继续进行条件判断
*/
?
System.out.println(sum);
?
}
}
执行步骤是一样的
while循环把执行步骤需要用到的初始化、条件判断、步径迭代分开来写。---初始化写在while外层，条件判断写在while里面，步径迭代写在while结构体里
for循环把执行步骤需要用到的初始化、条件判断、步径迭代放在一起，便于管理
实例：---for循环的死循环和while循环的死循环的区别
?
//无限循环
for( ; ; ){
System.out.println("Lucifer");
}
/*
注意for循环表示true的方式是把初始化、条件判断、步径迭代都不写出
while(true) = for( ; ; )
*/
?
for循环的变量作用域
for循环的初始化变量仅限于for的语句块当中，类似于语句块变量
while循环的初始化值相当于局部变量，在该方法中有效。
定义：
在一个循环语句内部再嵌套一个或多个循环称为嵌套循环(可以嵌套for循环也可以嵌套while循环)
实例：
/**
* This is a practice about how to print multiplication table
* @author Lucifer
*/
public class TestForWhile_Practice_MultiplicationTable {
public static void main(String[] args) {
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();
}
?
int a = 1;
while( a<=9 ){
int b = 1;
while(b <= a){
System.out.print(b + "*" + a + "=" + (a*b) + "\t");
// System.out.println();
b++;
}
System.out.println(); //一行一行的打印
a++;
}
}
}
关键点：
嵌套循环的并不难理解，关键是牢记每一种循环他语句的执行顺序。
循环无非三个条件，循环初始值、条件判断、步径迭代。牢记三种循环他的执行顺序那么嵌套多少层循环都能够解决。
for循环再for后括号内分别定义循环初始值、条件判断、步径迭代。执行步骤：
初始化初始值
进行条件判断
运行结构体内语句
进行步径迭代
进行条件判断
符合条件回到第三步开始继续循环执行
不符合条件跳出for循环执行下一步
while循环的循环初始值是一个局部变量，如果再while循环或者for循环里面嵌套while循环那么它的初始值只能在内层while循环里面生效
实例：
public class WhileCirculation{
/**
* Print a multiplication table
* @author Lucifer
*/
public static void main(String arguments[]){
int i = 1;
while( i <= 9){
int j = 1; //这就是内层while循环的初始值，他只会在内层while代码块里面生效。如果放在外层那么则视为局部变量，在方法里面生效
while( j <= i ){
System.out.print(j + "*" + i + "=" + (i*j) + "\t");
j++;
}
System.out.println();
i++;
}
}
}
执行步骤：
在while外层初始化初始值
进行条件判断
运行结构体
结构体内进行步径迭代
进行条件判断
符合条件回到第三步继续执行
不符合条件开始执行下一步
原文：https://www.cnblogs.com/JunkingBoy/p/14595534.html