• 3 Java 基礎知識
  • 3.1 關於 Java
    • 3.1.1 Compiled language
    • 3.1.2 特殊既 main method
    • 3.1.3 Compile time 及 runtime
    • 3.1.4 如何 deploy Java apps
  • 3.2 Modifiers 修飾符
    • 3.2.1 Access modifiers
    • 3.2.2 Non-access modifiers
    • 3.2.3 Modifiers 既例子
  • 3.3 Classes / types
    • 3.3.1 Primitive data types 原始數據類型
    • 3.3.2 Primitive data type conversion/casting
      • 3.3.2.1 Automatic type conversion 示範
    • 3.3.3 Primitive data types 既 wrapper classes
    • 3.3.4 Autoboxing 及 unboxing
    • 3.3.5 Array / Collection / Map
    • 3.3.6 自定義 types
      • 3.3.6.1 Concrete class 既例子
      • 3.3.6.2 Abstract class 既例子
      • 3.3.6.3 Subclass 及 superclass 既例子
      • 3.3.6.4 Implementation class 及 interface 既例子
      • 3.3.6.5 Anonymous class 既例子
    • 3.3.7 以 lambda 取代 anonymous class
    • 3.3.8 Naming convention 命名原則/慣例
  • 3.4 如何設計 class
  • 3.5 如何寫 method
    • 3.5.1 Overload 一個 method
    • 3.5.2 Override 一個 method
  • 3.6 睇 libraries 既 Javadoc 以及實際 source code
    • 3.6.1 喺 Eclipse 裡面睇
      • 3.6.1.1 安裝 Enhanced Class Decompiler plugin
    • 3.6.2 上官網睇 Javadoc
  • 3.7 JDK 內建實用 classes

• Compile time：你寫緊 code，compiler compile 你啲 code 既時候
• Runtime：個程式 deploy 左，run 緊既時候

java -jar My-Application-1.0.jar

mvn spring-boot:run

• Type
• Class/instance variable
• Constructor
• Method
• Local variable
• Constructor/method parameter

• 將所有野用曬 public 係一定 work，但係會令 access 太濫，影響 code maintenance，因為你唔知邊啲野係要 expose 畀其他 classes 用，所以最好係 limit access，最有限既 access 夠做就用果個。

1public class Foo { // type: public
2    private static final String MESSAGE = "Hello World"; // class variable: private static final
3
4    private final String name; // instance variable: private final
5
6    public Foo(final String name) { // constructor: public; constructor parameter: final
7        this.name = name;
8    }
9
10    public String sayHi() { // method: public
11        final String message = MESSAGE; // local variable: final
12        return toLowerCase(message);
13    }
14
15    public String sayHi(final String message) { // method: public; method parameter: final
16        return toLowerCase(message);
17    }
18
19    private String toLowerCase(String str) { // method: private
20        return str==null ? "" : str.toLowerCase();
21    }
22}

• boolean (true / false)
• int（自然數）
• long（自然數，正負數範圍比 int 大）
• float（有小數點）
• double（有小數點，，正負數範圍比 float 大）
• byte（較少用）
• char（單字/符號，幾乎唔需要用到）

1byte b = 1;
2
3short s = b; // implicit type conversion
4byte b2 = s; // compilation error, Type mismatch: cannot convert from short to byte
5byte b3 = (byte) s; // explicit type casting
6
7int i = s; // implicit type conversion
8short s2 = i; // compilation error, Type mismatch: cannot convert from int to short
9short s3 = (short) i; // explicit type casting
10
11char c = 1;
12int i2 = c; // implicit type conversion
13char c2 = i2; // compilation error, Type mismatch: cannot convert from int to char
14char c3 = (char) i2; // explicit type casting
15
16long l = i2; // implicit type conversion
17int i3 = l; // compilation error, Type mismatch: cannot convert from long to int
18int i4 = (int) l; // explicit type casting
19
20float f = i2; // implicit type conversion
21int i5 = f; // compilation error, Type mismatch: cannot convert from float to int
22int i6 = (int) f; // explicit type casting
23
24double d = l; // implicit type conversion
25long l2 = d; // compilation error, Type mismatch: cannot convert from double to long
26long l3 = (long) d; // explicit type casting

