和其他编程语言一样，Java中的程序流程控制是通过：条件语句、选择语句以及循环语句来控制的。具体总结如下：
在总结每一种语句之前，先说明一个知识点：语句块。
语句块：
也称作用域，是指由一对花括号（即{ }）括起来的若干条语句。语句块确定了成员的作用域，表示这些语句的使用范围。当然，语句块中还可以嵌套其他语句块。
一、判断结构
1、格式：
判断结构是if语句，它有三种结构：
1、格式一：
if (布尔型表达式)
{
执行语句
}
如果布尔型表达式的值为true（或者说条件为真），则执行{}中的语句，否则不执行。
2、格式二：
if (布尔型表达式)
{
执行语句1
}
else
{
执行语句2
}
如果布尔型表达式的值为true（或者说条件为真），则执行if后{}中的语句1，否则执行else后{}中的语句2。
3、格式三：
if (布尔型表达式1)
{
执行语句1
}
else if (布尔型表达式2)
{
执行语句2
}
else
{
执行语句3
}
如果布尔型表达式1的值为true（或者说条件为真），则执行if后{}中的语句1，然后退出这个结构；不满足的话，检查是否满足布尔型表达式2，满足的话就执行else if后{}中的语句2，然后退出这个结构，否则就执行语句3。
2、关于三元运算符：
注：if语句的简写格式为三元运算符，即(布尔型表达式)?表达式1:表达式2。
三元运算符：
好处：可以简化if else代码的书写，
弊端：因为是一个运算符，是有返回值的，必须有接收这个返回值的变量。而if语句运算完可无需结果。
注意：三元运算符的表达式1和2必须有相同的类型。
示例：
class DemoIf
{
public static void main(String[] args)
{
int x = 5;
if (x>0)
{
System.out.println("3/x是可以的，结果为正数。")
}
else if (x < 0)
{
System.out.println("3/x是可以的，结果为负数。")
}
else
{
System.out.println("别想了，3/x是不可以的。");
}
}
}
二、选择结构
1、格式：
switch (表达式)
{
case 取值1:
执行语句;
break;
case 取值2:
执行语句;
break;
......
default :
执行语句;
break;
}
2、switch特点：
1、表达式不可为布尔型表达式
2、case的取值只能为byte、short、int、char以及字符串、枚举等六种类型，
注：在JDK1.5中还因为出现了枚举，也可以在switch中应用此类型。
3、case与default没有必然的顺序，要先执行case，执行从上向下执行，没有找到匹配的case执行default。
4、结束switch语句的两种情况：遇到break或者执行到switch结尾结束。
5、如果没有break，每个case都会判断一次，如果不符合表达式的值，则继续判断下面的case取值，如果满足表达式的值，执行完当前语句后，会继续判断并执行后面全部的语句，直到switch语句结束。
3、if和switch的选择：
1、选择if：运算结果为布尔型的，含有判断区间的，或其他情况下使用if。使用范围更广。
2、选择switch：判断少量具体数值，类型仅为byte、short、int和char和字符串的时候。因为当加载switch的时候，这些数据会全进内存。效率相对if高一些。
示例：
class DemoSwitch
{
public static void main(String[] args)
{
int x = 5;
switch (x)
{
case 3:
case 4:
case 5:
System.out.println("夏季。");
break;
case 6:
case 7:
case 8:
System.out.println("秋季。");
break;
case 9:
case 10:
case 11:
System.out.println("冬季。");
break;
case 12:
case 1:
case 2:
System.out.println("春季。");
break;
default :
System.out.println("无。");
break;
}
}
}
3、循环结构
对于循环结构，有三种形式：while、do while、for。
1、while循环
格式：
//定义初始化表达式;
while (条件表达式)
{
循环体（执行语句）;
}
特点：先执行一次循环体，然后再进行判断，如果满足继续，不满足退出。循环体至少被执行一次。
3、for循环
1、格式：
//格式一
for (初始化表达式;循环条件表达式;循环后操作表达式)
{
执行语句;
}
//格式二
初始化表达式;
for (;循环条件表达式;)
{
执行语句;
（循环后操作表达式）
}
说明：对于格式一，初始化表达式中如果有变量，是局部变量，存在于栈内存中，循环结束，随之消亡。而对于格式二，则不同，作用域是存在于for外面的语句块中。注：初始化表达式只读一次，判断是否满足循环条件表达式，满足则进行循环。
4、无限循环的最简单形式：
for(;;){}
while(true){}
四、循环的选择
1、对于for循环和while循环的使用：
对于变量：变量有自己的作用域，如果将控制循环的增量定义在for语句中，那么变量只在for循环中作用，for循环结束，该变量在内存中被释放。
对于循环的选择：
先看一看一个小程序需求：Hotpo游戏：
Hotpo是Half Or Triple Plus One（半数或3倍加1）的简写。规则为：一个自然数，如果是偶数，就减去它的一半；如果是奇数，就3倍这个数再加1。一直这样计算下去，直到值到达1。
编写一个程序，设定一个初始值，并让这个循环打印这个序列中的每个数，连同当前步骤号，如3的输出结果将是：
Step #1： 10
Step #2： 5
Step #3： 16
Step #4： 8
Step #5： 4
Step #6： 2
Step #7： 1
那么，这个程序应该使用一个for循环，还是使用一个while循环呢？
我想，大家在用for循环写程序的时候就会发现，for中的条件确定为多少呢。好，这就引出了我这篇文章的主题了：
当我们事先知道将要对该循环的主体循环多少次的时候，最好是使用for循环，这样for中的条件就可以确定了。如果在循环执行完之前一直不知道主体循环了多少次，那么，现在最好就要用while了。当然，我们同样可以用两个循环完成某些程序，这没有错与对的分别，只有更合适与否之分。
好啦，下面是我为大家分享的一段程序：
class TestLoop
{
public static void main(String [] args)
{
int n = 3;
int nStep = 0;
while(n !=1)
{
n = (n%2==0)? (n/2) : (3*n+1);
nStep++;
System.out.println("Step #"+nStep+": "+n);
}
}
}
大家看到之后都会觉得很熟悉这个问题，这其实就是角谷猜想，只不过角谷猜想是验证是否3到10000之间的自然数都符合这个结果。下面是我为大家分享的角谷猜想的程序：
public class Jiaogu
{
static int count;
public static void main(String[] args) {
int num = 10000;
for (int i = 3; i <= num; i++)
dispose(i);
System.out.println(count == (num - 3 + 1));
}
public static void dispose(int i) {
i = (i % 2 == 0)?(i / 2):(i * 3 + 1);
if (i != 1) {
dispose(i);
}
else {
count++;
}
}
}
补充：
请看下面的代码：
class Xunhuan
{
public static void main(String [] args)
{
for(int i=0;i<3;i++)
{
System.out.println("i = " + i);
}
System.out.println("i = " + i);
int j = 0;
while(j < 3)
{
System.out.println("j = " + j);
}
System.out.println("j = " + j);
int m=0;
for(;m<3;m++)
{
System.out.println("m = " + m);
}
System.out.println("m = " + m);
}
}
运行后会报错：
因为变量i是在for中定义的，只能存在于for中，当for循环结束后，i会被销毁，不再存在于内存之中，因此内存会得到优化。而while循环中的j是依然存在的，因为j是在循环外定义的。所以：
如果变量只是作为循环中的增量存在，控制循环的次数，那么，用for循环式更好些的，利于内存的优化。如果此变量在后面的程序中仍然需要，用while较好；当然，也可以用for循环，只是要像第三个循环一样，将变量定义在for循环之外，同样是可行的。
五、函数
1、函数的概述：
函数也称为方法，是定义在类中的具有特定功能的一段独立的小程序。函数可以实现某些特定的功能。
1、定义函数的体现：
在写程序时，发现运算中获取不同数据的运算结果，总是重复使用一些代码，为了提高代码的复用性，就对代码进行了抽取。
将这个抽取的部分定义为一个独立的功能，方便日后重复使用。这就是函数的体现形式。
2、函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,......)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型
参 数 类 型：是形式参数的数据类型，就是传入的数据的类型
形 式 参 数：是一个变量，用于存储调用函数时传递给函数的实际参数
实 际 参 数：传递给形式参数的具体数值
return ：用于结束函数运行的语句，表示函数执行完毕
返 回 值 ：该值将返回给调用者，即函数实现功能需要获得的数据。
说明：当函数运行完，没有具体的返回值，这时的返回值类型可以用一个特殊的关键字来表示，即void，它代表的是函数没有具体的返回值的情况。此时，函数中的return可以省略不写。
3、何时定义函数：
1）首先要明确函数的功能，这个功能实现的运算结果是什么
其实就是在明确返回值类型
2）在定义函数功能的过程中需要明确是否含有位置内容参与运算
其实就是在明确函数的参数列表（参数类型和参数个数）
示例：
/*
需求：打印a ~ b 中每个数与c的乘积
分析：明确功能的结果：打印运算结果，返回类型无，为void
在实现功能的过程中是否有位置内容：有，int型的a、b和c
*/
public static void Chengji(int a,int b,int c)
{
int j = 1;
for(a=1;a<=b;a++)
{
int m = c*a;
System.out.print(m + "\t");
if(j == a/10)//十个数换一次行
{
j++;
System.out.println(" ");
}
}
}
2、函数的特点：
1、定义函数可以将功能代码进行封装，体现了java的封装性
2、定义函数可以提高代码的复用性，便于使用，可对功能进行复用
3、函数需要被调用才能被执行，否则就是一段代码
4、无返回值类型的函数用void修饰，则可以省略函数中的return
5、函数中不可以定义函数（内部类除外），但函数间可以相互调用。
3、函数的重载：
1、定义：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
2、特点：与返回值类型无关，只看参数列表。
3、好处：方便与阅读，优化了程序设计。
4、重载解析：编译器对于重载的方法会进行选择，，匹配出相应的方法，如果编译器找不到匹配的参数，或者找出了多个可能的匹配函数，那么就会产生编译错误。
示例：
//定义函数，求两个数的和
public static int add(int a,int b)
{
return a+b;
}
//定义函数，求三个数的和
public static int addT(int a,int b,int c)
{
return add(a,b)+c;
}
