跳到主要內容
← 回到學習

學習 · 程式語言

Java SE 6 技術手冊

By Kurau7 分鐘閱讀

目錄 · 8 個段落
  1. 017.1 定義類別(Class)
  2. 02完整 Java 類別範例
  3. 03Java 類別的關鍵元素
  4. 04OOP 四大特性的 Java 實作
  5. 05Interface(介面)
  6. 06static 變數陷阱
  7. 07OOP 設計流程(物件分析簡介)
  8. 08Java SE 6 之後的演進(2026 視角)

Java SE 6 技術手冊 — 以物件思考問題

TL;DR
OOP 的第一步是「以物件為中心思考問題」:從需求中找 名詞 → 識別物件、屬性,找 動詞 → 識別方法。Java 用 class 定義物件規格、new 建立實例。public / private 控制成員可見度,基本原則是「資訊最小化公開」。
主要參考
良葛格 — Java SE 6 技術手冊

7.1 定義類別(Class)

物件導向設計的第一步:如何描述問題中的元素、如何將它們定義成物件,也就是 如何封裝資訊。

7.1.1 以物件思考問題

範例需求
「有一個帳戶,帳戶中有存款餘額。可以對帳戶進行存款與提款,並可以查詢餘額。」

識別物件與屬性

從問題中的名詞識別物件:

  • 「帳戶」 → 物件 Account
  • 「餘額」 → 屬性 balance(也可以視為物件,但這個粒度暫不需要)

從問題的靜態特性識別屬性:

  • 帳戶有什麼狀態? 餘額、帳戶號碼

識別物件方法

從動詞識別方法:

  • 「存款」 → deposit()
  • 「提款」 → withdraw()
  • 「查詢餘額」 → getBalance()

完整 Java 類別範例

public class Account {
    private String accountNumber;       // 私有屬性
    private double balance;
 
    // 預設建構方法
    public Account() {
        this("empty", 0.0);
    }
 
    // 自訂建構方法
    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
 
    public String getAccountNumber() {
        return accountNumber;
    }
 
    public double getBalance() {
        return balance;
    }
 
    public void deposit(double money) {
        balance += money;
    }
 
    public double withdraw(double money) {
        balance -= money;
        return money;
    }
}
java

使用方式

Account account1 = new Account();                       // 用預設建構
Account account2 = new Account("123-4567", 100.0);      // 用自訂建構
 
account1.deposit(1000.0);
System.out.println(account1.getBalance());              // 1000.0
java

Java 類別的關鍵元素

1. class 關鍵字 + 檔名規則

// 檔名必須是 Account.java
public class Account {
    // ...
}
java
Java 檔名規則
  • 每個檔案最多一個 public class
  • public class 名稱 必須跟檔名同名
  • 同一檔案可以有多個非 public 的 class,各自編譯成獨立 .class 檔
  • 執行時用 java ClassName(不是 java filename.java)

2. 成員(Members)

成員類型例說明
Field(資料成員)private double balance屬性、狀態
Method(方法成員)public void deposit(...)行為
Constructor(建構方法)public Account()創建時呼叫

3. 可見度修飾符

修飾符可見範圍
public所有 class 都看得到
private只有自己 class 內
protected自己 + 子類 + 同 package
(不寫)同 package(default / friendly)
資訊最小化公開原則
儘量透過方法操作物件,不要直接讓外部存取 field。 違例會造成 程式設計人員亂改內部狀態,維護地獄。 範例:accountNumber / balance 都是 private,外面只能透過 getXxx() 看到。

4. 建構方法(Constructor)

與類別同名的特殊方法,用來 初始化物件:

public Account() {
    this("empty", 0.0);                 // ⭐ this() 呼叫另一個建構方法
}
 
public Account(String accountNumber, double balance) {
    this.accountNumber = accountNumber; // ⭐ this 指向當前物件
    this.balance = balance;
}
java

