用 Java 入門物件導向程式設計

焦點話題

從 C++ 到 Java 的物件導向程式設計

物件導向設計原則（SOLID）… Wikipedia
物件導向設計模式 … 菜鸟教程
MVC 軟體架構 … Wikipedia
重構（Refactoring）… 林維展的學習筆記
Scrum 與敏捷開發 … Microsoft 365 Team：如何為您的專案選擇最佳敏捷做法

是抽象還是想像？
為何會把物件導向拿來對照真實世界的物件？
不要違反 Java 的物件導向思維
如何寫出好的程式？什麼是好的設計？
用 UML 進行物件導向系統分析與設計，用 Java 進行物件導向程式設計。
Java 不再免費？

應用範例

String（不可變物件的字串）
StringBuilder（可變字串）
格式化字串
Regular Expression

陣列
Collections 速成（各式資料結構）
亂數

資料夾與檔案的管理
純文字文件的寫入與讀取
以二進制格式讀寫資料
將 Java 物件轉為檔案形式（序列化）

命令列介面的程式設計
調用作業系統的命令
Swing 快速入門
變更視窗樣式
對話視窗
JScrollPane
JTable

日期與時間
計時器
暫停一段時間
列印

複製物件
Observer pattern（觀察者設計模式）

其它功能

javac
jar
JavaScript 引擎：Rhino
Tomcat + JSP + SQL 快速入門

類別（Class）

Java 規定所有程式都必須以類別來撰寫，所以即使只想宣告一個整數型態的變數，也必須這麼寫：

class A{ int i; }
將類別建立成物件，並存取變數的方式如下：

class A{ int i; public static void main(String[] args){ A a = new A(); a.i = 5; System.out.print(a.i); } }

5

main() 是 Java 內定的函式，Java 虛擬機器只要看到這個名稱的函式，就會自動執行裡面的程式碼。static 表示不用建立物件也能使用，也就是說不用 new 一個 Main 物件就能呼叫 main()。main() 一定要宣告為 public 表示公開使用，否則 Java 虛擬主機會找不到它。

Java 跟 C++ 一樣，將類別變數和函式稱為成員（member），但 C++ 將類別裡面的變數和函式稱為成員變數和成員函式，Java 改稱欄位（field）和方法（method）。

物件導向將呼叫物件的函式，稱為傳遞訊息（message passing）。程式只透過物件之間的訊息傳遞，來組織軟體，就叫物件導向程式設計。1

Java 的類別也引進了 C++ 的建構子、封裝、繼承、多型、覆載、多載、抽象…等物件導向基本功能，下面將逐一介紹。

建構子（Constructor）

跟 C++ 一樣，名稱與類別一樣，且沒有傳回值，就是建構子：

class A{ int i; A(){ i = 1; } }
如果有傳回值，像是 int、String、void，則是函式，而不是建構子。

建構子可以有參數，藉由參數的不同，來為類別設計多個建構子。

沒有建構子的話，Java 會自動建立一個呼叫 super() 函式的建構子。已經有建構子的話，就沒有自動呼叫 super() 的建構子，所以需要執行父類別的建構子時要記得要自己呼叫。

Java 虛擬機器有一套垃圾收集系統，會自動將浪費記憶體資源的物件釋放掉，所以不需要解構子（destructor）。雖然 Java 有 finalize() 函式，但這並不是解構子，而是垃圾收集決定回收該物件時自動執行的函式。

封裝（Encapsulation）

Java 引進了 C++ 的 public、private、protected，用來規劃類別的成員是公開存取還是限制存取：

public class A{ private int i; public void inc(){ i++; } }
變數 i 使用 private 表示只有自己能存取，函式 add 使用 public 表示別的物件也能使用。

比較特別的是，Java 規定類別使用 public 的話，存放該類別的檔案，檔名必須與類別名稱一樣。

protected 表示開放給子類別存取。

不使用存取權限的話，表示同套件的類別彼此間都能存取。雖然 Java 預設使用這種存取權限，但建議物件導向新手明確宣告 public 和 private，否則你會覺得整個設計一團亂、在組織程式元件的規劃上失去控制權。只有物件導向專家，才懂得用預設的存取權限，將物件用群組化的方式來設計，平常人會一團糟。

繼承（Inheritance）

Java 使用 extends 指令來繼承類別：

class A{ int i; void inc(){ i++; } } class B extends A{ int get(){ return i; } }
沒有使用 extends 時，Java 會自動繼承 java.lang.Object 物件。

在 C++ 使用多重繼承時，常常產生成員歸屬問題，所以 Java 只能繼承一個類別。Java 使用多重實作介面（interface）的方式，來表達多重繼承的關係。介面只宣告函式名稱，不實作函式功能，所以沒有責任歸屬的問題，一律由實作的類別負責。

多型（Polymorphism）

Java 跟 C++ 一樣，透過繼承讓不同子類別有共同的行為能力，再藉由子類別覆寫（override）父類別的函式，來實現多型的程式設計。

不一樣的是，Java 預設所有方法都是 virtual，所以子類別的方法只要同名、同參數，就能覆寫父類別的方法，這也是 Java 之所以稱為簡約語言的主要原因：

class A{ void f(){ System.out.println("AAA"); } } class B extends A{ void f(){ System.out.println("BBB"); } } class C extends A{ void f(){ System.out.println("CCC"); } } class Main{ static void test(A a){ a.f(); } public static void main(String[] args){ B b = new B(); C c = new C(); test(b); test(c); } }

BBB
CCC

或許，不是每個用過 C++ 的人都了解多型的意義，所以這裡還是補充一下觀念。

多型就是以同樣的訊息來表達不同的內容，或者以同樣的行為來進行不同的動作。舉個例子，你可以反覆用「你叫什麼名字」這行為向不同人發問，然後每個人會反應自己的狀況。

這項語法特性是物件導向程式設計與程序導向程式設計差異最大的地方，以往只能事先寫死程式碼來執行各種動作，有了多型會將程式碼設計成可擴充的元件，事後想要什麼再新增一個元件去用，靈活很多。

多載（Overload）

在 C++，類別的成員函式有個很棒的功能，就是函式名稱可以重複，只要參數不同，就可以視為不同函式。Java 也支援這項功能，讓物件導向程式設計更能表達語意：

class A{ void f(){ System.out.println("AAA"); } void f(String x){ System.out.println(x); } void f(String x, String y){ System.out.println(x + ", " + y + "!"); } } class Main{ public static void main(String[] args){ A a = new A(); a.f(); a.f("Hello"); a.f("Hello", "world"); } }

AAA
Hello
Hello, world!

其它特性

除了上述對 C++ 語法的改進，Java 也對物件導向程式設計做了重大改進！像是廢除指標運算能力的參照（reference）、不用再寫解構式的垃圾回收（garbage collection）、介面與實作分離的 abstract 和 interface…這些影響物件導向發展的特性，都是 Java 開創的！

加上 Java 包山包海的程式庫（Java API）、沙盒般的安全性2，能用 Java 寫應用程式，真是幸福的事～

但 Java 也有失策的地方，像是過於仰賴「所有類別都繼承自 java.lang.Object」的特性，想讓物件導向程式的語法盡可能簡化，所以沒有 C++ 的 template 和重載運算子。結果拖到 Java SE 5 和 Java SE 7 又陸續追加 C++ 這些語法功能，加與不加都造成災情。

