Java語言基礎組成：關鍵字、識別符號、註釋、常量和變數、運算子、語句、函式、陣列

一. 程式流程控制語句

1. 順序結構：

簡單的語句都是順序結構的。

2. 判斷結構：

【例項 1】：根據使用者定義的數值不同，列印對應的星期英文

int num = 2;
if(num == 1
 
)
{
    System.out.println("Monday");
}
else if(num == 2)
{
    System.out.println("Tuesday")
}
else if(num == 3)
{
    System.out.println("Wednesday")
}
else if(num == 4)
{
    System.out.println("Thursday")
}
else if(num == 5)
{
    System.out.println("Friday")
}
else if(num == 6)
{
    System.out
 
.println("Saturday")
}
else if(num == 7)
{
    System.out.println("Sunday")
}
else
{
    System.out.println("nono");
}

【例項 2】：根據使用者指定月份，列印該月份所屬的季節（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
      （【注】見switch進行改寫）

int x = 4;
if(x > 12 || x < 1)
{
    //一定要先對資料進行判斷，只有正確的數值才能進行相應的處理，非正確的數值應該人性化地提示使用者。
    System.out.println("月份不存在"); 
}
else if(x >= 3 && x <= 5)
{
    System.out.println("春季");
}
else if(x >= 6 && x <= 8)
{
    System.out.println("夏季");
}
else if(x >= 9 && x <= 11)
{
    System.out.println("秋季");
}
else
{
    System.out.println("冬季");
}

3. 選擇結構：

【例項 1】：分析程式碼執行結果

int x = 3; 
switch(x) 
{
    default : System.out.println(“d”); 
   case 4 : System.out.println(“a”); 
   case 6: System.out.println(“b”); break; 
   case 2: System.out.println(“c”); break; 
} 
//結果為：d(回車)a(回車)b(回車) 

//分析為：第一次讀取時，case都沒有符合，讀到default，執行後既沒有break也沒有大括號（}）， 
//       那麼繼續向下執行，而不再進行判斷case，把下面能執行的都執行完，直到碰到break或大括號（}）。

【例項 2】：根據使用者指定月份，列印該月份所屬的季節（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
      （【注】對上面的if-case進行改寫）

int x = 4;
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;
    default: System.out.println("月份不存在"); 
}

4. 迴圈結構：

當要對某些語句執行很多次，就使用迴圈結構。

【例項 1】：分析下面的程式碼

int x = 1;
for(System.out.println("a"); x < 3; System.out.println("b"))
{
    System.out.println("c");
    x++;
}

//結果為：a(回車)c(回車)b(回車)c(回車)b(回車)
/*分析為：(1)【初始化表示式】：不一定要寫成int x = 1; 只要是合法表示式就可以
         (2)【迴圈條件】：迴圈條件表示式必須要有真假
         (3)【迴圈後的操作表示式】：當表示式多時，用"，"隔開，可以寫多條語句
*/

/*【擴充套件】: for(int y = 0; y < 3; y++){ }
        => 可以改成：
           int y = 0;
           for(; y < 3;)  //表示式可以為空
           {
              y++;
           }
*/

【例項 2】：獲取1~10的和，並列印

/*【累加思想】：
sum += num; => 每次加的內容有可能不一樣
原理： 通過變數記錄住迴圈操作後的結果， 一個數不斷地變大或變小，以記錄住每次變化的結果，
      通過迴圈的形式進行累加動作，通常為累加一個變數或一個迴圈增量。
      [e.g.] 字串的不斷延長
*/

int sum = 0;
for(int num = 1; num <= 10; num++)
{
    sum += num;
}
System.out.println("sum=" + sum);

【例項 3】：1~100之間 7的倍數的個數，並列印。

/*【計數器思想】：
count++; => 符合條件有多少個，立刻想到計數器
原理： 通過一個變數記錄住資料的狀態變化，也需要通過迴圈完成。
*/

//方法一：
int count1 = 0;
for(int i = 1; i <= 100; i++)
{
    if(i % 7 == 0)
    {
        System.out.print("i=" + i + ' ');
        count1++;
    }
}
System.out.println("個數為：" + count1);

