一、程序流程控制概述
流程控制語句：可以控制程序的執行流程。主要分成三種類型：順序結構、選擇結構（也稱分支結構）、循環結構。
1、順序結構
①順序結構的概念：是程序中最簡單最基本的流程控制，沒有特定的語法結構，按照代碼的先後順序，依次執行，程序中大多數的代碼都是這樣執行的。總的來說，就是寫在前面的先執行，寫在後面的後執行。
②順序結構的特點：從上往下，依次執行。
③順序結構圖：
例如如下代碼，代碼進入main函數之後，開始從上往下依次執行三個輸出語句。
class ShunXuJieGouDemo {
public static void main(String[] args) {
System.out.println("程序開始了");
System.out.println("我愛Java");
System.out.println("程序結束了");
}
}2、選擇結構
①選擇結構，也稱分支結構。選擇結構有着特定的語法規則，代碼要執行具體的邏輯判斷進行運算，邏輯運算的結果有兩個，所以產生選擇，按照不同的選擇執行不同的代碼。
②選擇結構的類型：在Java中，有兩種選擇結構語句，if語句和switch語句。其中，if語句又有這三種形式。分別是：單分支結構，雙分支結構，多分支結構。
③if語句的三大類型
- 單分支結構。這是最簡單的一種選擇結構，它只是簡單的判斷某個條件是否成立，如果成立就執行一段代碼。語句形式爲：
if(布爾類型表達式)｛
語句一；
……
｝
注：如果if控制的語句體中只有一條語句時，大括號可以省略掉。語句一；
……
｝
執行流程爲：首先判斷布爾類型表達式的結果是true還是false，如果爲true則執行語句一等語句，爲false就不執行。如下圖所示：
- 雙分支結構。雙分支結構是一個標準的，完整的if語句實現形式，它首先判斷某個條件是否成立，如果成立就執行一段代碼，如果條件不成立則執行另一段代碼，語句形式爲：
if(布爾類型表達式){
語句體1
}else{
語句體2
}
執行流程爲：判斷布爾類型表達式中值爲true還是false，如果爲true則執行語句體1，爲false則執行語句體2。如下圖所示：
- 多分支結構：這是if語句嵌套形式的一種，它是多個if語句的嵌套，語句形式如下：
if(布爾類型表達式) {
語句體1;
}else if (關係表達式2) {
語句體2;
}
…
else{
語句體n+1;
}
執行流程是：
a、首先判斷布爾類型表達式的結果是true還是false，爲true是則執行語句體1；
b、如果是false就繼續判斷關係表達式2看其結果是true還是false；
c、如果是true就執行語句體2；
d、如果是false就繼續判斷關係表達式……看其結果是true還是false；
e、……；
f、如果沒有任何關係表達式爲true，就執行語句體n+1。
執行流程如下圖所示：
if語句結構的代碼示例：
import java.util.*;
/*
if語句的三種形式的演示：
if語句分爲三種結構：單分支結構
雙分支結構
多分支結構
*/
public class IfDemo{
public static void main(String[] args){
/*int i = 20;
//if語句的第一種形式：單分支結構
if(i >10){
System.out.println("這是if語句的單分支結構演示");
}*/
//if語句的第二種形式：雙分支結構
/*int a = 10;
int b = 15;
if(a == b){
System.out.println("a和b的值相等");
}
else{
System.out.println("a和b的值不相等");
}*/
/*
if語句的第三種形式：多分支結構
這裏用一個小例子來演示一下if語句的多分支結構。
需求：通過鍵盤錄入一個成績並判斷出成績的等級。
90-100分爲優秀，80-90爲良好，70-80爲中等，60-70爲及格，60分以下不及格。
*/
//創建鍵盤錄入對象。
Scanner scan = new Scanner(System.in);
//錄入數據
Sop("請輸入考試成績：");
int score = scan.nextInt();
//利用多分支結構對輸入的成績進行等級判斷
if(score <0 || score > 100){
Sop("您輸出的成績有誤");//輸入的數據不合理，直接返回輸入錯誤。
}
else if(score >= 90 && score < 100){
Sop("您的考試成績等級爲“優秀”");
}
else if(score >= 80 && score < 90){
Sop("您的考試成績等級爲“良好”");
}
else if(score >= 70 && score < 80){
Sop("您的考試成績等級爲“中等”");
}
else if(score >= 60 && score < 70){
Sop("您的考試成績等級爲“及格”");
}
else{
Sop("您的考試成績等級爲“不及格”，要加油啦！");
}
}
public static void Sop(Object obj){
System.out.println(obj);
}
}④選擇語句的第二種形式：switch語句
相關概念闡述：switch語句專用於實現多分支結構程序，其特點是各分支清晰而直觀。switch語句後面的括號中可以是任何表達式，取其整數部分與各常量表達式比較。其中常量表達式必須是能夠自動轉換爲整型的，如字符型、短整型、枚舉等。語句形式如下：
switch(表達式){
case 常量表達式1：語句1；braek；
case 常量表達式2：語句2；braek；
......
case 常量表達式n：語句n；braek；
default: 語句n+1
}
Switch語句的格式解釋：switch語句中表達式的取值只能爲byte、short、int、char四種類型；case後面跟的是要和表達式進行比較的值；break表示中斷，結束的意思，可以結束switch語句；default語句表示所有情況都不匹配的時候，就執行該處的內容，和if語句的else相似。執行流程圖如下所示：
Switch語句的代碼實例演示：
/*
面試題：
byte可以作爲switch的表達式嗎?可以
long可以作爲switch的表達式嗎?不可以
String可以作爲switch的表達式嗎?Jdk1.7以後可以
案例：
鍵盤錄入一個數據，根據這個數據，我們輸出對應的星期?
鍵盤錄入1,對應輸出星期一
鍵盤錄入2,對應輸出星期二
...
鍵盤錄入7,對應輸出星期日
分析：
1:鍵盤錄入，用Scanner實現
2:判斷我們既可以使用if語句，也可以使用我們要講解的switch語句
注意：
A:遇到左大括號縮進一個tab的位置。
B:關聯不是很大的語句間空行
*/
import java.util.Scanner;
class SwitchDemo {
public static void main(String[] args) {
//創建鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//控制鍵盤錄入數據
System.out.println("請輸入一個數據(1-7):");
int week = sc.nextInt(); //3
//switch判斷語句
switch(week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你輸入的數據有誤");
break;
}
}
}3、循環結構
在Java中，有着三種循環語句：for，while，do……while。
①for循環語句詳解
- for循環的語法格式爲：
for(初始化語句；判斷條件語句；控制條件語句){
......
循環體語句
......
}
- for循環語句流程圖：
- 注意事項：
a、判斷條件語句的結果是一個boolean類型。
b、循環體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。
c、一般來說：有左大括號就沒有分號，有分號就沒有左大括號。
- for循環語句實例代碼演示（統計水仙花數）：
/*
需求：統計”水仙花數”共有多少個
分析：
A:首先必須知道什麼是水仙花數
所謂的水仙花數是指一個三位數，其各位數字的立方和等於該數本身。
舉例：153就是一個水仙花數。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
B:定義統計變量，初始化值是0
C:三位數告訴了我們範圍，用for循環就可以搞定
D:獲取每一個三位數的個，十，百的數據
E:按照要求進行判斷
F:如果滿足要求就計數。
*/
class ForDemo{
public static void main(String[] args) {
//定義統計變量，初始化值是0
int count = 0;
//三位數告訴了我們範圍，用for循環就可以搞定
for(int x=100; x<1000; x++) {
//獲取每一個三位數的個，十，百的數據
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//按照要求進行判斷
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果滿足要求就計數。
count++;
}
}
System.out.println("水仙花數共有"+count+"個");
}
}②while循環語句詳解
while循環語法格式
- 基本格式
while(判斷條件語句) {
循環體語句;
}
- 擴展格式
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
- while循環語句流程圖
- while循環和for循環的區別
a、while循環和for循環可以互換
b、兩者在格式上和使用上有點小區別。for循環中控制條件語句中的變量在循環結束後就不能再被訪問到了。而while循環中還能繼續使用。
c、for循環適合於針對一個範圍判斷進行操作。while循環適合於判斷次數不明確操作。
- while循環代碼演示（依舊使用上例中的水仙花用while循環實現）：
/*
需求：統計水仙花數有多少個
*/
class WhileDemo3 {
public static void main(String[] args) {
//while循環版本
int count = 0;
int y = 100;
while(y<1000) {
int ge = y%10;
int shi = y/10%10;
int bai = y/10/10%10;
int x = ge*ge*ge+shi*shi*shi+bai*bai*bai;
if(x == y) {
System.out.println(x);
count++;
}
y++;
}
System.out.println("1000以內的水仙花數共有"+count+"個");
}
}③do...while循環語句詳解
do…while循環語句基本格式
-
基本格式
do {
循環體語句;
}while((判斷條件語句);
-
擴展格式
初始化語句;
do {
循環體語句;
控制條件語句;
} while((判斷條件語句);
-
do…while循環語句流程圖：
-
do…while代碼演示：
public class DoWhileDemo{
public static void main(String[] args){
int x = 11;
do{
System.out.println("無論如何我都要執行一次");
}while(x < 10);
}
}三種循環語句其實可以完成一樣的功能，也就是說可以等價互換，但是還是有些小區別的：
-
do…while循環至少會執行一次循環體
- for循環和while循環只有在條件成立時纔會去執行循環體
注意事項：
寫循環時，優先考慮for循環，再考慮while循環，最後考慮do…while循環。
⑤循環嵌套結構的使用(如：打印九九乘法表)
/*
需求：在控制檯輸出九九乘法表。
首先我們寫出九九乘法表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
...
1*9=9 2*9=18 3*9=27 ...
注意：
'\x' x表示任意，這種做法叫轉移字符。
'\t' tab鍵的位置
'\r' 回車
'\n' 換行
*/
class ForForTest{
public static void main(String[] args) {
//爲了使用數據，我們從1開始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}4、跳轉控制語句
在前面的java概述中，我們就提到過goto在java中是保留字，目前不能使用。沒有了goto語句雖然增強了安全性，但在我們想知道某個循環在執行到哪一步就結束的時候卻帶來了不方便。爲了彌補這個缺陷，java提供了break，continue和return來實現控制語句的跳轉和中斷。
- break：中斷
- continue：繼續
- return：返回
①break概述
break的使用場景：
- 在選擇結構switch語句中
- 在循環語句中
- 離開使用場景的存在是沒有意義的
break的作用：
- 跳出單層循環
- 跳出多層循環
記住：
a、當break語句單獨存在時，下面不要定義其它語句，因爲執行不到，
b、break跳出所在的當前循環
c、如果出現了循環嵌套，break想要跳出指定的循環，可以通過標號來實現。
②continue概述
continue的使用場景：
- 在循環語句中
- 離開使用場景的存在是沒有意義的
continue的作用：
- 單層循環時對比break
- 也可以帶標籤的使用。
③return：return關鍵字不是爲了跳出循環，更常用的功能是結束一個方法，也就是退出一個方法。跳轉到上層使用的方法。
二、一維數組
1、數組的概念
a、定義數組：是同一類型數據的集合，其實數組就是一個容器。數據既可以存儲基本數據類型，也可以存儲引用數據類型。b、數組的好處：可以自動給數組中的元素進行編號，方便操作這些元素。
- 元素類型 [] 數組名 = new 元素類型 [元素的個數或者數組長度]。eg：int [] arr = new int [5]；
- 元素類型 [] 數組名 = new 元素類型 [] ｛元素、元素、……｝。eg：int [] arr = new int [] {3,5,1,7}; int [] arr = {3,5,1,7};
2、數組的初始化
java中的數組必須進行初始化才能使用。所謂初始化，就是爲數組中的元素分配內存空間，併爲每個數組元素賦值。數組的初始化方式：
a、動態初始化：初始化時只指定數組長度，由系統爲數組分配初始值。
b、靜態初始化：初始化時指定每個元素的初始值，由系統決定數組長度。
3、java中的內存分配
java中的內存分爲：寄存器，本地方法區和方法區a、棧內存：存儲的都是局部變量，而且變量所屬的作用域一旦結束，該內存自動釋放。
b、堆內存：存儲的都是數組和對象（其實數組就是對象），凡是new建立的都存儲在這裏。
堆內存的特點：
①每一個實體都有着地指值。
②堆內存中的每一個變量都有着默認初始化值，根據類型的不同而不同。
③垃圾回收機制。
4、java中的數組操作
對數組操作最基本的動作就是存和取，核心思想就是對角標的操作。數組常見操作演示：
/*
數組常見操作演示
*/
class ArrayTest {
public static void main(String[] args) {
//定義數組
int[] arr = {11,22,33,44,55};
/*********************1、獲取數組元素*********************************/
//通過數組角標一個一個獲取
System.out.println(arr[0]);
//通過循環獲取
for(int x=0; x<arr.length; x++) {
//x=0,1,2,3,4
System.out.println(arr[x]);
}
//改進方法,這樣輸出[11,22,33,44,55]
System.out.print("[");
for(int x = 0;x < arr.length;x++){
if(x == arr.length-1)
System.out.println(arr[x]+"]");//最後一個元素。
else{
System.out.print("arr:"+arr[x]+",");
}
}
/*********************2、獲取數組最大值or最小值*********************************/
/*
思路：找一個元素作爲參照，然後遍歷數組，依次獲取元素與參照進行比較，大（小）
則保留，小（大）則離開，最後參照物裏保存的就是最大（小）值
*/
int max = arr[0];
for(int x = 0;x < arr.length;x++){
if(arr[x]>max)
max = arr[x];
}
int min = arr[1];
for(int x = 0;x < arr.length;x++){
if(arr[x]<min)
min = arr[x];
}
System.out.println("數組的最大值max爲："+max);
System.out.println("數組的最小值min爲："+min);
/*********************3、逆序輸出數組元素*********************************/
/*
逆序輸出就是把數組元素對調
思路：把0角標與arr.length-1角標元素對調
……
做到arr.length/2即完成對調。
*/
//交換前
System.out.print("交換前：");
printArray(arr);
for(int x = 0;x < arr.length;x++){
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
//交換後
System.out.print("交換後：");
printArray(arr);
}
//爲了操作方便，將數組遍歷封裝成一個方法，以便示範中調用。
public static void printArray(int arr[]){
System.out.print("[");
for(int x = 0;x < arr.length;x++){
if(x == arr.length-1)
System.out.println(arr[x]+"]");//最後一個元素。
else{
System.out.print(arr[x]+",");
}
}
}
}三、二維數組
1、二維數組的概念
二維數組其實就是一個元素爲一維數組的數組。
2、二維數組的格式
- 格式1：int [] [] arr = new int arr [3] [2]。創建一個二維數組，該數組中有3個一維數組，每一個一維數組中有兩個元素。
- 格式2：int [] [] arr = new int [3] [] 。二維數據中有3個一維數組，每一個一維數組都是默認初始化值null。可以對這三個一維數組分別進行初始化。
- 格式3：int [] [] arr = {{1,2,3},{4,5},{6}}
3、二維數組的遍歷
代碼演示如下：
/*
需求：二維數組遍歷
外循環控制的是二維數組的長度，其實就是一維數組的個數。
內循環控制的是一維數組的長度。
*/
class Array2Test {
public static void main(String[] args) {
//定義一個二維數組
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
/************************遍歷方法1************************/
//我們可以發現arr[0] = {1,2,3};所以可以如下進行遍歷
for(int x=0; x<arr[0].length; x++) {
System.out.println(arr[0][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[1].length; x++) {
System.out.println(arr[1][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[2].length; x++) {
System.out.println(arr[2][x]);
}
System.out.println("--------------");
//用循環改進，外循環的長度就是二維數組的長度，內循環的長度是一維數組的長度。
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}4、二維數組練習：打印楊輝三角
代碼演示如下：
/*
需求：打印楊輝三角形(行數可以鍵盤錄入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析：看這種圖像的規律
A:任何一行的第一列和最後一列都是1
B:從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
步驟：
A:首先定義一個二維數組。行數如果是n，我們把列數也先定義爲n。
這個n的數據來自於鍵盤錄入。
B:給這個二維數組任何一行的第一列和最後一列賦值爲1
C:按照規律給其他元素賦值
從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
D:遍歷這個二維數組。
*/
import java.util.Scanner;
class Array2Test2 {
public static void main(String[] args) {
//創建鍵盤錄入對象
Scanner scan = new Scanner(System.in);
//這個n的數據來自於鍵盤錄入。
System.out.println("請輸入一個數據：");
int n = scan.nextInt();
//定義二維數組
int[][] arr = new int[n][n];
//給這個二維數組任何一行的第一列和最後一列賦值爲1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最後1列
}
//按照規律給其他元素賦值
//從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) {
//這裏如果y<=x是有個小問題的，就是最後一列的問題
//所以這裏要減去1
//並且y也應該從1開始，因爲第一列也是有值了
for(int y=1; y<=x-1; y++) {
//每一個數據是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}
//這個時候，要注意了，內循環的變化必須和曾經講過的九九乘法表類似
for(int x=0; x<arr.length; x++) {
for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}四、Java函數（方法）
1、函數的概述
定義：方法就是完成特定功能的代碼塊
![]()
3、函數（方法）的重載
a、函數重載的定義：在一個類中，允許存在一個以上的同名函數，只要它們的參數個數或參數類型不同即可。
b、函數重載的注意事項：
定義：方法就是完成特定功能的代碼塊
- 在很多語言中都有函數的定義
- 函數在java中被稱爲方法
修飾符 返回值類型 方法名(參數類型 參數名1，參數類型 參數名2…) {
函數體;
return返回值;
}
①方法的格式說明：- 修飾符：修飾符後面會詳細解釋。
- 返回值類型：用於限定返回值的數據類型。
- 方法名：一個名稱，爲了方便我們調用方法。
- 參數類型：限定調用方法時傳入參數的數據類型。
- 參數名：是一個變量，接收調用方法時傳入的參數。
- 方法體：完成功能的代碼。
- return：結束方法以及返回方法指定類型的值。
- 返回值：程序被return帶回的結果，返回給調用者。
- 這個功能的結構是什麼，即明確返回值類型，明確方法結果的返回值類型。
- 這個功能實現過程中是否需要未知內容參與運算，即明確參數列表，明確有幾個參數及參數的類型。
- 方法不調用不執行。
- 方法與方法是平級關係，不能循環調用。
- 方法定義的時候參數之間用逗號隔開。
- 方法調用的時候不用再傳遞數值類型。
- 如果方法的返回值類型不是void，則一定要有return返回一個值。
3、函數（方法）的重載
a、函數重載的定義：在一個類中，允許存在一個以上的同名函數，只要它們的參數個數或參數類型不同即可。
b、函數重載的注意事項：
- 同一個類
- 同名
- 參數個數不同或者參數類型不同
- 函數重載和返回值類型無關
- java是嚴謹性語言，如果函數出現調用的不明確性，會編譯失敗。