和其他编程语言一样，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);  
          
    }  
}

运行后会报错：

Paste_Image.png

因为变量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;  
}