• Boolean (true / false)
• Integer
• Long
• Float
• Double
• Byte
• Character

Integer num = 1;

1public static void main(String[] args) {
2
3    // autobox int 1 成 Integer 1
4
5    foo(1);
6}
7
8private static void foo(Integer num) {
9    // do sth
10}

int num = new Integer(1);

1public static void main(String[] args) {
2
3    // unbox Integer 1 成 int 1
4
5    foo(new Integer(1));
6}
7
8private static void foo(int num) {
9    // do sth
10}

1// 先 unbox Integer 3 成 int 3
2// 再計 int 3 + int 2
3// 再將 int 5 autobox 成 Integer 5
4Integer num = new Integer(3) + 2;
5
6// 先 unbox Integer num 成 int 5 同 unbox Integer 4 成 int 4
7// 再計 int 5 + int 4
8// 再將 int 9 autobox 成 Integer 9
9num += new Integer(4);

String[] arr = new String[4];

int[] arr = new int[] { 3, 6 };
arr[0] = 7;
arr[2] = 3; // 因為只有 0 同 1 兩個 index，呢行會爆 ArrayIndexOutOfBoundsException

List<String> list = new ArrayList<>();

List<String> list = new LinkedList<>();

List<String> list = new Vector<>();

list.add("Michael");
list.add("Ben");
// 可以繼續 add 落去

Set<String> set = new HashSet<>(); // 不保留插入順序

Set<String> set = new LinkedHashSet<>(); // 保留插入順序

Set<String> set = new TreeSet<>(); // 自然順序

set.add("Michael");
set.add("Michael"); // 因為已經存在，add 完唔會有分別
// 可以繼續 add 落去

Map<String, Object> map = new HashMap<>(); // 不保留插入順序

Map<String, Object> map = new LinkedHashMap<>(); // 保留插入順序

Map<String, Object> map = new TreeMap<>(); // 自然順序

map.put("Michael", 25);
map.put("Michael", 30); // overwrite 左 Michael=25
// 可以繼續 put 落去

• List 係 interface，而 ArrayList、LinkedList、Vector 都係 implements 左 List
• Set 係 interface，而 HashSet、LinkedHashSet 都係 implements 左 Set
• Map 係 interface，而 HashMap、LinkedHashMap 都係 implements 左 Map

1public class Foo {
2
3    // 只要所有 methods 都有 method body，就係 concrete class
4
5    public void play() {
6        // do sth
7    }
8}

1public abstract class AbstractFoo {
2
3    // 因為有至少一個 abstract method，所以呢個 class 要係 abstract
4
5    protected abstract void play();
6}

1public abstract class AbstractFoo extends Bar {
2
3    // 繼承左 abstract 既 play()
4}
5
6abstract class Bar {
7
8    // 下面有一個 abstract method
9
10    protected abstract void play();
11}

1public abstract class AbstractFoo implements Bar {
2
3    // 繼承左 abstract 既 play()
4}
5
6interface Bar {
7
8    // interface 既所有 methods 都係 abstract
9
10    void play();
11}

1public class Foo extends Bar {
2
3    // extends 左 Bar，所以係一個 subclass（methods 有齊 method body，所以亦係 concrete class）
4
5    @Override
6    protected void play() {
7        // do sth
8    }
9}
10
11abstract class Bar {
12
13    // 被 Foo extends，所以算係 Foo 既 superclass
14
15    protected abstract void play();
16}

1public class Foo implements Bar {
2
3    // implements 左 Bar，所以係一個 implementation class（methods 有齊 method body，所以亦係 concrete class）
4
5    @Override
6    public void doSth() {
7        // do sth
8    }
9}
10
11interface Bar {
12
13    // interface 裡面既 methods 一定係 public 同 abstract
14
15    void doSth();
16}

1public class Example {
2    public static void main(String[] args) {
3
4        new Thread(new Runnable() {
5            @Override
6            public void run() {
7                // do sth
8            }
9        }).start();
10    }
11}

1public class Example {
2    public static void main(String[] args) {
3
4        // new Runnable() {} 係 anonymous class
5
6        new Thread(new Runnable() {
7            @Override
8            public void run() {
9                // do sth
10            }
11        }).start();
12    }
13}

