Head First Java 和 AcWing Java課程做的總結2。

2.1 判斷語句

if語句

基本 if-else 語句:

• 當條件成立時，執行某些語句；否則執行另一些語句。
• else 語句可以省略
• 當只有一條語句時，大括號可以省略

(與C++不同的是，括號() 中的語句不能是單純的數，如1/2/0等，而只能是邏輯表示式，即結果是 true 或 false )

練習：判斷閏年

閏年有兩種情況：
(1) 能被100整除時，必須能被400整除；
(2) 不能被100整除時，被4整除即可。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        
        if(year % 100 == 0){
            if(year % 400 == 0)
                System.out.println("Yes");
            else
                System.out.println("No");
        }else{
            if(year % 4 == 0)
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }
}
 

常用比較運算子：

• 大於 >
• 小於 <
• 大於等於 >=
• 小於等於 <=
• 等於 ==
• 不等於 !=

用於邏輯表示式中，舉例：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = nextInt(), b = nextInt();
        
        if(a > b)System.out.printf("%d > %d\n", a, b);
        if(a < b)System.out.printf("%d < %d\n", a, b);
        if(a >= b)System.out.printf("%d >= %d\n", a, b);
        if(a <= b)System.out.printf("%d <= %d\n", a, b);
        if(a == b)System.out.printf("%d == %d\n", a, b);
        if(a != b)System.out.printf("%d != %d\n", a, b);
    }
}
 

if-else 連寫：

if (s >= 85) {
    System.out.println("A");
} else if (s >= 70) {
    System.out.println("B");
} else if (s >= 60) {
    System.out.println("C");
} else {
    System.out.println("D");
}

條件表示式

• 與 &&
• 或 ||
• 非 !

舉例：判斷閏年

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();

        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
            System.out.println("yes");
        else
            System.out.println("no");
    }
}
 

switch語句

注意： swtich語句中如果不加break語句，則從上到下匹配到第一個case後，會順次執行後面每個case中的語句。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int day = sc.nextInt();
        String name;

        switch(day) {
            case 1:
                name = "Monday";
                break;
            case 2:
                name = "Tuesday";
                break;
            case 3:
                name = "Wednesday";
                break;
            case 4:
                name = "Thursday";
                break;
            case 5:
                name = "Friday";
                break;
            case 6:
                name = "Saturday";
                break;
            case 7:
                name = "Sunday";
                break;
            default:
                name = "not valid";
        }

        System.out.println(name);
    }
}

2.2 迴圈語句

while迴圈

可以簡單理解為迴圈版的if語句。if語句是判斷一次，如果條件成立，則執行後面的語句；while是每次判斷，如果成立，則執行迴圈體中的語句，否則停止。

public class Main {
    public static void main(String[] args) {
        int i = 1, sum = 0;
        while (i <= 100) {
            sum += i * i * i;
            i ++ ;
        }
        System.out.println(sum);
    }
}

死迴圈：迴圈永久執行，無法結束。我們要避免寫出死迴圈。比如：

int x = 1;
while (x == 1)
    System.out.println("!");

do-while 迴圈

do while迴圈不常用。
do while語句與while語句非常相似。唯一的區別是，do while語句限制性迴圈體後檢查條件。不管條件的值如何，我們都要至少執行一次迴圈。

public class Main {
    public static void main(String[] args) {
        int x = 1;
        while (x < 1) {
            System.out.println("x!");
            x ++ ;
        }

        int y = 1;
        do {
            System.out.println("y!");
        } while (y < 1);
    }
}

for迴圈

基本思想：把控制迴圈次數的變數從迴圈體中剝離。

for (init-statement : condition: expression) {
    statement
}

init-statement可以是宣告語句、表示式、空語句，一般用來初始化迴圈變數；
condition是條件表示式，和while中的條件表示式作用一樣；可以為空，空語句表示true；
expression一般負責修改迴圈變數，可以為空。

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i ++ )
            sum += i * i * i;
        System.out.println(sum);
    }
}
// 迴圈體中只有一條語句時，可以不加大括號

init-statement可以定義多個變數，expression也可以修改多個變數。

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1, j = 10; i < j; i ++, j -- ) {
            sum += i * j;
        }

        System.out.println(sum);
    }
}

跳轉語句

break：
可以提前從迴圈中退出，一般與if語句搭配。

continue：
可以直接跳到當前迴圈體的結尾。作用與if語句類似。

3.5 多層迴圈

練習：列印1~100中的所有質數

public class Main {
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i ++ ) {
            boolean isPrime = true;
            for (int j = 2; j < i; j ++ ) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime)
                System.out.println(i);
        }
    }
}

2.3 函式

理解函式，最重要的是理解函式的執行順序。（棧的順序）

函式基礎

一個典型的函式定義包括以下部分：修飾符、返回型別、函式名字、由0個或多個形參組成的列表以及函式體。

編寫函式

//求階乘
public class Main{
    //private只有在當前類中可用
    //public公有
    private static int fact(int val){
        int res = 1;
        for(int i = 1; i <= val; i++)
            res *= i;
        return res;
    }
}

函式名字是fact，它作用於一個整型引數，返回一個整型值。return語句負責結束fact並返回res的值。
修飾符包括private、static等，它們屬於類相關的概念，會在下一章解釋。

呼叫函式

public class Main{
    private static int fact(int val){
        int res = 1;
        for(int i = 1; i <= val; i++)
            res *= i;
        return res;
    }
    
    public static void main(String[] args){
        int res = fact(5);
        System.out.printf("5! is %d\n", res);
    }
}

函式的呼叫完成兩項工作：