//方法二：
int multiplication = 7; //7的倍數值
int count2 = 0;
for(int i = 2; multiplication <= 100; i++)
{
    count2++;
    System.out.print("mul=" + multiplication + ' ');
    multiplication = 7 * i; //更新7的倍數值
}
System.out.println("個數為：" + count2);

【例項 4】：列印矩形

/*
利用for迴圈巢狀列印圖形
******
******
******
******
*/
    /**
     * 列印矩形
     * @param x 行
     * @param y 列
     */
    public static void printJuxing(int x,int y)
    {
        for(int n = 0; n < x; n++)  //對於列印長方形，外迴圈控制行數
        {
            for (int m = 0; m < y ; m++ )  //內迴圈控制的是每一行的列數，也就是一行中元素的個數
            {
                System.out.print("*");
            }
            System.out.println();  //用於換行
        }
    }

【例項 5】：列印倒直角三角形

        /*
        利用for迴圈巢狀，列印圖形。
        ****
        ***
        **
        *
        方法一：
        思路： 1.因為for迴圈巢狀的，外迴圈是控制行數的，內迴圈是控制每一行的列數的。
              2.行數為4，n由0開始，進行4次迴圈，n最大為3。
              3.列數m不斷地變小，第0行4個，第1次3個，由此可見，第n行為4-n。
              補充：
              第0行，m變化的區間為，0-4，共4個。
              第1行，m變化的區間為，0-3，共3個。
              第2行，m變化的區間為，0-2，共2個。
              第n行，m變化的區間為，0-n，共n個。
              所以m的初始值為0，m的條件為，m<4-n。

        */
        for(int n = 0; n < 4; n++)
        {
            for(int m = 0;m < 4 - n;m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("------------------------");

        /*
        方法二：
        思路：第0行，m變化的區間為，0-4，共4個。
              第1行，m變化的區間為，1-4，共3個。
              第2行，m變化的區間為，2-4，共2個。
              第n行，m變化的區間為，n-4，共4-n個。
              所以m的初始值在變化，m<4是不變的。
        */
        for(int n = 0; n < 4; n++ )
        {
            for(int m = n; m < 4; m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("------------------------");

【例項 6】：列印順直角三角形

        /*
        利用for迴圈巢狀，列印圖形。
        *
        **
        ***
        ****
        思路：1.因為for迴圈巢狀的，外迴圈是控制行數的，內迴圈是控制每一行的列數的。
              2.行數為4，n由0開始，進行四次迴圈，n最大為3。
              3.列數m不斷增加，第0行1個，第1行2個，由此可見，第n行為n+1。
        */
        for(int n = 0; n < 4; n++)
        {
            for(int m = 0; m < n + 1; m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

【列印三角形的規則】：

• 1. 尖朝上，可以改變條件，讓條件隨外迴圈變化
• 2. 尖朝下，可以改變初始值，讓初始值隨外迴圈變化

【例項 7】：按規則列印數字

        /*
        列印：
        1
        12
        123
        1234
        12345
        思路:尖朝上，改變條件。
        */
        for(int n = 1; n <= 5; n++)
        {
            for(int m = 1; m <= n; m++)
            {
                System.out.print(m);
            }
            System.out.println();
        }

【例項 8】：列印九九乘法表

        /**
        列印九九乘法表：
        1*1=1
        1*2=1 2*2=4
        1*3=3 2*3=6 3*3=9
        */
        for (int n = 1; n <= 9 ; n++)
        {
            for(int m = 1; m <= n; m++)
            {
                System.out.print(m + "*" + n + "=" + ( m * n) + "\t");
            }
            System.out.println();
        }

【例項 9】：列印等腰三角形

        /*
        列印。
        ----*
        ---* *
        --* * *
        -* * * *
        * * * * *
        */
        //方法一
        for (int n = 1; n <= 5; n++ )
        {
            for (int m = 5; m >= 1; m-- )
            {
                if(m <= n)
                {
                    System.out.print("* ");
                }
                else
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

        System.out.println("------------------------");

        //方法二
        for (int n = 0; n < 5 ; n++ )
        {
            for (int m = n + 1; m < 5 ; m++ )
            {
                System.out.print(" ");
            }
            for (int z = 0; z <= n ;z++ )
            {
                System.out.print("* ");
            }
            System.out.println();
        }

5. 其他程式流程控制語句：

二. 函式

1. 函式的定義：

函式就是定義在類中的具有特定功能的一段獨立小程式，函式也成為方法。

【例項】：如何定義函式，呼叫函式的例項

    public static void main(String[] args) {

        int x = getResult(4); //可以重用
        System.out.println("x=" + 4);
    }

    public static int getResult(int num) //定義函式
    {
        return num * 3 + 5;
    }

2. 函式的特點：

【函式的特點】：

1. 定義函式可以將功能程式碼進行封裝。
2. 便於對功能進行復用。
3. 函式只有被呼叫才會執行。
4. 函式的出現提高了程式碼的複用性。
5. 當函式運算後，沒有具體返回值時，這時返回值型別用一個特殊的關鍵字標識，該關鍵字就是void。
   void 代表的是函式沒有具體返回值的情況。
   當函式的返回值型別是void時，函式中的return 可以省略不寫，系統會自己加的。

3. 函式的應用：

  我們編寫程式，其實就是在不斷地實現功能，Java中最小的功能單元就是函式，所以以後在寫程式碼的時候，只要在處理或定義功能，都把它定義到獨立的函式功能中去，而不要把程式碼換七八糟塞到主函式中，主函式的功能就只有一個，就是呼叫函式。

【如何定義函式？】：

1. 明確返回值型別：既然函式是一個獨立的功能，那麼該功能的運算結果是什麼就要先明確。
2. 明確引數列表：再明確在定義該功能的過程中，是否需要未知的內容參與運算，即是否需要引數。
   引數列表包括引數的型別和引數的個數。

【例項 1】：定義一個功能，完成 3 + 4 的運算，並將結果返回給呼叫者

    public static void main(String[] args) {

        int sum = getSum();
        System.out.println("sum=" + sum);
    }

    /**
     * 功能：計算 3 + 4
     * @return 返回總數
     */
    public static int getSum()
    {
        return 3 + 4;
    }

【例項 2】：為了方便使用者需求，由使用者來指定加數和被加數，這樣功能才有意義

    public static void main(String[] args) {

        int sum = getSum(3, 4);
        System.out.println("sum=" + sum);
    }

    /**
     * 功能：計算兩數相加
     * @return 返回總數
     */
    public static int getSum(int x, int y)
    {
        return x + y;
    }

【例項 3】：判斷兩個數是否相同

    public static void main(String[] args) 
    {
        boolean num = compare(6,6); //比較兩個值是否相等
        if(num)
            System.out.println("相同");
        else
            System.out.println("不相同");
    }

    /**
     * 功能：判斷兩個數是否相同
     * @return boolean值
     */
    public static boolean compare(int x, int y)
    {
        /*
        方法一：
        if(x == y)
            return true;
        else
            return false;
        */

        /*
        方法二：三元運算子
        return x == y ? true : false;
        */

        //方法三：最簡單的
        return x == y;
    }

【例項 4】：比較兩個數，獲取最大的數

    public static void main(String[] args) 
    {
        int max= getMax(4,6); //求最大值
        System.out.println("最大值為：" + max);
    }

    /**
     * 功能：比較兩個數，獲取最大的數
     * @return max
     */
    public static int getMax(int x,int y)
    {
        return x > y ? x : y;
    }

【例項 5】：查找出下面程式碼中，錯誤的定義思想

    public static void main(String[] args) 
    {
        System.out.println(getMax(4,6)); //[錯誤1]
    }

    /**
     * 功能：比較兩個數，獲取最大的數
     */
    public static void getMax(int x,int y)
    {
        System.out.println("最大值為：" + x > y ? x : y);  //[錯誤2]
    }

    /*【錯誤分析】：

    [錯誤1]：getMax方法返回值型別為void時，輸出語句不知道要輸出什麼，不能列印，直接呼叫就行了。

    [錯誤2]：定義函式只要完成相對應的功能就好了，不要做過多的功能，
            至於列印是由呼叫者來完成，不要在getMax功能中完成。
    */

【例項 6】：定義功能，用於列印矩形。

    /*
    定義功能，用於列印矩形。
    思路：1.需要知道行數和列數。
          2.不需要返回值。
    */
    public static void main(String[] args) {

        printJuxing(4, 6);
    }

    /**
     * 功能：用於列印矩形
     * @param row 行
     * @param col 列
     */
    public static void printJuxing(int row,int col)
    {
        for(int n = 0; n < row; n++)
        {
            for (int m = 0; m < col ; m++ )
            {
                System.out.print("*");
            }
            System.out.println();
        }
    }

【例項 7】：定義一個列印99乘法表功能的函式。

    /*
    定義一個列印99乘法表功能的函式。
    思路：1.需要值。
          2.不需要返回值，直接列印。
    */
    public static void main(String[] args) {

        mul(9);
    }

    /**
     * 功能：列印99乘法表功能的函式
     * @param x 最大到幾（例如9）
     */
    public static void mul(int x)
    {
        for(int n = 1; n <= x; n++)
        {
            for (int m = 1; m <= n ; m++ )
            {
                System.out.print( m + "*" + n + "=" + m * n + "\t");
            }
            System.out.println();
        }
    }

4. 函式的過載：

  在同一個類中，允許存在一個以上的同名函式，引數個數或者引數型別不同的同名函式就叫做過載。過載的特點：與返回值無關，只看引數列表。
  當定義的功能相同，但參與運算的未知內容不同，那麼，就定義一個相同的函式名稱以表示其功能，方便閱讀，而通過引數列表的不同來區分多個同名函式。

【例項 1】：add方法出現了過載的形式，名稱保證一致

public static void main(String[] args)
{
    //功能一致，所以功能用的名字也一致
    add(4, 5);
    add(4, 5, 6); //通過引數列表來區分呼叫哪個函式
}

public static int add(int a, int b)
{
    return a + b;
}

public static int add(int a, int b, int c)
{
    return a + b + c; //簡化為：return add(a, b) + c; 提高程式碼的複用性。
}

【什麼時候用過載？】
  當定義的功能相同，但參與運算的未知內容不同，那麼，這時就定義一個函式名稱以表示其功能，方便閱讀。而通過引數列表的不同來區分多個同名函式。

【例項 2】：定義一個列印99乘法表功能的函式。用過載，一個是自定義num，一個是標準的9；

    public static void main(String[] args) {

        mul(8); //八八乘法表
        mul();  //九九乘法表
    }

    /**
     * 功能：自定義數值99乘法表
     * @param x 最大到幾（例如9）
     */
    public static void mul(int x)
    {
        for(int n = 1; n <= x; n++)
        {
            for (int m = 1; m <= n ; m++ )
            {
                System.out.print( m + "*" + n + "=" + m * n + "\t");
            }
            System.out.println();
        }
    }

    /**
     * 功能：標準版99乘法表
     */
    public static void mul()
    {
        mul(9);
    }

【例項 3】：給定一個函式，比較下面有沒有和它過載

void show(int a, char b, double c){}//原函式

//[a]
void show(int x, char y, double z){} //沒有，因為和原函式一模一樣

//[b]
int show(int a, double c, char b){}//過載了，因為引數型別不同，注意：過載和返回值型別無關，引數也是有順序的

//[c]
void show(int a, double c, char b){} //過載了，引數是有順序的

//[d]
boolean show(int c, char b){} //過載了，因為引數個數不同

//[e]
void show(double c){} //過載了，因為引數個數不同

//[f]
double show(int x, char y, double z){} //沒有，引數一樣，返回值雖然不同，但是不是過載，並且這個函式不允許和給定的函式