和其他編程語言一樣，Java中的程序流程控制是通過：條件語句、選擇語句以及循環(huán)語句來控制的。具體總結如下：
在總結每一種語句之前，先說明一個知識點：語句塊。
語句塊：
也稱作用域，是指由一對花括號（即{ }）括起來的若干條語句。語句塊確定了成員的作用域，表示這些語句的使用范圍。當然，語句塊中還可以嵌套其他語句塊。
一、判斷結構
1、格式：
判斷結構是if語句，它有三種結構：
1、格式一：
if (布爾型表達式)
{
執(zhí)行語句
}
如果布爾型表達式的值為true（或者說條件為真），則執(zhí)行{}中的語句，否則不執(zhí)行。
2、格式二：
if (布爾型表達式)
{
執(zhí)行語句1
}
else
{
執(zhí)行語句2
}
如果布爾型表達式的值為true（或者說條件為真），則執(zhí)行if后{}中的語句1，否則執(zhí)行else后{}中的語句2。
3、格式三：
if (布爾型表達式1)
{
執(zhí)行語句1
}
else if (布爾型表達式2)
{
執(zhí)行語句2
}
else
{
執(zhí)行語句3
}
如果布爾型表達式1的值為true（或者說條件為真），則執(zhí)行if后{}中的語句1，然后退出這個結構；不滿足的話，檢查是否滿足布爾型表達式2，滿足的話就執(zhí)行else if后{}中的語句2，然后退出這個結構，否則就執(zhí)行語句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是可以的，結果為正數(shù)。")
}
else if (x < 0)
{
System.out.println("3/x是可以的，結果為負數(shù)。")
}
else
{
System.out.println("別想了，3/x是不可以的。");
}
}
}
二、選擇結構
1、格式：
switch (表達式)
{
case 取值1:
執(zhí)行語句;
break;
case 取值2:
執(zhí)行語句;
break;
......
default :
執(zhí)行語句;
break;
}
2、switch特點：
1、表達式不可為布爾型表達式
2、case的取值只能為byte、short、int、char以及字符串、枚舉等六種類型，
注：在JDK1.5中還因為出現(xiàn)了枚舉，也可以在switch中應用此類型。
3、case與default沒有必然的順序，要先執(zhí)行case，執(zhí)行從上向下執(zhí)行，沒有找到匹配的case執(zhí)行default。
4、結束switch語句的兩種情況：遇到break或者執(zhí)行到switch結尾結束。
5、如果沒有break，每個case都會判斷一次，如果不符合表達式的值，則繼續(xù)判斷下面的case取值，如果滿足表達式的值，執(zhí)行完當前語句后，會繼續(xù)判斷并執(zhí)行后面全部的語句，直到switch語句結束。
3、if和switch的選擇：
1、選擇if：運算結果為布爾型的，含有判斷區(qū)間的，或其他情況下使用if。使用范圍更廣。
2、選擇switch：判斷少量具體數(shù)值，類型僅為byte、short、int和char和字符串的時候。因為當加載switch的時候，這些數(shù)據會全進內存。效率相對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、循環(huán)結構
對于循環(huán)結構，有三種形式：while、do while、for。
1、while循環(huán)
格式：
//定義初始化表達式;
while (條件表達式)
{
循環(huán)體（執(zhí)行語句）;
}
特點：先執(zhí)行一次循環(huán)體，然后再進行判斷，如果滿足繼續(xù)，不滿足退出。循環(huán)體至少被執(zhí)行一次。
3、for循環(huán)
1、格式：
//格式一
for (初始化表達式;循環(huán)條件表達式;循環(huán)后操作表達式)
{
執(zhí)行語句;
}
//格式二
初始化表達式;
for (;循環(huán)條件表達式;)
{
執(zhí)行語句;
（循環(huán)后操作表達式）
}
說明：對于格式一，初始化表達式中如果有變量，是局部變量，存在于棧內存中，循環(huán)結束，隨之消亡。而對于格式二，則不同，作用域是存在于for外面的語句塊中。注：初始化表達式只讀一次，判斷是否滿足循環(huán)條件表達式，滿足則進行循環(huán)。
4、無限循環(huán)的最簡單形式：
for(;;){}
while(true){}
四、循環(huán)的選擇
1、對于for循環(huán)和while循環(huán)的使用：
對于變量：變量有自己的作用域，如果將控制循環(huán)的增量定義在for語句中，那么變量只在for循環(huán)中作用，for循環(huán)結束，該變量在內存中被釋放。
對于循環(huán)的選擇：
先看一看一個小程序需求：Hotpo游戲：
???????Hotpo是Half Or Triple Plus One（半數(shù)或3倍加1）的簡寫。規(guī)則為：一個自然數(shù)，如果是偶數(shù)，就減去它的一半；如果是奇數(shù)，就3倍這個數(shù)再加1。一直這樣計算下去，直到值到達1。
編寫一個程序，設定一個初始值，并讓這個循環(huán)打印這個序列中的每個數(shù)，連同當前步驟號，如3的輸出結果將是：
Step #1： 10
Step #2： 5
Step #3： 16
Step #4： 8
Step #5： 4
Step #6： 2
Step #7： 1
那么，這個程序應該使用一個for循環(huán)，還是使用一個while循環(huán)呢？
我想，大家在用for循環(huán)寫程序的時候就會發(fā)現(xiàn)，for中的條件確定為多少呢。好，這就引出了我這篇文章的主題了：
當我們事先知道將要對該循環(huán)的主體循環(huán)多少次的時候，最好是使用for循環(huán)，這樣for中的條件就可以確定了。如果在循環(huán)執(zhí)行完之前一直不知道主體循環(huán)了多少次，那么，現(xiàn)在最好就要用while了。當然，我們同樣可以用兩個循環(huán)完成某些程序，這沒有錯與對的分別，只有更合適與否之分。
好啦，下面是我為大家分享的一段程序：
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之間的自然數(shù)都符合這個結果。下面是我為大家分享的角谷猜想的程序：
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循環(huán)結束后，i會被銷毀，不再存在于內存之中，因此內存會得到優(yōu)化。而while循環(huán)中的j是依然存在的，因為j是在循環(huán)外定義的。所以：
如果變量只是作為循環(huán)中的增量存在，控制循環(huán)的次數(shù)，那么，用for循環(huán)式更好些的，利于內存的優(yōu)化。如果此變量在后面的程序中仍然需要，用while較好；當然，也可以用for循環(huán)，只是要像第三個循環(huán)一樣，將變量定義在for循環(huán)之外，同樣是可行的。
五、函數(shù)
1、函數(shù)的概述：
函數(shù)也稱為方法，是定義在類中的具有特定功能的一段獨立的小程序。函數(shù)可以實現(xiàn)某些特定的功能。
1、定義函數(shù)的體現(xiàn)：
在寫程序時，發(fā)現(xiàn)運算中獲取不同數(shù)據的運算結果，總是重復使用一些代碼，為了提高代碼的復用性，就對代碼進行了抽取。
將這個抽取的部分定義為一個獨立的功能，方便日后重復使用。這就是函數(shù)的體現(xiàn)形式。
2、函數(shù)的格式：
修飾符 返回值類型 函數(shù)名(參數(shù)類型 形式參數(shù)1,參數(shù)類型 形式參數(shù)2,......)
{
執(zhí)行語句;
return 返回值;
}
返回值類型：函數(shù)運行后的結果的數(shù)據類型
參 數(shù) 類 型：是形式參數(shù)的數(shù)據類型，就是傳入的數(shù)據的類型
形 式 參 數(shù)：是一個變量，用于存儲調用函數(shù)時傳遞給函數(shù)的實際參數(shù)
實 際 參 數(shù)：傳遞給形式參數(shù)的具體數(shù)值
return ：用于結束函數(shù)運行的語句，表示函數(shù)執(zhí)行完畢
返 回 值 ：該值將返回給調用者，即函數(shù)實現(xiàn)功能需要獲得的數(shù)據。
說明：當函數(shù)運行完，沒有具體的返回值，這時的返回值類型可以用一個特殊的關鍵字來表示，即void，它代表的是函數(shù)沒有具體的返回值的情況。此時，函數(shù)中的return可以省略不寫。
3、何時定義函數(shù)：
1）首先要明確函數(shù)的功能，這個功能實現(xiàn)的運算結果是什么
???其實就是在明確返回值類型
2）在定義函數(shù)功能的過程中需要明確是否含有位置內容參與運算
???其實就是在明確函數(shù)的參數(shù)列表（參數(shù)類型和參數(shù)個數(shù)）
示例：
/*
需求：打印a ~ b 中每個數(shù)與c的乘積
分析：明確功能的結果：打印運算結果，返回類型無，為void
在實現(xiàn)功能的過程中是否有位置內容：有，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)//十個數(shù)換一次行
{
j++;
System.out.println(" ");
}
}
}
2、函數(shù)的特點：
1、定義函數(shù)可以將功能代碼進行封裝，體現(xiàn)了java的封裝性
2、定義函數(shù)可以提高代碼的復用性，便于使用，可對功能進行復用
3、函數(shù)需要被調用才能被執(zhí)行，否則就是一段代碼
4、無返回值類型的函數(shù)用void修飾，則可以省略函數(shù)中的return
5、函數(shù)中不可以定義函數(shù)（內部類除外），但函數(shù)間可以相互調用。
3、函數(shù)的重載：
1、定義：在同一個類中，允許存在一個以上的同名函數(shù)，只要他們的參數(shù)個數(shù)或者參數(shù)類型不同即可。
2、特點：與返回值類型無關，只看參數(shù)列表。
3、好處：方便與閱讀，優(yōu)化了程序設計。
4、重載解析：編譯器對于重載的方法會進行選擇，，匹配出相應的方法，如果編譯器找不到匹配的參數(shù)，或者找出了多個可能的匹配函數(shù)，那么就會產生編譯錯誤。
示例：
//定義函數(shù)，求兩個數(shù)的和
public static int add(int a,int b)
{
return a+b;
}
//定義函數(shù)，求三個數(shù)的和
public static int addT(int a,int b,int c)
{
return add(a,b)+c;
}
