一Java的基本語法

1 Java中的關鍵字

關鍵字（Keyword）是編程語言裏事先定義好並賦予了特殊含義的單詞，也稱作保留字。JDK 8中有50個關鍵字，這些關鍵字都是小寫的。

2Java中的標識符

定義：在編程過程中，經常需要在程序中定義一些符號來標記一些名稱，如包名、類名、方法名、參數名、變量名等，這些符號被稱為標識符。

組成：標識符可以由任意順序的大小寫字母、數字、下劃線（_）和美元符號（$）組成，但標識符不能以數字開頭，也不能是Java中的關鍵字。

合法標識符:

   username    username123    user_name    _userName

非法標識符:

   123username // 不能以數字開頭    class // 不能是關鍵字    Hello World // 不能包含空格特殊字符

通用規範:

3 Java中的註釋

作用：在編寫程序時，為了使代碼易於閲讀，通常會在實現功能的同時為代碼添加一些註釋。註釋是對程序的某個功能或者某行代碼的解釋説明，它能夠讓開發者在後期閲讀和使用代碼時能更容易理解代碼的作用。

説明：註釋只在Java源文件中有效，在編譯程序時編譯器會忽略這些註釋信息，不會將其編譯到class字節碼文件中。

(1)單行註釋

單行註釋通常用於對程序中的某一行代碼進行解釋，用符號“//”表示，“//”後面為被註釋的內容。

  int c = 10;      // 定義一個整型變量c

(2)多行註釋

多行註釋顧名思義就是可以同時為多行內容進行統一註釋，它以符號“/*”開頭，並以符號“*/”結尾。

/* 定義一個整形變量x    將5賦值給變量x */    int x;    x = 5;

(3)文檔註釋

文檔註釋通常是對程序中某個類或類中的方法進行的系統性的解釋説明，開發人員可以使用JDK提供的javadoc工具將文檔註釋提取出來生成一份API幫助文檔。文檔註釋以符號“`/”開頭，並以符號“*/`”結尾**。

/**
 * Title：HelloWorld類
 * @author ycy
 * @version 1.0 
 */
public class HelloWorld {
    /**
     * 這是一個main()方法入口
     * @param args 參數名
     */
    public static void main(String[] args){
        System.out.println("這是第一個Java程序！");
    }
}

(4)註釋的嵌套

在Java中，有的註釋可以嵌套使用，有的則不可以

1)多行註釋可以嵌套單行註釋

   /* int c = 10;   // 定義一個整型的c        int x = 5; */

2)多行註釋不能嵌套多行註釋

   /*        /*int c = 10;*/        int x=5;    */

二 變量和常量

1常量

定義：常量就是在程序中固定不變的值，是不能改變的數據。例如數字1、字符'a'、浮點數3.2等。

分類：在Java中，常量包括整型常量、浮點數常量、布爾常量、字符常量等。

(1)整型常量

整型常量是整數類型的數據，有二進制、八進制、十進制和十六進制4種

(2)浮點常量

浮點數常量就是在數學中用到的小數，分為float單精度浮點數和double雙精度浮點數兩種類型。

例如:

   2e3f  3.6d  0f  3.84d  5.022e+23f

注意:

單精度浮點數後面以F或f結尾，而雙精度浮點數則以D或d結尾。當然，在使用浮點數時也可以在結尾處不加任何後綴，此時Java虛擬機會將浮點數默認識別為double雙精度浮點數。

(3)字符常量

字符常量用於表示一個字符，一個字符常量要用一對英文半角格式的單引號（' '）引起來，它可以是英文字母、數字、標點符號以及由轉義序列來表示的特殊字符。

例如:

   'a'  '1'  '&'  '\r'

(4)字符串常量

字符串常量用於表示一串連續的字符，一個字符串常量要用一對英文半角格式的雙引號（" "）引起來。

例如:

   "HelloWorld"   "123"   "Welcome \n XXX" ""

(5)布爾常量

布爾常量即布爾類型的兩個值true和false，該常量用於區分一個條件的真假。

(6)null常量

null常量只有一個值null，表示對象的引用為空。

2轉義符