想像

坦白說，物件導向程式設計的開發手法，其實還是跟程序導向一樣，可以重複利用的，就加以模組化，只是從函式改成類別來模組化你的程式，能夠更靈活管理一大群模組罷了！

亦即，物件導向絕對不是用來對照現實世界的開發手法！

學過「封裝」「繼承」「多型」依然不知道物件導向程式設計是怎樣的開發手法，就是因為想把現實世界搬到程式設計；但那不叫「抽象」，而叫「想像」。下場通常是過兩三年了，還無法建立起能夠彰顯物件導向精神的開發手法。

要建立讓自己感覺到漂亮的物件導向開發手法，應該回過頭來讓程式設計去像現實世界，這樣才叫「抽象」。或者說，你應該抽象的對象是依然是「程式」本身，而不是「現實世界的物體」，錯這一步就全盤通輸。

在傳統程式設計裡，根據程式的需求，分割出函式來使用，這就是一種針對程式本身所進行的抽象了！現在你只需要把函式改用類別來設計，就能在往後修改程式時，發現到程式具備的穩固性，不會因為大量修改而破壞系統的運作。千萬不要以為把現實事物寫在程式世界裡面叫做抽象！

所以「物件導向程式設計」並不複雜，只是一種能夠更靈活管理模組的程式語言而已，是牽扯上「物件導向專案管理」的手法才導致「物件導向」變成像玄學一樣詭譎的議題。因此，當你在初學「物件導向」感到迷惘時，請跳脫「物件導向分析」「物件導向設計」，剩下「物件導向編程」就好，單純地從程式設計的觀點，來理解物件導向的基本精神，會比較有效率。

但並不是拋棄「物件導向分析」「物件導向設計」，而是原本正常的學習過程，就應該從「程式設計」本身建立起物件導向的開發手法，然後為了「明文規範」這樣的開發手法，才將這些擴展為「物件導向分析」「物件導向設計」。1

抽象

在破除了把「想像」當「抽象」的魔障後，接著進一步來描述抽象的手法。

讓某個可以獨立運作的程式區段，變得像某個「對象」可以與它溝通交流，然後協力運作，這就是 object 了！

object 這一詞所表示的「物件」，是可以與你「相對立」的東西，而不是與你「相對等」的存在。

把程式碼變成與你相對立的東西，讓你可以對它進行操作，就是物件導向程式設計的精隨。讓某個程式區段變成可以穩固操作，而且沒有副作用，是很快樂的事！這件事就像從化學排列組織中調配出新的藥方，可以有效治療某個症狀，但身體卻沒有副作用一樣，設計物件導向程式的時候，都會感受到這樣的快樂2。

如果你企圖把整個世界搬到程式裡面，成為各個相對等的存在，那叫 things，而不是 object。把明明不真實存在的事情搬到程式裡面，然後說服自己說：「這些是物件。」你發揮的是想像，並不是抽象。把確實存在的程式碼，設計成相對立的東西，讓你可以更穩固、有效地重複使用它，才是物件導向真正所要的抽象精神。

為了物件而物件，或多或少在兌現獨立個體的設計～

物件導向程式設計語言並不是讓你把 Ball（球）、Court（球場）、Stand（球架）、Player（球員）、Rule（規則）、Score（計分）鉅細靡遺搬到程式裡面，企圖堆砌出一個想像世界的技術。但當你這麼做時，卻相當貼近物件導向程式設計的精神了：「每個物體都保持獨立性，球是球、場地是場地，球不必關心場地座落在哪或造價多少來製造，場地也不必關心球是哪個品牌或哪種顏色來設計。」

所以，你並不是不能建立 Ball、Stand、Player、Score…這些類別，只是我們並非為了把所有真實世界存在的物體，通通搬進程式碼裡面，讓我們的程式世界應有盡有，而建立出這些類別。我們是為了方便整理「可獨立運作的程式碼」才建立這些類別，讓外界只能接觸該個體公諸於世的功能特性使用它，讓它始終就是那樣的個體，不會時常因外界的需求條件變成另一種個體。

因此，不要為了物件而物件似的，瘋狂比照現實世界的事物，建立一堆類別。而是要讓不同個體能獨立於外物，讓某塊程式碼照自己需求條件發展，不受外界影響往後的設計，而寫成類別來管理。否則，即使你把所有事物都搬進程式碼裡面，卻彼此牽扯不清：「球會挑南北場地、場地會挑球的顏色。」那你的物件導向程式設計不管怎麼寫，永遠都不會有成熟的一天～

做為最高道德標準，不要陷入迷思。

以籃球來講，有室內球跟室外球的設計之分，這就是在挑場地了！

這時，我們繼續堅持保有類別不受外界影響的獨立性，不讓該類別被修改設計，以免時常演變成另一種不一樣的類別。只要費心思考，依然能夠不破壞程式碼獨立性，最小限度地「附加」公諸於世的新功能特性上去，而不是破壞設計。

但也不要陷入迷思，以為類別應該完全禁止受外界影響，我們的目標是：「以免『時常』演變成另一種不一樣的類別」，並不是『絕對』不能。

如果真的該設計一顆「拿到戶外打就會爆掉的室內籃球」，那就放手去設計這顆可以當炸彈的籃球吧 XDDD

Java 並不適合做為「學術派物件導向程式設計」的語言

你可能會想藉由 Java 來建立一套自己的物件導向思維，但真的不建議幹這種事，你會發現很多事都不能做。像是鉅細靡遺 import 所有用到的套件（甚至連 lang 都寫進來）、全面使用 this 叫用自身屬性與方法、不宣告 reference（參照）直接 new 一個 object（物件）…我知道這麼做一定有自己的想法，但在 Java 幹這些事，吃虧的份要比佔便宜來得大。

因為 Java 並非完整的物件導向程式語言

Java 一向自稱是完全物件導向的程式語言，而不是「完整的」物件導向程式語言。

這差異在於，Java 只是規定你必須用物件導向的結構來開發程式，因此使用 Java 語言設計出來的程式，確實是完全物件導向的結構。

不過，Java 卻把物件導向的做法給寫死，要求你照 Java 那一套物件導向思維來設計程式。而許多不在 Java 物件導向思維的語法功能，則不會納入 Java 語言。

於是 Java 語言確實是完全物件導向的程式設計，但卻是會讓你綁手綁腳的物件導向程式語言，因為它物件導向的機制不足，你心中思維的物件導向架構，有可能無法在 Java 程式語言建立起來，只能被迫改變自己真正想要的結構來通過 Java 認定的規範，因此稱不上是一款完整的物件導向程式語言

解決之道

若真要架構自己的物件導向規範，物件導向語法強大的 C++ 反而是比較適合的選擇。

但有時候我們不是為了開發軟體而在眾多語言中選擇 Java，而是為了跑 Java 所以試圖在上頭開發應用程式，沒得選擇。既然用 Java 程式語言，那與其建立自己的一套物件導向學術思維，不如遵循 Java 預設的物件導向學術思維～

那為何在物件導向的領域，Java 比 C++ 來得熱門？因為 C++ 的語法功能強悍到難以駕馭，剛上路的物件導向程式設計師，不曉得該怎樣整合得宜這群語法結構。反而規定你只能怎樣使用物件導向的 Java 是最好入門的選擇！

不盡然是缺點