特性:

  • 沒有回傳值(連 void 都不寫)
  • 可以 overload(多個不同參數版本)
  • 不寫 constructor 時 Java 自動給一個無參數的 default

OOP 四大特性的 Java 實作

1. 抽象(Abstraction)

// 抽象 class — 不能 new,只能繼承
abstract class Vehicle {
    abstract void move();           // ⭐ 抽象方法,只宣告不實作
    void stop() {                   // 一般方法,可有實作
        System.out.println("stopped");
    }
}
 
class Car extends Vehicle {
    @Override
    void move() {
        System.out.println("driving");
    }
}
java

2. 封裝(Encapsulation)

透過可見度修飾符 + getter/setter:

public class User {
    private String password;        // 外部看不到
 
    public boolean checkPassword(String input) {
        return this.password.equals(input);   // 透過方法檢查
    }
}
java

3. 繼承(Inheritance)

class Animal {
    void eat() { System.out.println("eating"); }
}
 
class Dog extends Animal {
    void bark() { System.out.println("woof"); }
 
    @Override
    void eat() { System.out.println("dog eating");}   // 覆寫父類
}
java

4. 多型(Polymorphism)

Animal a = new Dog();
a.eat();                            // ⭐ 印 "dog eating"(動態繫結)
java

父類別參考可以指向子類別物件,呼叫方法時用 子類別實際版本。

Interface(介面)

// 純抽象的契約
interface Drivable {
    void drive();
    int getMaxSpeed();
}
 
class Car implements Drivable {
    @Override
    public void drive() { /* ... */ }
 
    @Override
    public int getMaxSpeed() { return 200; }
}
java

Java 8+ 加入 default method,介面也可以有實作:

interface Drivable {
    void drive();
    default void honk() {                // ⭐ 有預設實作
        System.out.println("honk!");
    }
}
java

static 變數陷阱

class Test {
    static int classVar = 0;            // ⭐ 類變數,全 class 共享
    int instanceVar = 0;                // 實例變數,每物件獨立
}
 
Test t1 = new Test();
Test t2 = new Test();
 
t2.classVar = 10;
System.out.println(t1.classVar);        // 10!(共享)
System.out.println(t2.instanceVar);     // 0(獨立)
java

static 變數 是 整個 class 一份,所有實例看到同一個。改一個影響全部。

適合:常數(配 final)、計數器、單例。 不適合:任何 user-specific 資料(會踩雷)。

OOP 設計流程(物件分析簡介)

1. ==識別物件==(從名詞)
2. ==識別屬性==(物件的靜態特性)
3. ==識別方法==(物件的行為)
4. ==設計類別關係==(繼承 / 組合 / 依賴)
5. ==實作==(寫 Java 程式碼)

這就是 OOA / OOD 的簡化版。詳見:

  • 物件導向分析(OOA Object-Oriented Analysis)
  • 物件導向設計(OOD Object-Oriented Design)
  • 物件導向程式設計基本原則 - SOLID
進階閱讀
Craig Larman, Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process(2nd Ed.) — 經典 OOAD 教科書

Java SE 6 之後的演進(2026 視角)

Java SE 6 是 2006 年的東西,實務已遠去。但概念仍適用:

版本重要新特性
Java 8 (2014)Lambda / Stream API / default method / Optional
Java 9 (2017)Module system
Java 11 (2018, LTS)var 關鍵字
Java 14 (2020)Record(immutable data class)
Java 17 (2021, LTS)Sealed class / Pattern matching
Java 21 (2023, LTS)Virtual threads / Pattern matching for switch
// 現代 Java(17+)— record + pattern matching
record Account(String number, double balance) {}
 
if (account instanceof Account a && a.balance() > 0) {
    System.out.println("Active account: " + a.number());
}
java

2026 年寫新 Java code 直接走 Java 21,Spring Boot 3 / Quarkus 都已支援。

目錄