定義：在字符常量中，反斜槓（\）是一個特殊的字符，被稱為轉義符，它的作用是用來轉義緊隨其後的一個字符。

説明：轉義後的字符通常用於表示一個不可見的字符或具有特殊含義的字符，例如“\n”表示換行。

常見的轉義字符:

3 java中的常量

定義：Java中的常量，其實就是特殊的變量，也是固定不變的量，有且只能進行一次賦值。

語法：Java中定義常量的語法也非常簡單，只需要在定義變量的語法基礎上加上一個final關鍵字修飾即可。

Java中的常量的語法格式：

final 常量類型 常量名 [= 初始值];

例如：

final int a=0, b;     // 定義一個int類型的常量a和b，併為常量a初始化賦值0
    b= 1;       // 後續為常量b賦值

4 變量

定義：在程序運行期間，隨時可能產生一些臨時數據，應用程序會將這些數據保存在一些內存單元中，每個內存單元都用一個標識符來標識。這些內存單元我們稱之為變量，定義的標識符就是變量名，內存單元中存儲的數據就是變量的值。

變量的基本語法格式如下：

變量類型 變量名 [= 初始值];

變量類型:決定了變量的數據性質、範圍、存儲在內存中所佔的字節數以及可以進行的合法操作

變量名:必須是一個合法的標識符

[]:代表可選項，即在定義變量的同時，可以對該變量進行初始化賦值

例如:

   int x = 0,y;    y = x+3;

説明：

上述代碼中，第一行代碼的作用是定義了兩個int類型的變量x和y，也就相當於分配了兩塊內存單元，在定義變量的同時為變量x分配了一個初始值0，而變量y沒有分配初始值。

變量x和y在內存中的狀態變化圖：

5 變量的數據類型

Java是一門強類型的編程語言，它對變量的數據類型有嚴格的限定。在定義變量時必須先聲明變量的數據類型，在為變量賦值時必須賦予和變量同一種類型的值，否則程序在編譯期間就會出現類型匹配錯誤的問題。

在Java中變量的數據類型分為兩種：基本數據類型和引用數據類型。

(1)基本數據類型

基本數據類型總共有8個,也叫作8大基本數據類型

1)整數類型變量

整數類型變量用來存儲整數數值，即沒有小數部分的值。

例如:

long num = 2200000000L;   // 所賦的值超出了int型的取值範圍，後面必須加上字母L
    long num = 198L;          // 所賦的值未超出int型的取值範圍，後面可以加上字母L
    long num = 198;           // 所賦的值未超出int型的取值範圍，後面可以省略字母L

注意:

在為一個long類型的變量賦值時，所賦值的後面要加上一個字母“L”（或小寫“l”），説明賦值為long類型。如果賦的值未超出int型的取值範圍，則可以省略字母“L”（或小寫“l”）。

2)浮點數類型變量

浮點數類型變量用來存儲小數數值

例如:

float f = 123.4f;      // 為一個float類型的變量賦值，後面必須加上字母f或F
    double d1 = 199.3d;    // 為一個double類型的變量賦值，後面可以加上字母d或D
    double d2 = 100.1;     // 為一個double類型的變量賦值，後面可以省略字母d或D
    float f = 100;         // 聲明一個float類型的變量並賦整數值
    double d = 100;        // 聲明一個double類型的變量並賦整數值

注意:

一個小數會被默認為double類型的值，因此在為一個float類型的變量賦值時，所賦值的後面一定要加上字母“F”（或者小寫“f”），而為double類型的變量賦值時，可以在所賦值的後面加上字符“D”（或小寫“d”），也可以不加。

在程序中也可以為一個浮點數類型變量賦予一個整數數值

3)字符類型變量

字符類型變量用於存儲一個單一字符，在Java中用char表示。

Java中每個char類型的字符變量都會佔用2個字節(16位)。

在給char類型的變量賦值時，需要用一對英文半角格式的單引號（' '）把字符括起來，如'a'，也可以將char類型的變量賦值為0~65535範圍內的整數，計算機會自動將這些整數轉化為所對應的字符，如數值97對應的字符為'a'。

例如:

char c = 'a';            // 為一個char類型的變量賦值字符'a'
    char ch = 97;           // 為一個char類型的變量賦值整數97，相當於賦值字符'a'