雖然 Java 稱不上是完整的物件導向程式語言，但像這樣把物件導向的做法給規範成固定幾種範本，有個好處就是每個人寫出來的程式會變得類似，有助於團隊的開發。

Java 原本就不是自比 Perl 這類「There's more than one way to do it（不只一種做法來做一件事）」的萬能型程式語言，反而是希望做法減到最低，能在特定幾個領域提升開發效率的程式語言。

好的程式，不是寫來彰顯技術，而是讓沒技術的人也讀得懂～

漸漸熟悉程式設計以後，首先，最容易發生的，就是質疑自己寫的程式不夠水準，然後開始思考，該怎樣寫出好的程式？

而思考的方向往往是，怎樣寫才能讓自己顯得高竿一些？不希望寫出來的程式碼，讓人家看了以後，認為你像初學者般笨拙。

於是可能傾向於這樣寫程式：

import java.io.File; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Element; public class ArticleElement{ private Element element; public ArticleElement(String x){ try{ //從 x 傳入的 6 位數字中，取前四位為檔名，後兩位為索引值，來傳回 XML 檔中的某個節點。 element = (Element)DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(x.substring(0,4) + ".xml")).getElementsByTagName("article").item(Integer.parseInt(x.substring(4,6))-1); } catch(Exception exception){ exception.printStackTrace() ; } } }
然而，這種純粹只是節省行數或者字數，對執行效能沒有實際提升的寫法，並不叫做好的程式。1

真正好的程式，是寧可多花幾行程式，讓閱讀你程式碼的人，能輕鬆自在地理解你想要傳達的想法：

import java.io.File; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Element; public class ArticleElement{ private Element element; public ArticleElement(String id){ String filename = id.substring(0,4); File xmlfile = new File(filename + ".xml"); int which = Integer.parseInt(id.substring(4,6))-1; try{ element = (Element)DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(xmlfile).getElementsByTagName("article").item(which); } catch(Exception exception){ exception.printStackTrace() ; } } }
所以，別再為「怎樣寫才叫好的程式」這種問題感到疑惑，最笨拙的寫法，往往就是最好的程式。

自認為高竿的程式碼，但沒人明白是在做什麼事，其實是最差勁的程式！能故意用最笨拙的方式，寫出連小朋友看了以後，都大概知道是在做什麼的程式碼，才是好程式。2

除了好的程式，還要有好的設計。

那麼，把上面的範例，寫得像下面載明得更仔細呢？

import java.io.File; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.FactoryConfigurationError; import javax.xml.parsers.ParserConfigurationException; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.xml.sax.SAXException; public class ArticleElement{ private Document document; private Element element; public ArticleElement(String id){ String filename = id.substring(0,4); File xmlfile = new File(filename + ".xml"); try{ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); this.document = builder.parse(xmlfile); } catch(FactoryConfigurationError factory_configuration_error){ factory_configuration_error.printStackTrace(); } catch(IOException io_exception){ io_exception.printStackTrace(); } catch(ParserConfigurationException parser_configuration_exception){ parser_configuration_exception.printStackTrace(); } catch(SAXException sax_exception){ sax_exception.printStackTrace(); } int which = Integer.parseInt(id.substring(4,6))-1; this.element = (Element)this.document.getElementsByTagName("article").item(which); } }
這是好是壞，還真的見仁見智…

Java 8u211、Java 11

Java 17

比較字串內容

有三種，而且比較的原理不同，請務必釐清箇中差異，否則依賴比對字串來動作的程式將設計失敗：

public class Main{ public static void main(String[] args){ String a = "HELLO"; String b = "HELLO"; if(a==b){ System.out.println("兩物件指向同一筆資料。"); } if(a.intern()==b.intern()){ System.out.println("兩物件傳回的資料相同。"); } if(a.equals(b)){ System.out.println("兩物件的資料相同。"); } } }

兩物件指向同一筆資料。
兩物件傳回的資料相同。
兩物件的資料相同。

從字串中尋找文字所在位置

public class Main{ public static void main(String[] args){ String a = "ABCDEFG"; System.out.println(a.indexOf("D")); System.out.println(a.indexOf("FG")); System.out.println(a.indexOf("Z")); } }

3
5
-1

找不到的話傳回 -1，因此這個功能也常常用來檢查字串中有沒有特定文字，例如：

if(a.indexOf("#")<0){
　doSomething();
}

另外還有類似的 lastIndexOf() 可用，差別在於改從字串尾端往前尋找，但結果不變。

以 Regular Expression 比對資料

雖然 indexOf() 就可用來檢查字串中有沒有特定資料，但主要任務並非如此，所以可以選用真正專門用來執行這樣任務的 matches()，它可用 Regular Expression 語法來檢查資料。

底下範例用 Regular Expression 設定條件，檢查字串的資料是否符合 Hex 寫法的 RGB 值：

public class Main{ public static void main(String[] args){ String a = "#6699CC"; String b = "#RRGGBB"; System.out.println(a.matches("[#]?[\\da-fA-F]{6}")); System.out.println(b.matches("[#]?[\\da-fA-F]{6}")); } }

true
false

取得某個位置的字元

public class Main{ public static void main(String[] args){ String a = "ABCDEFG"; System.out.print(a.charAt(3)); } }

D

因為要指定第一個字元的話是 0，所以指定為 3 所獲得的字元為 D。

擷取字串

public class Main{ public static void main(String[] args){ String a = "ABCDEFG"; System.out.println(a.substring(2,4)); } }

CD

不是很直覺的參數，容易誤以為是第三個字元到第五個字元，但其實第二個參數是「終點」，並不是「從…到…」，要特別記住。

也可以不用第二個參數，這樣則是從指定的某個字元開始擷取往後的所有字串內容。

混搭 indexOf() 與 substring()

底下範例從 [password=abc123] 這組字串中2，擷取出 password 與 abc123。

public class Main{ public static void main(String[] args){ String section = "[password=abc123]"; String name = section.substring(section.indexOf("[") + 1, section.indexOf("=")); String value = section.substring(section.indexOf("=") + 1, section.indexOf("]")); System.out.println(name); System.out.println(value); } }

password
abc123

分離字串

public class Main{ public static void main(String[] args){ String string = "AAA,BBB,CCC"; String[] strings = string.split(","); System.out.print(strings[2]); } }

CCC

上面的程式可以簡化成：

public class Main{ public static void main(String[] args){ System.out.print("AAA,BBB,CCC".split(",")[2]); } }
這招尤其適合用來快速取得 CSV 格式中想要的資料！特別是以純文字文件的「行」為 row，以 split() 的陣列索引值為 column，一個「資料表」很簡單就實現了。

替換字串中的文字資料

public class Main{ public static void main(String[] args){ String a = "HELLO"; String b = a.replace("L", "-"); System.out.print(b); } }

HE--O

值得注意的是，b 雖然是 HE--O，但 a 依然是 HELLO。

以 Regular Expression 一次替換多種條件

如果想替換掉的文字不只一個，又不想多寫一行程式來替換，可以使用 Regular Expression 做為條件。下面的範例，一行就將 HELLO 中的 L 和 O 全部替換為 - 符號：

public class Main{ public static void main(String[] args){ String a = "HELLO"; String b = a.replaceAll("L|O", "-"); System.out.print(b); } }

HE---

連接字串

public class Main{ public static void main(String[] args){ String a = "ABCDEFG"; String b = a.concat("HIJKLMNOP"); System.out.println(b); System.out.println(a); } }

ABCDEFGHIJKLMNOP
ABCDEFG

這個範例值得注意的是，b 雖然獲得連接了字串的內容，但 a 本身的資料並未改變。

削掉頭尾空白

public class Main{ public static void main(String[] args){ String a = " ABCDEFG"; //注意 A 的前面留了一個空白 System.out.println(a); System.out.println(a.trim()); } }

 ABCDEFG
ABCDEFG

轉換為大小寫

public class Main{ public static void main(String[] args){ String a = "Twideem Civs"; System.out.println(a.toUpperCase()); System.out.println(a.toLowerCase()); } }

TWIDEEM CIVS
twideem civs

有時候需要檢查字串內容時，先全部轉為大寫或小寫，再來處理會比較適合。所以這個功能雖然只適用於英文字母，但還是用得到，尤其是設計登入介面，處理英文字母的帳號。

將數值轉為字串

public class Main{ public static void main(String[] args){ int a = 123; int b = 456; System.out.println(a+b); System.out.println(String.valueOf(a)+String.valueOf(b)); } }

579
123456

如果想將兩個數值資料用 + 串起來成為文字，會變成兩個數值進行加法運算，而不是串接。這時就適合用 valueOf() 功能。

將物件型態的字串轉輸出為基本型態 char 的陣列

public class Main{ public static void main(String[] args){ String a = "ABCDEFG"; char[] b = a.toCharArray(); for(int n=0; n<b.length; n++){ b[n]+=1; } System.out.println(b); } }

BCDEFGH

適合逐一針對字串裡面每個字元進行運算的場合。

字串的 Unicode 值

public class Main{ public static void main(String[] args){ String a = "猜猜我是誰"; char[] b = a.toCharArray(); for(int n=0; n<b.length; n++){ System.out.println(b[n] + " \\u" + Integer.toHexString(b[n]) + " &#" + (int)b[n] +";"); } } }

猜 \u731c 猜
猜 \u731c 猜
我 \u6211 我
是 \u662f 是
誰 \u8ab0 誰

直接對字串資料操作物件功能

以 "" 括住的資料，本身就是 String 物件了，因此可以直接對其呼叫 Stirng 的功能：

public class Main{ public static void main(String[] args){ System.out.print("ABCDEFG".indexOf("D")); } }

3

加入字串

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder(); string_builder.append("ABCDEFG"); System.out.print(string_builder.toString()); } }

ABCDEFG

插入字串

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.insert(3,"XYZ"); System.out.println(string_builder.toString()); } }