1public class Example {
2
3    public static void main(String[] args) {
4
5        new Thread(() -> { /* do sth */ }).start();
6    }
7}

• UpperCamelCase：type 名
• lowerCamelCase：property、local variable、method 名、parameter
• UPPER_UNDERSCORE_CASE：constant 名（不變值）

1public void foo(String message) {
2
3    // do sth
4
5    if (new Random().nextInt()==0) {
6        System.out.println("Lucky!");
7        return; // 用黎控制 flow，提早返回
8    }
9
10    System.out.println("No luck!");
11
12    return; // 如果寫喺最後一行，就可以省略，否則用黎控制 flow
13}

public String fullCapitalLetters(String message) {
    return message==null ? null : message.toUpperCase();
}

1public class Foo {
2
3    public static void main(String[] args) {
4        sayHi(); // Hi
5        sayHi("Michael"); // Hi, Michael
6        sayHi("Michael", true); // Hi, MCIHAEL
7    }
8
9    private static void sayHi() {
10        sayHi(null, false);
11    }
12
13    private static void sayHi(String message) {
14        sayHi(message, false);
15    }
16
17    private static void sayHi(String message, boolean isUpperCase) {
18        if (message==null) {
19            System.out.println("Hi");
20        } else {
21            System.out.println("Hi, " + (isUpperCase ? message.toUpperCase() : message));
22        }
23    }
24}

1// 所有可能出現或需要用到既 parameters
2function sayHi(message, isUpperCase) {
3	if (message) {
4		console.log("Hi, " + (isUpperCase ? message.toUpperCase() : message));
5	} else {
6		console.log("Hi, who are you?");
7	}
8}
9
10// 喺 arguments 裡面攞需要用到既 arguments
11function sayHello() {
12	const message = arguments && arguments.length >= 1 ? arguments[0] : undefined;
13	const isUpperCase = arguments && arguments.length >= 2 ? arguments[1] : undefined;
14
15	sayHi(message, isUpperCase);
16}
17
18// ----- 任意 arguments -----
19
20sayHi(); // Hi, who are you?
21sayHi("Michael"); // Hi, Michael
22sayHi("Michael", true); // Hi, MICHAEL
23
24// ----- 畀多過個 method 接受既都得 -----
25
26sayHi("Michael", true, "extra"); // Hi, MICHAEL
27
28// ----- 個 function 用左 arguments 而唔係 declare parameters -----
29
30sayHello(); // Hi, who are you?
31sayHello("Michael"); // Hi, Michael
32sayHello("Michael", true); // Hi, MICHAEL

1abstract class AbstractFoo {
2
3    protected abstract void sayHi();
4}
5
6interface Playable {
7
8    void play();
9
10    default void playTogether() {
11        // do sth
12    }
13}
14
15public class Foo extends AbstractFoo implements Playable {
16
17    @Override
18    protected void sayHi() {
19        // do sth
20    }
21
22    @Override
23    public void play() {
24        // do sth
25    }
26
27    @Override
28    public void playTogether() {
29        // do sth
30    }
31}

1. 將 cursor 放喺 class 或 method 上面，等一兩秒，佢會顯示一個帶有 Javadoc 既 popup，除非 API developer 冇寫，否則都會有文字描述。 呢個時候可以撳 F2，或將 cursor 放喺呢個 popup 上面，等一秒，mouse 撳一撳個 popup 既文字，呢個時候就可以有多啲操作。
2. 你亦可以按住 Ctrl 鍵，然後 mouse 撳落個 class 或 method 上，就可以直接踩入 API developer 寫既 code 裡面。

1. Drag 個 Install 掣去 Eclipse 度安裝。
2. 安裝最基本既 Core component 就夠。
3. 去 menu bar > Window > Preferences > 左邊 filter text 打 file asso > 揀 File Associations > 右邊 File types 揀 .class without source > 下面 set Class Decompiler Viewer 做 default。

• Java decompiler plugin for Eclipse IDE
• Eclipse 中安裝反編譯工具 Fernflower（Enhanced Class Decompiler）