4)布爾類型變量

布爾類型變量用來存儲布爾值，在Java中用boolean表示，該類型的變量只有兩個值，即true和false。

例如:

boolean flag = false;    // 聲明一個boolean類型的變量，初始值為false
    flag = true;            // 改變flag變量的值為true

(2)引用數據類型

除了8大基本數據類型,其餘全部是引用類型

例如:保存字符串需要用到String類型

String str = "hello world";

6 變量的類型轉換

説明：在程序中，當把一種數據類型的值賦給另一種數據類型的變量時，需要進行數據類型轉換。

分類：根據轉換方式的不同，數據類型轉換可分為兩種：自動類型轉換和強制類型轉換。

(1)自動類型轉換

自動類型轉換也叫隱式類型轉換，指的是兩種數據類型在轉換的過程中不需要顯式地進行聲明。當把一個類型取值範圍小的數值直接賦給另一個取值範圍大的數據類型變量時，系統就會進行自動類型轉換。

自動類型轉換就好比將小瓶水倒入到大瓶的換裝過程。我們將小瓶水倒入到大瓶中時，由於小瓶的容量比大瓶的容量小，所以倒入的水永遠不可能溢出大瓶。

Java中支持的不同數據類型之間的自動轉換，如下圖所示。

例如:

   byte b = 3;    int x = b;         // 程序把byte類型的變量b轉換成了int類型，無需特殊聲明    double y = x;     // 將int類型的變量x轉換成double類型，無需特殊聲明

(2)強制類型轉換

強制類型轉換也叫顯式類型轉換，指的是兩種數據類型之間的轉換需要進行顯式地聲明。當兩種類型彼此不兼容，或者目標類型取值範圍小於源類型時，自動類型轉換無法進行，這時就需要進行強制類型轉換。

強制類型轉換就好比將大瓶水倒入到小瓶中一樣，如果大瓶中的水的容量小於小瓶的大小，那麼水是可以完全倒入的；否則多出來的水就會溢出。所以系統默認不支持這種行為，只能由開發者自己決定是否進行強制類型轉換。

強制類型轉換語法格式：

目標類型 變量名 = （目標類型）值;

例如:

int a = 127;
byte b = (byte)a; //127在byte的存儲範圍內,可以正常強制轉換
int c = 128;
b = (byte)c;//128超出了byte的存儲範圍,強制轉換,數據會丟失

注意：

在對變量進行強制類型轉換時，會發生取值範圍較大的數據類型向取值範圍較小的數據類型的轉換情況，如將一個int類型的數轉為byte類型，這樣做極容易造成數據精度的丟失。

(3)表達式類型自動提升

所謂表達式是指由變量和運算符組成的一個算式。變量在表達式中進行運算時，也有可能發生自動類型轉換，這就是表達式數據類型的自動提升，如byte、short和char類型的變量在運算期間類型會自動提升為int，然後再進行運算。

例如:

byte a = 1;
byte b = 2;
byte c = a+b; //報錯:a和b在進行運算時會自動提升為int,所以a+b的結果是int類型

7 變量的作用域

定義：變量需要在它的作用範圍內才可以被使用，這個作用範圍稱為變量的作用域。

三 運算符

所謂運算符就是專門用於告訴程序執行特定運算或邏輯操作的符號。

1 算術運算符

Java中的算術運算符就是用來處理四則運算的符號。

也是最簡單和最常用的運算符號。

注意:

在進行自增（++）和自減（--）的運算時，如果運算符（++或--）放在操作數的前面則是先進行自增或自減運算，再進行其他運算。反之，如果運算符放在操作數的後面則是先進行其他運算再進行自增或自減運算。

在進行除法運算時，當除數和被除數都為整數時，得到的結果也是一個整數；如果除法運算有小數參與，得到的結果會是一個小數。

在進行取模（%）運算時，運算結果的正負取決於被模數（%左邊的數）的符號，與模數（%右邊的數）的符號無關。

2賦值運算符

賦值運算符的作用就是將常量、變量或表達式的值賦給某一個變量。

它將運算符右邊的值賦給左邊的變量。