ABCXYZDEFG

輸出字串

StringBuilder 並非 String，因此不能將它代入 String 的參數，必須使用 toString() 將內容以 String 輸出：

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder(); string_builder.append("ABCDEFG"); List<String> list = new ArrayList>String>(); list.add(string_builder.toString()); //沒 toString() 將編譯失敗 System.out.print(list.get(0)); } }

ABCDEFG

取得字元

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); System.out.print(string_builder.charAt(3)); } }

D

擷取字串

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); System.out.println(string_builder.substring(2,4)); } }

CD

更改字元

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.setCharAt(3,"-"); System.out.println(string_builder.toString()); } }

ABC-EFG

注意！既然是字元，第二參數用的是單引號，而不是雙引號，否則將編譯錯誤。

更改字串

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.replace(1,6,"-"); System.out.println(string_builder.toString()); } }

A-G

注意，與 String 的 replace() 參數用法不一樣。

將字串順序反過來

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.reverse(); System.out.println(string_builder.toString()); } }

GFEDCBA

刪除單一字元

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.deleteCharAt(2); System.out.println(string_builder.toString()); } }

ABDEFG

刪除連續字串

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.delete(1,6); System.out.println(string_builder.toString()); } }

AG

注意！跟 String 的 substring() 一樣，參數看起來並不直覺，第二個參數是終點（到哪裡為止），所以 (1,6) 而不是從第二個字元刪到第七個字元。

清空字串

StringBuilder 並沒有 clear() 這類操作方式，只好用 setLength(0) 將字串長度設為 0，以資料歸零的做法來折衷：

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); string_builder.setLength(0); string_builder.append("HIJKLMNOP"); System.out.print(string_builder.toString()); } }

HIJKLMNOP

削掉頭尾空白

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder(" ABCDEFG "); string_builder.trimToSize(); System.out.println(string_builder.toString()); } }

ABCDEFG

從字串中尋找文字所在位置

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); System.out.println(string_builder.indexOf("D")); } }

3

取得字串長度

public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder("ABCDEFG"); System.out.println(string_builder.length()); } }

7

Example 1

import java.util.Formatter; public class Main{ public static void main(String[] args){ System.out.print(new Formatter().format("%d", 123)); } }

123

Example 2

import java.util.Formatter; public class Main{ public static void main(String[] args){ StringBuilder string_builder = new StringBuilder(); Formatter formatter = new Formatter(string_builder); formatter.format("%1$d + %1$d = %2$d", 1, 2); System.out.print(string_builder); } }

1 + 1 = 2

Example 3

System.out.printf() 跑的其實就是 Formatter：

public class Main{ public static void main(String[] args){ System.out.print(String.format("%1$d + %1$d = %2$d\n", 1, 2)); System.out.printf("%1$d + %1$d = %2$d", 1, 2); } }

1 + 1 = 2
1 + 1 = 2

基本用法

import java.util.regex.Pattern; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ //設定規則為三個數字。 Pattern pattern = Pattern.compile("[\\d]{3}"); //輸入 ABC123 資料進行匹配，並且將結果傳至 Matcher 物件。 Matcher matcher = pattern.matcher("ABC123"); //如果資料匹配結果出現符合規則的字串，輸出符合匹配的結果。 if(matcher.find()){ System.out.print(matcher.group()); } } }

123

取得成功匹配結果的開頭位置與終點

import java.util.regex.Pattern; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ Pattern pattern = Pattern.compile("[\\d]{3}"); Matcher matcher = pattern.matcher("ABC123"); if(matcher.find()){ System.out.println(matcher.start()); System.out.println(matcher.end()); } } }

3
6

注意開頭位置是「第幾個字元開始」，但終點卻不是「第幾個字元結束」，而是「到哪裡為止」。

取代字串

import java.util.regex.Pattern; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ Pattern pattern = Pattern.compile("[\\d]"); Matcher matcher = pattern.matcher("ABC123"); if(matcher.find()){ System.out.print(matcher.replaceAll("-")); } } }

ABC---

完整匹配

有時候希望更簡單就能以嚴密的方式，比對整個字串是否能通過驗證。如下範例，Pattern 所 matcher() 的字串，必須從頭到尾都符合 compile() 設定的條件，才會傳回 true：

import java.util.regex.Pattern; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ //設定規則為三個數字 Pattern pattern = Pattern.compile("[\\d]{3}"); //傳入 123 三個數字 Matcher matcher = pattern.matcher("123"); //輸出結果 System.out.println(matcher.matches()); } }

true

底下示範無法通過規範：

import java.util.regex.Pattern; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ //設定規則為三個數字 Pattern pattern = Pattern.compile("[\\d]{3}"); //傳入 1234 四個數字 Matcher matcher = pattern.matcher("1234"); //輸出結果 System.out.println(matcher.matches()); } }