• 一是用實參初始化函式對應的形參；
• 二是將控制權轉移給被呼叫函式。此時，主調函式的執行被暫時中斷，被調函式開始執行。

形參和實參

實參是形參的初始值。第一個實參初始化第一個形參，第二個實參初始化第二個形參，依次類推。形參和實參的型別和個數必須匹配。

fact("hello");      // 錯誤：實參型別不正確
fact();             // 錯誤：實引數量不足
fact(42, 10, 0);    // 錯誤：實引數量過多
fact(' ');      // 正確：該實參能自動轉換成int型別，' '的ASCII值為32，所以該操作等價於fact(32);

函式的形參列表

函式的形參列表可以為空，但是不能省略。

void f1() {/* …. */}            // 空形參列表

形參列表中的形參通常用逗號隔開，其中每個形參都是含有一個宣告符的宣告。即使兩個形參的型別一樣，也必須把兩個型別都寫出來：

int f3(int v1, v2) {/* … */}        // 錯誤
int f4(int v1, int v2) {/* … */}    // 正確

函式返回型別

大多數型別都能用作函式的返回型別。一種特殊的返回型別是void，它表示函式不返回任何值。
函式的返回型別也可以是陣列、字串或者其他物件：

import java.util.Arrays;

public class Main {
    private static int[] newArray() {
        int[] a = {1, 2, 3};
        return a;
    }

    private static String newString() {
        return "Hello World";
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(newArray()));
        System.out.println(newString());
    }
}

變數的作用域

本章中我們只使用靜態成員變數和靜態成員函式，非靜態成員變數/函式及其區別會在下一章中介紹。

函式內定義的變數為區域性變數，只能在函式內部使用。
定義在類中的變數為成員變數，可以在類的所有成員函式中呼叫。
當局部變數與全域性變數重名時，會優先使用區域性變數。

public class Main {
    private static int x = 4;

    private static void f1() {
        int x = 3;
        System.out.println(x);
    }

    private static void f2() {
        System.out.println(x);
    }

    private static void f3() {
        System.out.println(x + 1);
    }

    public static void main(String[] args) {
        f1();
        f2();
        f3();
    }
}

引數傳遞

值傳遞

八大基本資料型別和String型別等採用值傳遞。

String不支援修改，每次修改時建立一個新地址來存新的值。原地址值不發生變化。

將實參的初始值拷貝給形參。此時，對形參的改動不會影響實參的初始值。

public class Main {
    private static void f(int x) {
        x = 5;
    }

    public static void main(String[] args) {
        int x = 10;
        f(x);
        System.out.println(x);
    }
}

引用傳遞（其實是特殊的值傳遞，值是遙控器）

除String以外的資料型別的物件，例如陣列、StringBuilder等採用引用傳遞。

將實參的引用（地址）傳給形參，通過引用找到變數的真正地址，然後對地址中的值修改。所以此時對形參的修改會影響實參的初始值。

import java.util.Arrays;

public class Main {
    private static void f1(int[] a) {
        for (int i = 0, j = a.length - 1; i < j; i ++, j -- ) {
            int t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }

    private static void f2(StringBuilder sb) {
        sb.append("Hello World");
    }

    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        f1(a);
        System.out.println(Arrays.toString(a));

        StringBuilder sb = new StringBuilder("");
        f2(sb);
        System.out.println(sb);
    }
}

返回型別和return語句

return語句終止當前正在執行的函式並將控制權返回到呼叫該函式的地方。return語句有兩種形式：

return;
return expression;

無返回值函式

沒有返回值的return語句只能用在返回型別是void的函式中。返回void的函式不要求非得有return語句，因為在這類函式的最後一句後面會隱式地執行return。

通常情況下，void函式如果想在它的中間位置提前退出，可以使用return語句。return的這種用法有點類似於我們用break語句退出迴圈。

public class Main {
    private static void swap(int[] a) {  // 交換a[0]和a[1]
        // 如果兩個值相等，則不需要交換，直接退出
        if (a[0] == a[1])
            return;
        // 如果程式執行到了這裡，說明還需要繼續完成某些功能

        int tmp = a[0];
        a[0] = a[1];
        a[1] = tmp;
        // 此處無須顯示的return語句
    }

    public static void main(String[] args) {
        int[] a = {3, 4};
        swap(a);
        System.out.printf("%d %d\n", a[0], a[1]);
    }
}

有返回值函式

只要函式的返回型別不是void，則該函式內的每個分支都必須有return語句，且每條return語句都必須返回一個值。return語句返回值的型別必須與函式的返回型別相同，或者能隱式地轉換函式的返回型別。

import java.util.Scanner;

public class Main {
    private static int max(int a, int b) {
        if (a > b)
            return a;
        return b;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt(), y = sc.nextInt();

        System.out.println(max(x, y));
    }
}

函式過載

函式過載是指：在同一個類中存在多個函式，函式名稱相同但引數列表不同。

編譯器會根據實參的型別選擇最匹配的函式來執行。

import java.util.Scanner;

public class Main {
    private static int max(int a, int b) {
        System.out.println("int max");
        if (a > b) return a;
        return b;
    }

    private static double max(double a, double b) {
        System.out.println("double max");
        if (a > b) return a;
        return b;
    }

    public static void main(String[] args) {
        System.out.println(max(3, 4));
        System.out.println(max(3.0, 4.0));
    }
}

函式遞迴

在一個函式內部，也可以呼叫函式本身。

private static int fib(int n) {  // 求斐波那切數列第n項
    if (n <= 2) return 1;
    return fib(n - 1) + fib(n - 2);
}