在使用+=、-=、*=、/=、%= 賦值運算符時，需要進行的強制類型轉換會自動完成，程序不需要做任何顯式地聲明

public class Example05 {
    public static void main(String[] args) {
        short s = 3;
        int i = 5;
        s += i;
        System.out.println("s = " + s);
    }
}

注意:

在Java中可以通過一條賦值語句對多個變量進行賦值。

在賦值運算符中，除了“=”，其他的都是特殊的賦值運算符，以“+=”為例，x += 3就相當於x = x + 3，首先會進行加法運算x+3，再將運算結果賦值給變量x。其餘的-=、*=、/=、%=賦值運算符都可依此類推。

3 比較運算符

用來對兩個數值或變量進行比較。

其結果是布爾類型的true或false。

4 邏輯運算符

是用於對布爾類型的值或表達式進行操邏輯判斷的符號。

其返回值類型是布爾類型。

注意:

邏輯運算符可以針對結果為布爾值的表達式進行邏輯運算。如：5 > 3 && 1 != 0的結果為true。

運算符“&”和“&&”都表示與操作，當且僅當運算符兩邊的操作數都為true時，其結果才為true，否則結果為false。

“&”和“&&”的區別：在使用“&”進行運算時，不論左邊為true或者false，右邊的表達式都會進行運算。如果使用&&進行運算，當左邊為false時，右邊的表達式不會進行運算，因此“&&”被稱作短路與。

運算符“|”和“||”都表示或操作，當運算符任何一邊的操作數或表達式為true時，其結果為true，當兩邊的值都為false時，其結果才為false。同與操作類似，“||”表示短路或，當運算符“||”的左邊為true時，右邊的表達式不會進行運算。

運算符“^”表示異或操作，當運算符兩邊的布爾值相同時（都為true或都為false），其結果為false。當兩邊布爾值不相同時，其結果為true。

5 條件運算符

也稱作三元運算符（或三目運算符），由符號“? :”組合構成。

對布爾類型的表達式判斷，如果為true，就執行冒號“:”前面的表達式，否者執行後面的表達式。

格式:

(boolean_expr) ? true_statement : false_statement;

規則：先判斷boolean_expr的值，如果為true，就執行表達式true_statement，否者執行表達式false_statement

例如:

   int store = 5;    System.out.println(store <=0 ? "沒有庫存啦！" : "庫存量為："+store);    // 輸出結果為 “庫存量為：5”

6 運算符的優先級

指的是在表達式中各個運算符參與運算的先後順序

例如：先乘除，後加減

四 選擇結構語句

在實際生活中經常需要作出一些判斷，比如開車來到一個十字路口，這時需要對紅綠燈進行判斷，如果前面是紅燈，就停車等候，如果是綠燈，就通行。Java中有一種特殊的語句叫做選擇結構語句，它也需要對一些條件作出判斷，從而決定執行哪一段代碼。

Java中的選擇結構語句分為：if條件語句和switch條件語句

1 if條件語句

if條件語句的分類:

(1)if語句

格式:

if(判斷條件){  滿足條件執行的代碼   }

執行流程:

例如:

如果一個人的年齡不滿18週歲，那麼就可以判定這個人是未成年人

/*
偽代碼:
    if (年齡不滿18歲) {
        此人是未成年人！
    }
*/
int age = 20;
if(age<18){
    System.out.println("此人是未成年人!");
}

(2)if...else語句

格式:

  if (判斷條件){ 執行語句1 ...   }else{ 執行語句2 ...   }

執行流程:

例如:

int age = 16;//定義變量age,保存年齡
        if(age>=18){//年齡大於等於18-->代碼
            //條件成立
            System.out.println("恭喜你,被錄用了");
        }else{
            //條件不成立
            System.out.println("很遺憾,年齡不滿足需求");
        }

注意:

if...else語句還可以與前面學習的條件運算符“？:”進行替換。

System.out.println(num % 2 == 0 ? num+"是一個偶數" :num+"是一個奇數" );

(3)if...else if...else語句

格式:

   if (判斷條件1) {        執行語句1   } else if (判斷條件2) {        執行語句2   }   ...    else if (判斷條件n) {        執行語句n   } else {        執行語句n+1   }

執行流程:

