if语句的格式：
if(条件){
//执行体
}
格式分析：条件：条件的结果必须是boolean类型的，只有两种结果true，或者false。
执行体：如果条件的结果为true，就执行执行体里面的内容，如果条件为false，就不对执行体做任何的操作。
下面的代码对if语句的具体使用进行了演示：
/*
If语句的具体代码体现
*/
public class IfDemo{
public static void main(String[] args){
//定义一个变量i用于下面条件的判断
int i = 6;
//使用if语句对i进行判断
if(i == 6){
System.out.println("if语句中的条件为true执行体执行了");
i++;
}
//打印i的值
System.out.println(i);
}
}代码分析：程序从main函数入口进入，首先定义了变量i，使用if语句对变量i进行判断，i==6条件为true，执行了输出语句，打印了"if语句中的条件为true执行体执行了"，接着i++，变量i的值自增现在为7，if语句结束，接着有一个输出语句打印i的值，结果为7。如果if选语句中的条件为i>6，条件的结果为false，那么执行体中的内容就不会被执行，而是执行if语句下的输出语句打印i的值，结果i的值为6。
if…else语句的结构：
if(条件){
条件为true时要执行的语句（执行语句1）
}else{
条件为false时要执行的语句（执行语句2）
}
结构分析：如果if语句判断条件为true是，就执行执行语句1，如果条件为假，就执行执行语句2。
下面的代码演示了if…else语句的具体实现：
/*
用if...else语句判断一个数的奇偶性
*/
public class IfElseDemo{
public static void main(String[] args){
//定义一个变量i，用于下面的判断
int i = 15;
//用if...else语句判断变量的奇偶性
if(i % 2 == 0){
System.out.println(i+"是偶数");
}else{
System.out.println(i+"是奇数");
}
}
}代码分析：定义一个变量I,对该变量进行接下来的判断，使用if…else语句来对该变量进行奇偶性的判断，如果条件15%2的余数为0，就执行执行语句1，打印15是偶数，如果条件15%2的余数不为0，就执行15是奇数。
if…else if…else if 语句的结构：
if(条件1){
//执行语句1
}else if(条件2){
//执行语句2
}else if(条件3){
//执行语句3
}else{
//执行语句4
}
结构分析：如果条件1的结果为true，就执行执行语句1，如果为false，就对条件2进行判断，条件2的结果为true，就执行执行语句2，如果结果为false，就对条件3进行判断，条件3的结果为true，就执行执行语句三，…如果前面的条件都不成立就执行执行语句4.
下面的代码演示了if else if else if语句的具体体现：
/*
使用if else if else if语句对下面的要求进行判断
有一个成绩，判断成绩的等级，成绩大于80优，成绩大于70良，成绩大于60中，成绩小于60差
*/
public class IfElseIfDemo{
public static void main(String[] args){
//定义一个变量来记录成绩
int score = 90;
//使用if else if else if语句对成绩进行判断
if(score > 80){
System.out.println("优秀");
}else if(score > 70){
System.out.println("良好");
}else if(score > 60){
System.out.println("中等");
}else{
System.out.println("差");
}
}
}代码分析：定义一个变量score记录成绩90，进入判断语句第一个条件，90>80，所以直接执行执行语句打印输出语句的优秀，其他的条件不在进行判断，该代码结束。
if…else语句和三元运算符是可以进行互换的，下面的代码演示了互换的具体实现：
/*
给两个数判断出最大值
分别用if...else和三元运算符的方法实现
*/
public class IfElseDemo_1{
public static void main(String[] args){
//定义两个变量，进行下面的判断
int i = 8;
int j = 6;
//使用if...else语句判断两个变量的最大值
if(i > j){
System.out.println(i+"是最大值");
}else{
System.out.println(j+"是最大值");
}
//使用三元运算符判断其最大值
int k = i > j ? i : j;
System.out.println(k+"是最大值");
}
}代码分析：定义两个变量i=8和j=6，判断8>6,输出8是最大值。然后是三元运算符：定义一个变量k来接收等一下判断的值，8>6吗？大于6就输出i，不大于6就输出j，显然8大于6，所以输出i值，赋值给k，然后打印出8是最大值。
可以实现一段代码的反复执行，while循环的格式如下：
while(条件){
循环体
}
格式分析:首先条件进行判断，如果条件为true，就执行循环体的内容，然后返回继续对条件进行判断，如果为真，就继续执行循环体，知道条件为false，循环才结束。
下面一段代码是对while循环的具体演示：
/*
使用while循环输出整数1到4
*/
public class WhileDemo{
public static void main(String[] args){
//定义一个变量来记录循环的初始值
int i = 1;
//使用while循环对数据进行输出
while(i < 5){
System.out.println(i);
//每次循环i的值加1
i++;
}
}
}代码分析：先定义一个变量来记录循环的初始值1，然后进入while循环，判断1<5,结果为true，执行循环体，打印i的值，然后i的值进行自增，继续进入条件判断，2<5,结果为true，执行循环体….直到i的值为5，进行条件判断，5<5，结果为false，退出while循环。
for循环的格式：
for(初始化变量;条件表达式;操作表达式){
循环体
}
格式分析：初始化变量：定义一个变量来记录该循环的初始值，条件表达式：控制循环语句的循环次数，它的结果为true是，就继续执行循环体，结果为false是，循环结束，操作表达式：对该值进行自增，自减操作，控制值的变化。
执行过程：
1. 先初始化变量值，用来记录循环的初始值，此过程只执行一次。
2. 进入条件表达式，对该表达式进行判断，如果结果为true，就进入循环体，然后返回操作表达式，对该值进行自增自减的操作。然后再回到条件表达式进行判断，结果为true，就继续继续第二步 的操作，直到条件表达式的结果为false，循环才结束。
下面的代码演示了for循环的具体体现：
/*
使用for循环打印出1到10的数字
*/
public class ForDemo{
public static void main(String[] args){
//for循环，初始化变量，控制循环次数，变量的自增操作
for(int i = 1;i < 11;i++){
System.out.println(i);
}
}
}运行结果：
/*
使用for循环求1~100的和
*/
public class ForTest{
public static void main(String[] args){
//定义一个变量，记录求和后的值
int sum = 0;
//for循环，控制1~100的次数
for(int i = 1;i <= 100;i++){
sum = sum + i;
}
//打印求和后的值
System.out.println(sum);
}
}运行结果：
do…while循环语句的格式：
do{
循环体
}while(条件);
结构分析（执行过程）：首先循环体会先执行一次，然后再进行条件判断，结果为true时，继续执行循环体中的内容，然后再进行条件判断，直到结果为false时，循环才结束。do…while循环最大的一个特点就是无论条件是真是假，循环体都会无条件执行一次。
下面的代码演示了do…while功能的具体实现：
/*
使用do...while循环打印1~4的值
*/
public class DoWhileDemo{
public static void main(String[] args){
//定义一个变量来初始化循环的初始值
int i = 1;
//do...while循环 打印1~4的值
do{
//打印i的值
System.out.println(i);
//对i的值进行自增操作
i++;
}while(i < 5);
}
}运行结果：
所谓死循环就是一直在执行，不会停下。
下面的代码演示了while和for循环死循环的具体实现：
/*
while和for循环的死循环代码的实现
*/
public class WhileForDemo{
public static void main(String[] args){
//while循环的死循环
/*while(true){
}*/
//for循环的死循环
for(;;){
}
}
}通俗来讲嵌套循环就是循环中套循环，最常用的是for循环的嵌套。
for循环嵌套的格式：
for(1初始化变量;2条件表达式;3操作表达式){
for(4初始化变量;5条件表达式;6操作表达式){
循环体
}
}
执行过程：
1. 进入第一个for循环外层循环，1初始化变量
2. 判断2条件表达式，结果为true
3. 进入内层for循环，4初始化变量
4. 判断5条件表达式，结果为true
5. 进入内层循环的循环体
6. 执行6操作表达式
7. 判断5条件表达式，结果为true，重复5到6步的操作，如果为false，返回外层循环3操作表达式
8. 判断2条件表达式，结果为true，重复3到7步的操作，如果为false，退出for循环嵌套
下面用一个代码来演示for循环嵌套的具体体现：
/*
for循环嵌套的代码演示
*/
public class ForForDemo{
public static void main(String[] args){
//for循环的嵌套
for(int i = 1;i<3;i++){
System.out.println("外层循环执行第"+i+"次");
for(int j = 1;j<5;j++){
System.out.println("内层循环执行第"+j+"次");
}
}
}
}运行结果：
*
**
***
****
*****
具体实现功能代码如下：
public class ForForDemo_1{
public static void main(String[] args){
//外层循环控制行数
for(int i=1;i<=5;i++){
//内层循环控制每行的个数
for(int j=1;j<=i;j++){
//打印每列的*
System.out.print("*");
}
//对每行进行换行操作
System.out.println();
}
}
}用于跳出循环的作用，具体的用法见下面的代码：
/*
break关键字的具体实现:跳出循环
*/
public class BreakDemo{
public static void main(String[] args){
int i = 1;
//while死循环
while(true){
//if判断
if(i==3){
break;
}else{
System.out.println(i);
}
i++;
}
}
}运行结果：
Break关键字还有标记的作用，标记可以直接跳出指定的循环。具体代码如下：
/*
break关键字还有标记的作用：跳出指定循环
具体实现功能如下
*/
public class BreakDemo_1{
public static void main(String[] args){
a:for(int i=1;i<4;i++){
for(int j=1;j<7;j++){
System.out.print("j="+j);
//跳出指定的外层循环a
break a;
}
System.out.println("i+"+i);
}
}
}运行结果：
continue关键字的作用是结束本次循环，进入下一次循环。
作用的具体实现如下面代码演示：
/*
continue 关键字的具体作用代码演示
*/
public class ContinueDemo{
public static void main(String[] args){
for(int i=1;i<8;i++){
//判断这个数是否为偶数，如果是就跳出本次循环
if(i%2==0){
continue;
}
System.out.println(i);
}
}
}运行结果：
原文：http://blog.51cto.com/13502869/2046845