false

切割字串

使用 Pattern 的 split() 可將字串依照 compile() 所建立的規則，切割為好幾段的字串，而切割出來字串，以 String 陣列傳回：

import java.util.regex.Pattern; public class Main{ public static void main(String[] args){ //以 , 做為切割的依據 Pattern pattern = Pattern.compile(","); //開始分割字串 String[] strings = pattern.split("ABC,123,:)"); //將陣列輸出 for(int n=0; n<strings.length; n++){ System.out.println(strings[n]); } } }

ABC
123
:)

陣列

陣列是程式設計語言都有的語法功能，用來連續建立同樣型態的資料。

java.util.Arrays

陣列本身不是物件，因此沒有足夠的功能可以操作。為了更進一步靈活使用陣列，Java 提供了 Arrays。

它更讓人驚豔的是採用高效率的演算法來執行工作，提升解決問題的能力！

使用時機

陣列用途：

關聯表用途：

巡訪資料：

舊版做法：

範例

先以 ArrayList 為例：

import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main{ public static void main(String[] args){ List<String> list = new ArrayList<String>(); list.add("AAA"); list.add("BBB"); list.add("CCC"); Iterator<String> iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next().toLowerCase()); } } }

aaa
bbb
ccc

再以 TreeSet 為例：

import java.util.Iterator; import java.util.Set; import java.util.TreeSet; public class Main{ public static void main(String[] args){ Set<Integer> set = new TreeSet<Integer>(); set.add(8); set.add(4); //雖然是第二筆，但會被自動排序在 8 的前面。 set.add(8); //重複的資料，因此不會真的被加進去。 Iterator<Integer> iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } }

4
8

補充

為什麼使用 List list=new ArrayList() 或 Set set=new HashSet() 的方式來宣告參照？這是為了往後隨時可以抽換成其它類別。當我們發現所選的群集在處理資料並不適任時，就可以由 ArrayList 抽換成 LinkedList、或由 HashSet 抽換成 LinkedHashSet，而不影響程式其它部分。

當然，還可以更進一步！如果希望將來可以在 List 與 Set 中替換，那可以改用 Collection 介面，因為它是 List 與 Set 的共通介面：

import java.util.Collection; import java.util.HashSet; import java.util.Iterator; public class Main{ public static void main(String[] args){ Collection<String> collection = new HashSet<String>(); collection.add("AAA"); collection.add("BBB"); collection.add("CCC"); Iterator<String> iterator = collection.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } }
上例是用 HashSet 實作，現在直接換成 ArrayList，但其它地方都不需要修改：

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Main{ public static void main(String[] args){ Collection<String> collection = new ArrayList<String>(); collection.add("AAA"); collection.add("BBB"); collection.add("CCC"); Iterator<String> iterator = collection.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } }
然而，這樣做是需要犧牲的！例如 Collection 介面並沒有 List 介面的 get(int)，因此雖然可以從 Set 介面替換為 List 介面，但既然使用 Collection 介面，就不認得 get(int)，因此只能用 iterator() 來巡訪資料1。

這是理所當然的，既然要能隨時互相替換，那就應該用彼此都有的方式來操作。

如何在「初寫的方便性」與「修改的靈活性」之間做抉擇，端看我們對需求的掌握程度。

進階

java.util.Collections 提供許多 static 的 method，方便我們處理 Collection 的資料：

簡單示範其中的 shuffle，設計用電腦抽籤來決定聯盟球隊選秀順位的程式：

import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; public class Main{ public static void main(String[] args){ ArrayList<String> array_list = new ArrayList<String>(); array_list.add("兄弟象"); array_list.add("味全龍"); array_list.add("統一獅"); array_list.add("三商虎"); array_list.add("時報鷹"); array_list.add("俊國熊"); Collections.shuffle(array_list); Iterator<String> iterator = array_list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } }
每次執行結果都不一樣：

三商虎
味全龍
俊國熊
兄弟象
時報鷹
統一獅

補充

用來處理陣列的 java.util.Arrays，對 Collections 也有幫助，底下是利用 Arrays 產生 List 的範例，程式相當簡潔：

import java.util.List; import java.util.Arrays; public class Main{ public static void main(String[] args){ List<String> list = Arrays.asList("AAA","BBB","CCC"); for(String n:list){ System.out.print(n); } } }

AAA
BBB
CCC

如果可以再寫成 List<String> list = {"AAA","BBB","CCC"} 就好了，可惜 Java 不支援。

基本範例

import java.io.File; import java.util.Date; import java.text.DateFormat; public class Main{ public static void main(String[] args){ try{ //建立資料夾。 new File(".\\新增資料夾").mkdir(); //建立檔案。 new File(".\\新文字文件.txt").createNewFile(); //移動檔案。 new File(".\\新文字文件.txt").renameTo(new File(".\\新增資料夾\\新文字文件.txt")); //更改檔名。 new File(".\\新增資料夾\\新文字文件.txt").renameTo(new File(".\\新增資料夾\\舊文字文件.txt")); //取得檔案最後修改日期。 Date date = new Date(new File(".\\新增資料夾\\舊文字文件.txt").lastModified()); DateFormat date_rormat = DateFormat.getDateInstance(); System.out.println(date_rormat.format(date)); //檢查檔案是否存在，然後刪除檔案。（亦適用於檢查資料夾是否存在） File file = new File(".\\新增資料夾\\舊文字文件.txt"); if(file.exists()){ file.delete(); } //取得資料夾檔案清單。 String[] list = new File("C:").list(); for(int n=0; n<list.length; n++){ System.out.print(list[n] + ", "); } } catch(Exception exception){ exception.printStackTrace(); } } }

其它常見功能

import java.io.File; import java.text.SimpleDateFormat; import java.util.Date; public class Main{ public static void main(String[] args){ //修改資料夾內所有檔案的最後日期 try{ SimpleDateFormat simple_date_format = new SimpleDateFormat("yyyy/MM/dd-HH:mm:ss"); Date date = simple_date_format.parse("2002/02/06-12:34:56"); File files[] = new File("C:\\Users\\Twideem\\Documents").listFiles(); for(File file : files){ if(file.isFile()){ file.setLastModified(date.getTime()); } } } catch(Exception exception){ exception.printStackTrace(); } } }

直接套用作業系統預設格式來讀寫文字的 FileWriter 與 FileReader

為了方便程式設計師在不同作業系統，都能以相同的程式寫法，來存取純文字檔案的資料，Java 提供 FileWriter 與 FileReader，它會直接用作業系統預設的字元編碼與換行格式，來寫入與讀取純文字資料！

提升檔案讀寫效率的 BufferedWriter 與 BufferedReader

使用 FileWriter 與 FileReader 是直接對硬碟的檔案進行讀寫，如果讀寫頻繁的話，因為硬碟往往是電腦中速度最慢的裝置，應用程式的效率可能會被拖慢。因此 Java 又另外提供了 BufferedWriter 與 BufferedReader，可以先將硬碟檔案的資料緩存在速度較快記憶體來讀寫，提高應用程式的執行效率！

不只如此，BufferedWriter 與 BufferedReader 提供了更容易使用的方式來讀寫文字，所以很少人直接用 FileWriter 和 FileReader，寧願多一道程序捆入 BufferedWriter 和 BufferedReader。

使用 FileOutputStream 與 FileInputStream 指定字元編碼

常常聽到 FileWriter 和 FileReader 跨平台的說法！其實是「檔案讀寫」這個程式動作跨平台，而不是文字檔案本身跨平台。例如在預設使用 Big5 編碼的 Windows 寫入純文字文件，拿到預設使用 UTF-8 編碼的 Linux 碼讀取，還是會有亂碼的情況發生。所以我們應該掌握如何指定以某字元編碼來讀寫純文字文件的做法：

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; public class Main{ public static void main(String[] args){ try{ //以 UTF-8 儲存文字檔案 BufferedWriter buffered_writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("sample.txt"), "UTF-8")); buffered_writer.write("猜猜我是誰"); buffered_writer.close(); //以 UTF-8 讀取文字檔案 BufferedReader buffered_reader = new BufferedReader(new InputStreamReader(new FileInputStream("sample.txt"), "UTF-8")); System.out.print(buffered_reader.readLine()); buffered_reader.close(); } catch(Exception exception){ exception.printStackTrace(); } } }

猜猜我是誰

DataInputStream、DataOutputStream

與「純文字文件」不同的是，「二進制檔案」無法用「記事本」或「文書軟體」開啟來閱讀，會看到一堆亂碼。有些人不希望保存資料的檔案能夠直接被閱讀與修改，或者希望提高檔案的資料處理效率而使用它，屬於進階應用的檔案保存手法。

RandomAccessFile

RandomAccessFile 能進行 DataInputStream 與 DataOutputStream 一樣的工作效果，但只需要建立一個物件～

FileInputStream、FileOutputStream

前面範例是透過 Java 將資料以二進制格式寫入資料，往後再用 Java 讀出來用。但如果要讀取的，是像可執行檔、圖片、音樂、或其它程式產生的二進制檔案內容，那使用 FileInputStream 和 FileOutputStream 比較適合。

基本範例

進階項目

如果物件某些狀態不想被序列化的話，可以加上 transient 指令：

輸入

底下示範 Java 如何取得使用者用鍵盤輸入的資料～

輸出

命令列模式的輸出很簡單，使用 System.out.print() 能直接將資料以字串輸出，System.out.println() 一樣，但會自動換行。System.out.format() 提供了格式化輸出的功能，但因為這是仿效 C 語言的 printf() 而來，所以又提供 System.out.printf() 來呼叫它：

參數

在命令列下達程式指令時，經常都能尾隨一些參數，底下示範做法：

建立視窗

import javax.swing.JFrame; public class Main{ public static void main(String[] args){ //建立視窗物件。 JFrame frame = new JFrame(); //設定視窗大小、標題文字、然後顯示出來。 frame.setSize(400, 300); frame.setTitle("Hello, world!"); frame.setVisible(true); //按下關閉圖示鈕時結束應用程式，否則只是視窗不見，程序其實殘留著。 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
顯示結果：

加入按鈕

import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; public class Main{ private JFrame frame = new JFrame(); private JButton button = new JButton(); public Main(){ //建立視窗。 frame.setSize(400, 300); frame.setTitle("Hello, world!"); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //設定按鈕的位置、大小、標題文字。 button.setLocation(40, 100); button.setSize(300, 30); button.setText("別亂按"); //加入按鈕到視窗裡面。 frame.setLayout(null); frame.add(button); //觸發按下按鈕事件時，改變視窗的文字標題。 button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent action_event){ button.setText("不是叫你別亂按嗎"); } }); } public static void main(String[] args){ new Main(); } }
顯示結果：

你已經快速入門了～

依樣畫葫蘆，陸續加入像是：文字標籤的 JLabel、文字區域的 JTextArea、單行輸入欄的 JTextField、密碼輸入欄位 JPasswordField…等等各式組件，就能打造出視窗了！

接著再查 API 看看各個元件有哪些功能可用，然後深入研究 java.awt.event 的其它事件處理，就能熟悉 Java 的視窗應用程式設計！

Java 內建視窗樣式

底下程式示範將視窗更換為 Metal 樣式：

import javax.swing.JFrame; import javax.swing.plaf.metal.MetalLookAndFeel; import javax.swing.UIManager; public class Main{ public static void main(String[] args){ //啟用 Java 預設的視窗外框 JFrame.setDefaultLookAndFeelDecorated(true); //將視窗樣式改為 Metal 風格 try{ UIManager.setLookAndFeel(new MetalLookAndFeel()); } catch(Exception exception){ exception.printStackTrace(); } //建立視窗 JFrame frame = new JFrame(); frame.setSize(320, 240); frame.setTitle("視窗標題"); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
顯示結果：



其它內建的視窗樣式還有如下，請自行嘗試：

javax.swing.plaf.gtk.GTKLookAndFeel
javax.swing.plaf.mac.MacLookAndFeel
javax.swing.plaf.motif.MotifLookAndFeel
javax.swing.plaf.nimbus.NimbusLookAndFeel
javax.swing.plaf.windows.WindowsClassicLookAndFeel
javax.swing.plaf.windows.WindowsLookAndFeel

另外，Windows 與 MacOS 並非跨平台的樣式，遇上相異的作業系統無法使用，會改用預設的樣式。因此顧慮跨平台問題的話，也可考慮以下自動處理跨平台問題的樣式：

UIManager.getSystemLookAndFeelClassName()
UIManager.getCrossPlatformLookAndFeelClassName()


Steel Theme

Java SE 5.0 時，推出新的 Metal 風格，叫做 Ocean Theme，較為明亮。J2SE 1.4 時，Metal 風格叫做 Steel Theme，比較暗沉，而且元件的層次之間沒什麼立體感，辨識度較差。

由於 Java SE 5.0 開始將 Ocean 做為 Metal 風格的預設主題，因此如果你想切換回 Steel 主題，程式碼如下：

import javax.swing.JFrame; import javax.swing.plaf.metal.DefaultMetalTheme; import javax.swing.plaf.metal.MetalLookAndFeel; import javax.swing.UIManager; public class Main{ public static void main(String[] args){ //啟用 Java 預設的視窗外框 JFrame.setDefaultLookAndFeelDecorated(true); MetalLookAndFeel.setCurrentTheme(new DefaultMetalTheme()); //將視窗樣式改為 Metal 風格 try{ UIManager.setLookAndFeel(new MetalLookAndFeel()); } catch(Exception exception){ exception.printStackTrace(); } //建立視窗 JFrame frame = new JFrame(); frame.setSize(320, 240); frame.setTitle("視窗標題"); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

第三方視窗樣式

網路可以找到不少 Swing 的視窗樣式可以套用，首先推薦 JTatto，因為下載這個套件，就能切換十數種樣式1，而且每種樣式都經過精心配置，每樣都比其他人的樣式精美。請至官網下載：

http://www.jtattoo.net

目前為止 JTatto 可用的樣式如下：

com.jtattoo.plaf.acryl.AcrylLookAndFeel
com.jtattoo.plaf.aero.AeroLookAndFeel
com.jtattoo.plaf.aluminium.AluminiumLookAndFeel
com.jtattoo.plaf.bernstein.BernsteinLookAndFeel
com.jtattoo.plaf.fast.FastLookAndFeel
com.jtattoo.plaf.graphite.GraphiteLookAndFeel
com.jtattoo.plaf.hifi.HiFiLookAndFeel
com.jtattoo.plaf.luna.LunaLookAndFeel
com.jtattoo.plaf.mcwin.McWinLookAndFeel
com.jtattoo.plaf.mint.MintLookAndFeel
com.jtattoo.plaf.noire.NoireLookAndFeel
com.jtattoo.plaf.smart.SmartLookAndFeel
com.jtattoo.plaf.texture.TextureLookAndFeel

各樣式顯示結果依順序如下：

訊息視窗

純粹跳出對話視窗顯示一下訊息，頂多搭配圖示方便使用者判斷訊息，有五種可用…

確認視窗

跳出詢問用的對話視窗，可根據傳回值，判斷使用者的回覆：

JOptionPane.YES_OPTION
JOptionPane.NO_OPTION
JOptionPane.CANCEL_OPTION
JOptionPane.OK_OPTION
JOptionPane.CLOSED_OPTION

依按鈕的配置，總共有四種…

輸入視窗

檔案視窗

雖然有兩種方式可以呼叫不一樣的對話視窗，但其實只有標題列文字不一樣而已，取得檔案的行為一模一樣。為了方便研究，依然分開寫兩個範例如下：

色彩選擇器

import java.awt.Color; import javax.swing.JColorChooser; public class Main{ public static void main(String[] args){ Color color = JColorChooser.showDialog(this, "COLOR CHOOSER", Color.GRAY); } }

捲動軸

底下示範為 JTextArea 添加捲動軸：

import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTextArea; public class Main{ public static void main(String[] args){ JFrame frame = new JFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(320, 240); frame.setVisible(true); JTextArea text_Area = new JTextArea(); JScrollPane scroll_pane = new JScrollPane(); scroll_pane.setViewportView(text_Area); scroll_pane.setSize(312, 209); scroll_pane.setLocation(0, 0); frame.setLayout(null); frame.add(scroll_pane); } }
執行程式並貼上文字後：

其它設定

可用 scroll_pane.setHorizontalScrollBarPolicy() 設定垂直捲軸的顯示時機：

JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS （顯示）
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED （自動）
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER （隱藏）

可用 scroll_pane.setVerticalScrollBarPolicy() 設定水平捲軸的顯示時機：

JScrollPane.VERTICAL_SCROLLBAR_ALWAYS （顯示）
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED （自動）
JScrollPane.VERTICAL_SCROLLBAR_NEVER （隱藏）

將元件做為 JScrollPane() 建構式參數的話，相當於 scroll_pane.setViewportView() 的功能，例如：JScrollPane scroll_pane = new JScrollPane(text_area)。

產生表格

import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTable; import javax.swing.table.DefaultTableModel; public class Main{ public static void main(String[] args){ JFrame frame = new JFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(433, 219); frame.setVisible(true); String[] headline = {"姓名","背號","位置"}; Object[][] data = new Object[20][3]; DefaultTableModel table_model = new DefaultTableModel(data, headline); JTable table = new JTable(table_model); JScrollPane scroll_pane = new JScrollPane(table); scroll_pane.setSize(424, 185); scroll_pane.setLocation(0, 0); frame.setLayout(null); frame.add(scroll_pane); } }
顯示結果如下：

操作表格

針對上一節範例的 table_model 物件，進行「欄」「列」「資料」的相關操作。

//新增列 Object[] objects = new Object[3]; table_model.addRow(objects); //插入列 Object[] objects = new Object[3]; table_model.insertRow(3, objects); //搬移多列資料 table_model.moveRow(0, 3, 1); //第 0 列到第 3 列搬移到第 1 列 //取得列數 table_model.getRowCount(); //更改列數 table_model.setRowCount(3); //刪除列 table_model.removeRow(2); //刪最後列 int row_count = table_model.getRowCount() - 1; if(row_count>=0){ table_model.removeRow(row_count); table_model.setRowCount(row_count); } table.revalidate(); //新增欄 table_model.addColumn("新增欄"); //取得欄位名稱 table_model.getColumnName(column_count); //取得欄數 table_model.getColumnCount(column_count); //刪最後欄 int column_count = table_model.getColumnCount() - 1; if(column_count>=0){ javax.swing.table.TableColumnModel table_column_model = table.getColumnModel(); javax.swing.table.TableColumn table_column = table_column_model.getColumn(column_count); table_column_model.removeColumn(table_column); table_model.setColumnCount(column_count); } //設定資料 table_model.setValueAt("HELLO", 0, 0); //第 0 列第 0 行設為 HELLO //取得資料 table_model.getValueAt(0, 0).toString(); //取出第 0 列第 0 行的資料

讓表格能對應資料型別

表格可以根據資料型態的種類，作出不同的顯示：

先建立新的類別 MyTableModel.java 讓它繼承 DefaultTableModel，然後複寫 getColumnClass()，再將 Main.java 的 DefaultTableModel 改為 MyTableModel 即可。

取得日期與時間

import java.text.DateFormat; import java.util.Date; public class Main{ public static void main(String[] args){ //取得電腦當前的時間 Date date = new Date(); //輸出日期與時間 System.out.print(DateFormat.getInstance().format(date)); } }
執行結果隨電腦當時的時間與時區而不同：

2002/8/29 下午 12:34

只想輸出日期的話，可用 DateFormat.getDateInstance().format(date)) 輸出「2002/8/29」，只想輸出時間的話，可用 DateFormat.getTimeInstance().format(date)) 輸出「下午 12:34:56」。

分別取得年、月、日、週、時、分、秒

import java.util.Date; import java.text.SimpleDateFormat; public class Main{ public static void main(String[] args){ Date date = new Date(); System.out.println("年：" + new SimpleDateFormat("y").format(date)); System.out.println("月：" + new SimpleDateFormat("M").format(date)); System.out.println("日：" + new SimpleDateFormat("d").format(date)); System.out.println("週：" + new SimpleDateFormat("E").format(date)); System.out.println("午：" + new SimpleDateFormat("a").format(date)); System.out.println("時：" + new SimpleDateFormat("h").format(date)); System.out.println("分：" + new SimpleDateFormat("m").format(date)); System.out.println("秒：" + new SimpleDateFormat("s").format(date)); } }
執行結果隨電腦當時的時間與時區而不同：

年：2002
月：8
日：29
週：星期四
午：下午
時：12
分：34
秒：56

有 SimpleDateFormat，想取得「年、月、日、週、時、分、秒」時，可別傻傻用 DateFormat 傳回的字串去剖析。

自訂日期與時間的輸出格式

import java.util.Date; import java.text.SimpleDateFormat; public class Main{ public static void main(String[] args){ Date date = new Date(); System.out.println(new SimpleDateFormat("yyyy 年 MM 月 dd 日 E a h:m:s").format(date)); } }
執行結果隨電腦當時的時間與時區而不同：

2002 年 8 月 29 日 星期四 下午 12:34:56

指定時間

import java.text.DateFormat; import java.util.Calendar; public class Main{ public static void main(String[] args){ //建立 Calendar Calendar calendar = Calendar.getInstance(); //分別設定年、月、日、時、分、秒 calendar.set(Calendar.YEAR, 2002); calendar.set(Calendar.MONTH, Calendar.AUGUST); calendar.set(Calendar.DAY_OF_MONTH, 29); calendar.set(Calendar.HOUR_OF_DAY, 12); calendar.set(Calendar.MINUTE, 34); calendar.set(Calendar.SECOND, 56); //顯示結果 System.out.println("年：", calendar.get(Calendar.YEAR)); System.out.println("月：", calendar.get(Calendar.MONTH)+1); System.out.println("日：", calendar.get(Calendar.DAY_OF_MONTH)); System.out.println("週：", calendar.get(Calendar.DAY_OF_WEEK)-1); System.out.println("時：", calendar.get(Calendar.HOUR_OF_DAY)); System.out.println("分：", calendar.get(Calendar.MINUTE)); System.out.println("秒：", calendar.get(Calendar.SECOND)); } }
執行結果：

年：2002
月：8
日：29
週：4
時：12
分：34
秒：56

彆扭的是，Calendar 的一月是 0，所以取得月份時要加 1，設定月份時則用常數比較直覺。星期幾就複雜了，不同地區，有些星期日是每週的第一天，有些星期一是每週是第一天，導致台灣取得星期幾要減 1。

事前準備

除非你嫌墨匣太多，否則建議安裝 PDFCreator 充當印表機，在練習列印的功能時，將列印結果以 PDF 文件來儲存。或者 Windows Vista 開始內建的 Microsoft XPS Document Writer 也有同樣功能。

這樣在執行列印功能時，就可以不用拿真的印表機來測試，列印的結果改用 PDF 文件或 XPS 文件來輸出與顯示：

基本列印的語法架構

底下範例是最簡單的列印1，會在紙張上印出 Hello 字串：

import java.awt.Graphics; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class Main implements Printable{ //實作 Printable 介面的 print() 功能 public int print(Graphics graphics, PageFormat page_format, int page_index) throws PrinterException{ if(page_index>0){ return Printable.NO_SUCH_PAGE; } else{ //在 (100, 150) 的位置，繪出 Hello 字串。 graphics.drawString("Hello", 100, 150); return Printable.PAGE_EXISTS; } } public static void main(String[] args){ try{ //建立列印工作。 PrinterJob printer_job = PrinterJob.getPrinterJob(); //指定系統預設的紙張格式（A4），排入 Main() 實作的列印行程。 printer_job.setPrintable(new Main(), printer_job.defaultPage()); //呼叫列印對話視窗，確定後正式列印文件。 if(printer_job.printDialog()){ printer_job.print(); } } catch(Exception exception){ exception.printStackTrace(); } } }

改變文字樣式、取得紙張大小與可列印範圍

你可以透過 Graphics 改變文字的字型、大小、顏色，或其它樣式。而透過 PageFormat 的 getWidth()、getHeight()、getImageableWidth()、getImageableHeight()，可以取得紙張範圍的大小，避免資料列印到外界去了，例如：

import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class Main implements Printable{ public int print(Graphics graphics, PageFormat page_format, int page_index) throws PrinterException{ if(page_index>0){ return Printable.NO_SUCH_PAGE; } else{ //Dialog 字體、粗體、32 大小。 graphics.setFont(new Font("Dialog", Font.BOLD, 32)); //藍色。 graphics.setColor(Color.BLUE); //在可列印範圍皆除以二的位置，繪出 Hello 字串。 graphics.drawString("Hello", (int)page_format.getImageableWidth()/2, (int)page_format.getImageableHeight()/2); return Printable.PAGE_EXISTS; } } public static void main(String[] args){ try{ PrinterJob printer_job = PrinterJob.getPrinterJob(); printer_job.setPrintable(new Main(), printer_job.defaultPage()); if(printer_job.printDialog()) printer_job.print(); } catch(Exception exception){ exception.printStackTrace(); } } }

自訂紙張格式

或者使用 PageFormat 透過 Paper 自訂紙張尺寸，如下範例，它加大了 A4 紙張的可列印範圍，否則雖然紙張夠大，但允許的可列印範圍不夠，列印時超出範圍的部分會被切割掉：

import java.awt.Graphics; import java.awt.print.PageFormat; import java.awt.print.Paper; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class Main implements Printable{ public int print(Graphics graphics, PageFormat page_format, int page_index) throws PrinterException{ if(page_index>0){ return Printable.NO_SUCH_PAGE; } else{ graphics.drawString("Hello", 100, 150); return Printable.PAGE_EXISTS; } } public static void main(String[] args){ try{ PrinterJob printer_job = PrinterJob.getPrinterJob(); //自訂紙張範圍 PageFormat page_format = new PageFormat(); Paper paper = new Paper(); paper.setSize(590, 840); paper.setImageableArea(10, 10, 580, 830); page_format.setPaper(paper); //以自訂的紙張紙張格式，排入 Main() 實作的列印行程。 printer_job.setPrintable(new Main(), page_format); if(printer_job.printDialog()){ printer_job.print(); } } catch(Exception exception){ exception.printStackTrace(); } } }

A.java

public class A implements Cloneable{ public int x; public String y; public A clone() throws CloneNotSupportedException{ return (A)super.clone(); } }

Main.java

public class Main{ public static void main(String[] args){ try{ A a1 = new A(); a1.x = 123; a1.y = "abc"; A a2 = a1.clone(); } catch(Exception exception){ exception.printStackTrace(); } System.out.println(a2.x); System.out.println(a2.y); } }

123
abc

範例一：被監視者在狀態改變時發出通知，讓監視者做出反應。

範例二：取得被監視物件的狀態

常用參數

進階參數

其它參數

一個一個類別打包到 JAR 壓縮檔裡面。

jar cf 壓縮檔名稱.jar 類別一.class 類別二.class

將某個資料夾所有東西都打包到 JAR 壓縮檔裡面。

jar cf 壓縮檔名稱.jar -C 資料夾 .

注意 -C 是大寫！

只打包「子資料夾」到 JAR 壓縮檔裡面。

jar cf 壓縮檔名稱.jar -C 資料夾 ./子資料夾

如何執行 JAR 檔裡面的類別

假設你打包了一個 Application.jar，裡面有個 application 資料夾，這個資料夾裡面有 Main.class，那麼要執行 Application.jar 裡面的 Main.class 類別，方法是：

java -classpath Application.jar application.Main

Executable JAR

接續上一個「如何執行 JAR 檔裡面的類別」的案例，如果 application.Main 裡面有 main()，那麼在用 jar 打包時，可以多添加一個 e 參數將 application.Main 指定為入口（entrypoint）：

jar cfe Application.jar application.Main Main.class

以後就能直接執行 jar 檔：

java -jar Application.jar

甚至有安裝 JRE 或 IcedTea 的話，直接在 Application.jar 用滑鼠點兩下，就能執行程式，跟 *.exe 使用起來沒兩樣！

[META-INF]/MANIFEST.MF

上一節「Executable JAR」之所以能讓 *.jar 檔案成為執行檔，是因為下達 e 參數後，JAR 裡面的 META-INF 資料夾有 MANIFEST.MF 檔案出現這項設定值：

Main-Class: application.Main

你也可以自己寫好 MANIFEST.MF，再打包到 JAR 裡面，尤其需要追加更多參數給時只能這麼做。

做法是使用 m 參數，以及你自己寫好的 MANIFEST.MF 檔案：

jar cfm Application.jar MANIFEST.MF Main.class

寫 MANIFEST.MF 時，注意最後要新增一個空行，否則會有檔案結尾辨識錯誤，而找不到參數的問題。