例如:

int num = 100;
        //根據數字輸出對應的星期
        if(num==1){
            System.out.println("星期一");  
        }else if(num==2){
            System.out.println("星期二");
        }else if(num==3){
            System.out.println("星期三");
        }else if(num==4){
            System.out.println("星期四");
        }else if(num==5){
            System.out.println("星期五");
        }else if(num==6){
            System.out.println("星期六");
        }else if(num==7){
            System.out.println("星期天");
        }else{
            System.out.println("無效的星期");
        }

2 switch條件語句

定義：switch 條件語句也是一種很常用的選擇結構語句，它由一個switch控制表達式和多個case關鍵字組成。

説明：與if條件語句不同的是，switch 條件語句的控制表達式結果類型只能是byte、short、char、int、enum枚舉以及String類型，而不能是boolean類型。

格式:

   switch (控制表達式){        case 目標值1:              執行語句1              break;        case 目標值2:  執行語句2  break;        ．．．        case 目標值n:  執行語句n  break;        default:  執行語句n+1  break;   }

規則： switch語句將控制表達式的值與每個case中的目標值進行匹配，如果找到了匹配的值，會執行對應case後的執行語句，並通過break關鍵字跳出該switch語句；如果搜索完所有case中的目標值仍沒找到任何匹配的值，就會執行default後的語句。

注意:

第一，switch條件語句後{}中的多個case以及default標籤順序可以隨機，並不影響程序的執行結果；

第二，在case和default標籤中的執行語句後務必都加上break關鍵字，用於執行完語句後跳出當前的switch條件語句，否則，程序會接着執行後續的執行語句，直到遇到break關鍵字或switch語句末尾為止。

例如:

根據月份判斷當前所屬季節

int month = 9;
switch(month){
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
    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;
    default:
        System.out.println("月份不正確!");
        break;       
}

五 循環結構語句

在實際生活中經常會將同一件事情重複做很多次，例如在做眼保健操的第四節輪刮眼眶時，會重複刮眼眶的動作；打乒乓球時，會重複揮拍的動作等。在Java中有一種特殊的語句叫做循環語句，它可以實現將一段代碼重複執行，例如循環打印100位學生的考試成績。

循環語句的分類:

1 while循環

定義：while循環語句和選擇結構語句有些相似，都是根據條件判斷來決定是否執行大括號{}內的執行語句。

區別：while語句會循環判斷循環條件是否成立，只要條件成立，{}內的執行語句就會執行，直到循環條件不成立，while循環才結束。

格式:

   while(循環條件){         執行語句         ...   }

執行流程:

注意:

一般會通過 一個變量來控制循環條件

循環內容執行後需要對變量進行+1操作

例如:

循環輸出10次"hello world"

int i = 0; //定義一個變量i,控制循環次數
while(i<10){
    System.out.println("hello world");
    i++;//對變量i進行+1操作
}

循環出1-10

int i = 1;//定義一個變量i,控制循環次數
while(i<=10){
    System.out.println(i);
    i++;//對變量i進行+1操作
}

2 do-while循環

定義：do…while循環語句也被稱為後測試循環語句，它和while循環語句的功能類似。

區別：while是先判斷條件後執行循環體，而do...while會無條件執行一次循環體後再判斷條件。

格式:

   do {        執行語句       ...   } while(循環條件);

執行流程:

注意:

一般會通過 一個變量來控制循環條件

循環內容執行後需要對變量進行+1操作

例如:

循環輸出10次"hello world"

int i = 0; //定義一個變量i,控制循環次數
do{
    System.out.println("hello world");
    i++;對變量i進行+1操作
}while(i<10)

循環出1-10

int i = 1;//定義一個變量i,控制循環次數
do{
    System.out.println(i);
    i++;//對變量i進行+1操作
}while(i<=10)

3 for循環

for循環語句是最常用的循環語句，一般用在循環次數已知的情況下，通常情況下可以代替while循環。

格式:

   for（初始化表達式; 循環條件; 操作表達式）{           執行語句           ...   }

執行流程:

例如:

循環輸出10次"hello world"

for(int i=0;i<10;i++){    System.out.println("hello world"); }

循環出1-10

for(int i=1;i<=10;i++){    System.out.println(i); }

對1-10進行求和

int sum = 0;//定義一個變量,保存求和結果 for(int i=1;i<=10;i++){    //累計相加進行求和    sum += i; // sum = sum + i; } System.out.println("1-10的求和結果是:"+sum);

4 循環嵌套

定義：嵌套循環是指在一個循環語句的循環體中再定義一個循環語句的語法結構。

説明：while、do…while、for循環語句都可以進行循環嵌套，並且它們之間也可以互相嵌套。在實際開發時，我們最常用的是for循環嵌套。

雙層for循環:

   for(初始化表達式; 循環條件; 操作表達式) {         ...         for(初始化表達式; 循環條件; 操作表達式) {              執行語句             ...         }         ...   }

規則：在雙層for循環嵌套中，外層循環每執行一輪，都要執行完內層循環中的整個for循環，然後執行外層循環第二輪，接着再執行完內層循環中的整個for循環，以此類推，直至外層循環的循環條件不成立，才會跳出整個嵌套for循環。

例如:

//外層for循環
        for(int i=0;i<3;i++){
            System.out.println("外層for循環:"+i);
            //內層for循環
            for(int j=0;j<3;j++){
                System.out.println("***內層for循環:"+j);
            }
        }

結果:

5 跳轉語句(break/continue)

定義：跳轉語句用於實現循環語句執行過程中程序流程的跳轉。

分類：在Java中的跳轉語句有break語句和continue語句。

(1)continue語句

使用場景：continue語句用在循環語句中。

作用效果：它的作用是終止本次循環，執行下一次循環。

例如:

for(int i=1;i<=10;i++){
            if(i == 3){ //當i的值等於3
                continue; //跳到下一次循環
            }
            System.out.println(i); // 輸出i的值
        }

結果:

(2)break語句

使用場景：在switch條件語句和循環結構語句中都可以使用break語句。

作用效果：

當它出現在switch條件語句中時，作用是終止某個case並跳出switch結構；

當它出現在循環結構語句中時，作用是跳出當前循環結構語句，執行後面的代碼。

例如:

for(int i=1;i<=5;i++){            if(i == 3){ //當i的值等於3                break; //結束當前循環語句           }            System.out.println(i); // 輸出i的值       }

結果:

例如:

//外層for循環
        for(int i=0;i<3;i++){
            System.out.println("外層for循環:"+i);
            //內層for循環
            for(int j=0;j<3;j++){
                System.out.println("***內層for循環:"+j);
                break;//結束當前所在循環:內層for循環
            }
        }

結果:

注意:

break結束的當前所在循環,也就是內層循環,不會影響外層for循環

如果想要在內層for循環中結束外層for循環,可以給for循環取名字

//外層for循環,取名outer
        outer:for(int i=0;i<3;i++){

System.out.println("外層for循環:"+i); //內存for循環,取名inner inner:for(int j=0;j<3;j++){ System.out.println("***內存for循環:"+j); break outer; //結束外層for循環 } }

結果:

6 循環嵌套案例

例1:

//外層控制行
        for(int i=0;i<5;i++){
            // 內層循環控制列
            for(int j=0;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

結果:

例2:

//外層控制行
        for(int i=0;i<5;i++){
            // 內層循環控制列
            for(int j=0;j<5-i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

結果:

六 數組

假設如下場景：

現在需要統計某公司100名員工的工資情況，例如計算平均工資、最高工資等。

可能的辦法：

用前面所學的知識，程序就需要聲明100個變量來分別記住每位員工的工資（這樣的話非常麻煩）。

解決辦法：

可以使用一個數組來記住這100名員工的工資，然後對數組的元素進行操作。

定義：數組是指一組數據的集合，數組中的每個數據被稱作元素。在數組中可以存放任意類型的元素，但同一個數組裏存放的元素類型必須一致。

分類：一維數組和多維數組。

1 格式:

   數組類型[] 數組名 = new 數組類型[數組長度];      數組類型[] 數組名 = new 數組類型[]{數組元素0,數組元素1,...};      數組類型[] 數組名 = {數組元素0,數組元素1,...};

例如:

int[] ids = new int[100];   
    String[] names = new String[]{"張三","tom",...};  
    Object[] object = {"張三","tom",...};

2 數組內存圖

3 不同類型元素的初始值

注意問題

①每個數組的索引都有一個範圍，即0~length-1。在訪問數組的元素時，索引不能超出這個範圍，否則程序會報錯（ArrayIndexOutOfBoundsException，即數組角標越界異常）。

②在使用變量引用一個數組時，變量必須指向一個有效的數組對象，如果該變量的值為null，則意味着沒有指向任何數組，此時通過該變量訪問數組的元素會出現錯誤（NullPointerException，即空指針異常）。

4 數組常見操作

在程序開發中，數組的應用非常廣泛，靈活地使用數組對實際開發很重要。接下來，本節將針對數組的常見操作，如數組的遍歷、最值的獲取、數組的排序等，進行詳細地講解。

(1)遍歷數組

int[] arr = {6,9,2,1,5}; //定義一個數組
        //使用for循環遍歷數組
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

結果:

(2)找最大值

int[] arr = {6,9,2,1,5}; //定義一個數組
        //找最大值
        int max = arr[0];//假設數組中第一個數是最大值
        //遍歷出第一個數後的所有數
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){//如果遍歷出來的數比max大
                //把max改成較大的數
                max = arr[i];
            }
        }
        System.out.println("最大值是:"+max);

結果:

(3)冒泡排序

int[] arr = {6,9,2,1,5}; //定義一個數組
        // 冒泡排序
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                //從小到大
                if(arr[j]>arr[j+1]){//如果前面的數大於後面的數
                   int temp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = temp;
                }
            }
        }
        // 打印排好序的數組
        System.out.println(Arrays.toString(arr));

結果:

(4)二分查找法(有序數組)

int num = 9;//定義一個要查找的數據
        int[] arr = {1,2,5,6,9}; //定義一個數組
        int min = 0; // 最小索引值
        int max = arr.length-1;//最大索引值
        int mid = (min+max)/2;//中間索引值
        while(true){ // 不確定要找多少次,所以使用while循環
            if(num > arr[mid]){ // 如果num比中間數大
                min = mid + 1; // 最小索引值min = mid+1
            }else if(num < arr[mid]){//如果num比中間數小
                max = mid - 1; // 最大索引值max = mid-1
            }else{// 如果num等於中間數
                System.out.println(num+"在數組中,索引值是:"+mid);//num在數組中
                break;//結束循環,不找了
            }
            mid = (min+max)/2; // 由於min和max在變化,所以每次都要修改mid的值
            if(min>max){ // 如果min>max,説明沒找到
                System.out.println(num+"不在數組中");
                break; // 結束循環,不找了
            }
        }

結果:

5 多維數組

在程序中可以通過一個數組來保存某個班級學生的考試成績，試想一下，如果要統計一個學校各個班級學生的考試成績，又該如何實現呢？

上面這種場景就需要用到多維數組，多維數組可以簡單地理解為在數組中嵌套數組。而在程序中，比較常見的多維數組是二維數組。

(1)二位數組的格式:

   數據類型[][] 數組名 = new 數據類型[二維數組長度][每個數組元素個數];

例如:

int[][] arr = new int[3][4];

説明：上面的代碼相當於定義了一個3*4的二維數組，這個二維數組的長度為3，可以將它看成3個int[]類型的一維數組，每個一維數組中的元素又是一個長度為4的一維數組。

例如:

   int[][] arr = new int[3][];

説明：第二種方式和第一種類似，只是數組中每個元素的長度不確定。

例如:

   int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};

説明：上面的二維數組中定義了三個元素，這三個元素都是數組，分別為{1,2}、{3,4,5,6}、{7,8,9} 。

(2)二維數組的使用

arr[0][1];        // 獲取二維數組中第一個元素組的第二個元素
    arr[0][1]=1;    // 對二維數組中第一個元素組的第二個元素賦值或修改

説明：對二維數組中元素的操作也是通過角標的方式來完成的。

例如:

統計公司3個銷售小組中每個小組的總銷售額以及整個公司銷售額

int[][] arr = new int[3][];//定義一個長度為3的二維數組,保存3個小組的銷售額
        arr[0] = new int[]{11,22}; //第一個小組每個人的銷售額
        arr[1] = new int[]{12,15,16};//第二個小組每個人的銷售額
        arr[2] = new int[]{13,14,10,11};//第三個小組每個人的銷售額
        int sum = 0 ;//定義一個變量,保存所有小組的總銷售額
        for(int i=0;i<arr.length;i++){
            //求每組的總銷售額
            int groupSum = 0;//定義一個變量,保存每個組的總銷售額
            for(int j=0;j<arr[i].length;j++){
               groupSum += arr[i][j]; // 累計相加求和i
            }
            System.out.println((i+1)+"組的銷售總額是:"+groupSum);
            //把當前小組的總銷售額保存到sum中
            sum += groupSum; // 累計相加求和
        }
        System.out.println("公司所有小組總銷售額是:"+sum);

結果:

七 方法(函數)

1 什麼是方法

方法就是一段可以重複調用的代碼.

假設有一個遊戲程序,程序在運行過程中,要不斷的發射炮彈.發射炮彈的動作需要編寫100行代碼,在每次發射炮彈的地方都需要重複的寫這100行代碼,程序會變得很臃腫,可讀性也非常差.

為了解決上述問題,通常會將發射炮彈的代碼提取出來,然後放在一個方法中,並給這個方法取名,這樣在每次發射炮彈的地方,只需要通過方法名字來調用方法,即可完成發射炮彈的動作.

在有些書中也會把方法稱為函數,這兩者本身並沒有什麼區別,是同樣的概念,只是稱呼方式不一樣.

2 方法的語法格式

修飾符 返回值類型 方法名(參數列表){    //方法體,方法中具體要執行的代碼    return 返回值; }

修飾符:可以使用public/private等

返回值類型:用於限定方法返回值的數據類型

方法名:定義方法的名字,滿足標識符的規則

參數列表:變量列表,用於接收調用方法時傳入的數據

return:關鍵字,用於結束方法以及返回方法指定類型的數據

返回值:被return語句返回的值,該值會返回給調用者

注意:

參數列表可以為空,即()中不寫任何內容

方法的返回值必須和方法的返回值類型保持一致

如果方法沒有返回值,返回值類型要聲明為void

3 方法案例

例如:定義一個方法,打印10次"hello world"

public void printMsg(){    for(int i=1;i<=10;i++){        System.out.println("hello world");   } }

例如:定義一個方法,求1-n之和,返回求和結果

public int getSum(int n){    int sum = 0;    for(int i=1;i<=n;i++){        sum += i;   }    return sum; }

例如:定義一個方法,求矩形面積:寬*高

public int getArea(int x,int y){    return x*y; }

注意:

方法不會自己執行,需要去調用

4 方法的調用

方法名(實參列表);

注意:

實參列表要和調用方法的參數列表一一對應

如果調用的方法有返回值,一般會定義一個變量保存返回值

數據類型 變量名 = 方法名(實參列表);

例如:

//調用printMsg方法 printMsg(); //調用getSum方法 int sum = getSum(10); //調用getArea方法 int area = getArea(3,4);

5 方法的重載

假設要在程序中實現一個對數字求和的方法,由於參與求和數字的個數和數據類型都不確定,因此要針對不同的情況去設計不同的方法.

例如:

//對2個整合求和
public int add1(int a,int b){
    return a+b;
}
//對3個整數求和
public int add2(int a,int b,int c){
    return a+b+c;
}
//對2個小數求和
public double add3(double a,double b){
    return a+b;
}

問題:

程序需要對每一種求和的情況都定義一個方法名,如果方法名稱都不相同,調用時就很難分清哪種情況該調用哪個方法.

為了解決這個問題,java允許在一個程序中定義多個名稱相同的方法,但是參數的類型或個數必須不同,這就是方法的重載.

例如:

//方法的重載
//對2個整合求和
public int add(int a,int b){
    return a+b;
}
//對3個整數求和
public int add(int a,int b,int c){
    return a+b+c;
}
//對2個小數求和
public double add(double a,double b){
    return a+b;
}

調用:

add(1,2);
add(1,2,3);
add(3.14,1.1);