1. Software Development for Large
and Open Source Projects
Kun-Ta Chuang
Department of Computer Science and Information Engineering
National Cheng Kung University

2. Remind
• We introduce JAVA in this week
– But you are not compelled to use it!

3. Introduction to Java Language
Kun-Ta Chuang
Department of Computer Science and Information Engineering
National Cheng Kung University
3

4. Java 語言介紹
• Java 何時開始發展？(When)
– 1991年四月份，Sun的綠色計畫(Green Project)
– 開始著手於發展消費性電子產品時(Consumer
Electronics)，所使用的語言是C、C++
– James Gosling領導發展Oak (為Java語言的前身)
• 誰開發了Java？(Who)
– 美國昇陽電腦公司Java 發展小組
– 早期的成員(綠色計畫)是Patrick Naughton, James
Gosling 和 Mike Sheridan，而現在大家較為熟悉的成員
是James Gosling (join google at 2011, and now at startup)
– 後來Sun被Oracle併購，Java也隨之成為Oracle的產品。
4

5. Java 語言介紹
• 1993年，WWW（World Wide Web）開始出現於
Internet的舞台，並掀起世界性的資訊革命。
• Java這樣跨平台的程式語言，十分適合應用在
Internet上。
• 於是，Java研發小組寫了一個網頁瀏覽器
（browser）─HotJava，它是第一個可以支援Java
Applet 的瀏覽器。您可以將 Java Applet 嵌入HTML
文件中，如此一來，您的網頁便可以互動式的方
式而且十足的聲光效果呈現在使用者面前。
• Java在WWW上展現強大的威力，讓Java一夕之間
成為電腦界的寵兒。
5

6. Java語言簡介
• Why Java?
– 跨平台
• 安全性&強固性
• 強大的延伸套件
• Open Source!
• 開放性架構
– Java Specification
Request (JSR)
6

7. Java語言簡介
• 直譯式（Interpreted）的
程式語言。
• Java原始程式Java的編
譯器Interpreter結果
• 因為Java的位元碼提供了
一個與機器架構都無關
的檔案格式，所以可以
在各種平台上執行
• Java虛擬機器
– 手機
7

8. Java語言簡介
• Java執行的五個步驟
– 編輯原始碼 Edit
– 編譯 Compile
• 從原生碼產生java bytecode
– 載入bytecode Load
• Class loader 將 bytecode 載入memory
– 認證 Verify
• Verifier ensures bytecode does not violate security requirements
– 執行 Execute
• Interpreter translates bytecode into machine language
8

9. Java語言簡介
• 名詞區分
• JDK
– Java Development Kit
– 如果要自己寫Java程式並complied成Java Bytecode，就
需要用JDK
• JRE
– Java Runtime Environment
– 如果只是要執行Java程式而不自己寫，則只需要JRE
– JDK就包含了JRE
9

10. Java語言簡介
• Java 程式語言
– High-level 的物件導向程式語言，語法相當類似C++語言，
但排除了C++ 的複雜語法，且儘量追求bug-free!
– 用來寫Java 應用程式（包含Applet、Servlet 及JavaBeans
元件）的程式語言，當Java 程式被編譯時，它會被轉成
為位元碼（byte code）的型態。
– 位元碼是Java VM 的機器語言，JVM 可以直接以硬體方
式（ Java chip）來執行，但通常都還是以軟體型態出現，
而位元碼便由JVM 來直譯且執行。
10

11. Java 語言介紹
• Java 2
– 最新版本 JDK 1.7
– Download :
http://www.oracle.com/technetwork/java/javase/
downloads/jdk7u7-downloads-1836413.html
11

12. Java開發環境
• 文字開發模式
– 下載JDK -> 設定環境變數
• javac : compiler 語法: javac 檔名.java
• Java : interpreter 語法: java 檔名
• IDE開發模式
– Eclipse( Free, Open Source, Open Plugin API)
– NetBeans( Free, Open Source)
– Jbuilder (commercial version)
12

13. Java開發環境
• Eclipse
– IBM 贊助的Open
Source計畫
– 功能強大的開發環境
– plug in模組開發功能
使它的延伸性更強
13

14. Eclipse畫面
14

15. Java基本知識介紹
15

16. Java基本知識介紹
• 大小寫有差 (Case Sensitive)
– A和a是不同的, String和string不同
• Strongly Typed
– 所有的變數均須有其定義的type
• 如VB, php就可以不用定義
• 除了基本型別的資料之外,其它均為物件!
– 基本型別資料型態是不用new的
16

17. Java基本知識介紹
• 每一個Java的程式都至少是一個使用者定義
的類別(class)
• 檔名一定為 類別.java 格式，
• 應用程式必須有一個main函式，程式是由
此開始執行
– public static void main(String[] args)
• System.out可以印出訊息
– System.out.print, System.out.println
17

18. Java基本知識介紹
• Java Package
– 可依不同的分類(e.g., 功能, 品牌),將相關的classes group
在一起
– 可達到軟體重複使用(reuse)
– 可提供一個unique的class names
• e.g., com.nissan.car vs. com.toyota.car
– 一般來說，命名順序和internet domain name剛好相反
，是由大小排列
• E.g., tw.edu.ntu.ee.arbor.javacourse
18

19. Java基本知識介紹
• Java有豐富的標準函式庫
– 資料結構
– 網路
– 圖形介面和繪圖
– 資料庫存取
– XML剖析
– …
19

20. Java基本知識介紹
Package Description
java.applet The Java Applet Package contains the Applet class and several interfaces
that enable applet/browser interaction and the playing of audio clips. In
Java 2, class javax.swing.JApplet is used to define an applet that uses the
Swing GUI components.
java.awt The Java Abstract W indow Toolkit Package contains the classes and
interfaces required to create and manipulate GUIs in Java 1.0 and 1.1. In
Java 2, the Swing GUI components of the javax.swing packages are often
used instead.
java.awt.event The Java Abstract W indow Toolkit Event Package contains classes and
interfaces that enable event handling for GUI components in both the
java.awt and javax.swing packages.
java.io The Java Input/ Output Package contains classes that enable programs to
input and output data (see Chapter 17, Files and Streams).
java.lang The Java Language Package contains classes and interfaces (discussed
throughout this text) that are required by many Java programs. This
package is imported by the compiler into all programs.
java.net The Java Netw orking Package contains classes that enable programs to
communicate via networks (see Chapter 18, Networking).
java.text The Java Tex t Package contains classes and interfaces that enable a Java
program to manipulate numbers, dates, characters and strings. The
package provides many of Java’s internationalization capabilities that
enable a program to be customized to a specific locale (e.g., an applet may
display strings in different languages, based on the user’s country).
java.util The Java Utilities Package contains utility classes and interfaces, such as
date and time manipulations, random-number processing capabilities with
class Random, storing and processing large amounts of data and breaking
strings into smaller pieces called tokens with class StringTokenizer (see
Chapter 20; Data Structures, Chapter 21, Java Utilities Package and Bit
Manipulation; and Chapter 22, Collections).
javax.swing The Java Sw ing GUI Com ponents Package contains classes and interfaces
for Java’s Swing GUI components that provide support for portable GUIs.
javax.swing.event The Java Sw ing Event Package contains classes and interfaces that enable
event handling for GUI components in package javax.swing.
Fig. 6.6 Java API packages (a subset).
20

21. Java基本知識介紹
• 和C/C++ 有很大不同，Java不允許入下的寫法：
if (a) { 如此才對 if ( a != null ) {
while( i ) { … while ( i != 0 ) { …
} }
} }
不允許其他型態的變數值轉換成boolean型態來使用，
這在C++/C是很常用的方法
21

22. Java基本知識介紹 (String)
• 在Java中，String不是基本型別，而是一個物件型
態
“Hello, world”
“ ‘Hello’ is a String”
• String中可存在跳脫字元
– t n
22

23. Java基本知識介紹 (reference)
• Java 另外定義了 類別 與 陣列兩種參考型態（reference
type），可以依照自己的需求來製作類別與陣列資料型態。
• Java 的程式是由類別與所其定義的類別所組成的。每個類
別均會定義新的資料型態來給 Java 程式運算。
• 陣列型態則是由許多某種的資料型態數值所組成的串列。
23

24. Java基本知識介紹 (reference)
• 『參考』：是指該物件或陣列被儲存在記憶體中的位址。
『Java 的參考並不像指標（pointer）：參考並不能轉換成
整數，亦不能拿來作遞加或遞減的操作』。
• 基本資料型態都具標準且定義精確的大小，在記憶體中有
固定大小的位置來儲存（1 – 8 bytes）。
• 陣列與類別是複合型的參考型態（reference type），並沒
有固定的大小。
• 不同於基本資料行態的操作方式--直接把值取出來操作。
24

25. Java基本知識介紹 (reference)
• 因此 Java 並不會直接操作物件（實作的類別）與
陣列，而是以參考（reference）的方式來操作。
• Java 的物件是根據參考的方式來處理，不同於
C/C++中是根據數值方式來處理，所以沒有 & 運算
子，也就沒有指標 *。
25

26. Java基本知識介紹 (重要概念喔)
• 基本資料型態與參考資料型態的不同：
– 變數的指定
– 傳遞的方法
– 複製的方式
• 使用運算子 “==” 來比較是否相等的方式 也是不同的。
– 基本資料型態 使用 “==” 時，會比較真正的數值是否相等。
– 物件與陣列使用 “==” 時 ，會比較是否是同一個物件或陣列
的參考，並不是比較其內容。
26

27. Java基本知識介紹 (重要概念喔)
• 要比較物件與陣列的內容，我們必須使用 equals() 的方式。
– 所有的物件與陣列都會繼承 Object.equals() 這方法，因
為所有的參考型態的物件都根源於Object類別。
27

28. Java基本知識介紹 (重要概念喔)
• 所有的陣列型態都不相同，因此不同陣列型態之間一定不
能轉換（縱使，陣列內元素的基本資料型態是可以轉換
的）。
– 例如： byte [] 不能與 int [] 做轉換
• 陣列在型態上不具有階級性，但所有的陣列都可以與
Object 作轉換（放大）
– 因為所有的陣列都源於Object。
Object o = new int [] { 1, 2, 3 }; // 放大
int [] a =(int []) o; // 縮小
28

29. 變數的宣告與有效範圍（Scope）
– Member variable
– Local variable
– method parameter
– exception-handler parameter
29

30. throw 丟出例外（Exception）
catch 攫取信號以及狀況的處理
• Java 程式語言中的例外，是一個信號：用來指示出某
種意外狀況的發生以及其對應的錯誤訊息。
• 一旦你在程式裡加進了throw 敘述，則直譯器一執行到
它時，會馬上停止正常的程式執行，然後去尋找對應
的例外處理器（Exception Handler），沒找到的話，直
譯器會列出錯誤訊息。
• throw 的查核很嚴謹，用了一次就一定要有對應的
handler。寫程式時很容易就疏忽，造成很多的error。
• 個人建議：要做就要做到最好！不要做就不會出錯 :p
30

31. try [catch][finally] 敘述
例外的處理
try {
// try 會建立一個程式區塊來處理例外
}
/* 可以有多個處理不同例外型態的catch */
catch ( SomeException err1) {
// 此敘述型態為SomeException的物件
}
catch ( AnotherException err2) { …
}
finally {
// 一定會在離開try子句之後執行，除非你在 try裡頭寫了
System.exit();
}
31

32. Exception 例外的處理很繁複，
使用時要很留意對應的 handler
免得出現一大堆不易看懂的
error messages
基本上程式要寫得好
要懂得活用Exception才行!
32

33. 物件導向
(Object-Oriented)
• 物件導向語言最基本的一個概念:
把資料與處理資料的函式合併成一個單元，每個單元都叫
做一個物件（Object）。
• 使用者無法未經允許直接碰觸到資料本身，從這角度來說，
資料是隱藏（Data Hiding）起來的，所以可以避免意外毀
壞的危險，
• 而資料與函式則是則被封裝（encapsulated）在一個單元中。
資料封裝與隱藏是物件導向程式語言極重要的觀念。
33

34. Object-Oriented Languages
的資料存取方式
34

35. Data Access by Object-Oriented
Languages
35

36. Java 物件導向程式設計
• Java 物件
– 定義一個類別與物件
– 類別、方法、欄位
– 子類別 與 繼承
– 重載 Overload method
– 覆蓋 Override method
– “super” and “this”
– “Casting” 型態轉換 (BMW  Cast成Car)
36

37. Java 物件導向程式設計
• 包裹(encapsulation) 與 可視性(visibility)
• 抽象(abstract)方法與類別、介面(interface)
• 內部類別 (inner class)
• Universal Superclass – Object
– 在java中，所有物件均繼承自Object
• Members of the class
• Copying Objects
• Casting Objects
37

38. Java 物件導向程式設計 - 導論
• 類別也是一種資料型態，該資料型態的實體
（值），我們稱做物件（object/instance）
• 類別裡面定義了成員(members) 和方法(methods)
( 成員也可稱做欄位(attribute) )
• 實作一個類別時要指定 members 的值，之後就可
使用類別裡的 methods
38

39. Java 類別(Class)
• 類別是 Java 執行的最基本單位。
• 類別是一個由 Java 程式碼所形成的模組，定義了資料結構
與一群運作該資料的方法。
• 類別包含：
類別成員，與類別本身有關連性
實體成員，與物件有關連性
– 類別（靜態）成員
– 類別（靜態）方法
– 實體成員
– 實體方法
39

40. Java 物件(Object)
• 建立一個物件：以關鍵字new 來建立物件。
Point p = new Point( 2.0, -3.5 );
Date d = new Date();
• 使用物件：每一個物件都有屬於自己的成員與方
法的複本（copy），可以使用點字元（.）來讀取
物件中的成員與方法。
Point p = new Point(2, 3);
double x = p.x;
p.y = p.x * p.x;
double d = p. distanceToOrigin() ;
40

41. Java 物件的建立與初始化
• 建構子（Constructor）
• 重載建構子
• this 關鍵字的使用
• 成員與方法的初始值設定
• 靜態初始函式
• 實體初始函式
41

42. 物件導向設計概念(I)
• 繼承
– 軟體重複使用
– 從現有類別建立新類別
• 吸收現有類別的資料和行為
• 強化新的功能
– 子類別(Subclass)延伸父類別(Superclass)
• 行為繼承自父類別, 但可以變更
• 更專門的類別
• 額外的行為
42

43. 物件導向設計概念(II)
• 類別階層(Class hierarchy)
– Direct superclass
• Inherited explicitly (one level up hierarchy)
– Indirect superclass
• Inherited two or more levels up hierarchy
– Single inheritance
• Inherits from one superclass
– Multiple inheritance
• Inherits from multiple superclasses
43

44. 物件導向設計概念(III)
• 抽象化
– 物件的共通性
• “is-a” vs. “has-a”
– “is-a”
• 繼承
• 把子類別物件當作父類別的物件
• Example: Car is a Vehicle
– Car has Vehicle properties/behaviors
– “has-a”
• 組成
• 物件包含其他類別的物件當作成員
• Example: Car has a steering Wheel
44

45. 父類別與子類別
• Superclasses and subclasses
– 一個類別的物件是(“is a”)另一類別的物件
• Example: Rectangle is quadrilateral.
– Class Rectangle inherits from class Quadrilateral
– Quadrilateral: superclass
– Rectangle: subclass
– 父類別典型代表較大集合的類別
• Example:
– superclass: Vehicle
» Cars, trucks, boats, bicycles, …
– subclass: Car
» Smaller, more-specific subset of vehicles
45

46. 繼承範例
Shape
TwoDimensionalShape ThreeDimensionalShape
Circle Square Triangle Sphere Cube Tetrahedron
46

47. Java 子類別與繼承(Inheritance)
• Java 只允許單一繼承，但提供以介面（interface）的方式，
來替代C++中的多重繼承。
• 遮蔽（shadowed）超類別的成員
當一系列繼承的物件有相同名稱的成員時，下層的成員會
永遠遮蔽上層的成員。
• 改寫或覆蓋（overrided）超類別的方法
若不想被改寫，只要宣告它為 final 即可。
final 也可以用在類別上，如此它將不會再有子類別。
• 對於類別靜態欄位與方法，只能被遮蔽，不能被改寫。
47

48. 超（父）類別及類別階層
 利用 超類別建構子 super() 這種用法 來作繼承物件的初始化，有
一些規則：
– super() 必須出現在子類別的建構子中
– 必須出現在第一行敘述裡，也必須出現在變數宣告之前
每個被啟用的建構子會有三個程序：
• 如果建構子的第一行敘述是一個普通的敘述，不是this()或super()，
則Java 會自動加入一個 super();
來啟動父類別的預設建構子，由它所傳回的初始化實體來進行子
類別接下來的敘述。
• 如果建構子的第一行敘述即呼叫了super()，則Java 會啟用這個選
定好的父類別建構子，由其所傳回的已初始化實體來進行接下來
的敘述。
• 若建構子第一行敘述是呼叫 this()，則 Java 會啟用特定的重載建構
子（並暗中呼叫父類別建構子），然後回來進行接下的敘述。
48

49. 遮蔽（shadowed）超類別的欄位
• 對於實體的成員與方法：
– 當一系列繼承的物件有相同名稱的方法時，下層的方
法會永遠改寫上層的方法。
– 若不想被改寫，只要宣告它為 final 即可。
– 成員(member)只會被遮蔽。
– 若一個父類別的欄位或方法是 static 時，在子類別中，
也只能以 static 的欄位方法來遮蔽。
• 對於類別靜態成員與方法：
– 只能被遮蔽，不能被改寫。
49

50. 改寫方法與動態連結
• 重載的方法（overload）會在編譯時就決定。
• 改寫的方法（overwrite）會在執行的時會才動態確定。
• 若我們同時擁有 Circle 與 PlaneCircle物件，各自定義了
area()這方法，當直譯器在執行的時候，會做動態查詢的
動作，以決定使用哪以方法。
• 這方式，基本上與 C++ 中的虛擬函數做的事情是一樣的。
50

51. 介面(Interface)
• 介面：是一種 參考型態（會與實作這介面的類別有親密關
係）。
• 定義一個介面（= 等待實作的API）：
– 介面內所有的方法都是abstract（即使沒加上 abstract
修飾元。）
– 介面只能包含 抽象（實體）方法與 static final 欄位。
– 介面是 public 的，其內的抽象方法也一定都要是 public ，
就算沒明寫也都內定是 public。
– 介面不包含建構子，所以不能被實體化。
51

52. 實作一個介面
• 實作一個介面
– implements
– 若實作兩個以上的介面 以“ , ” 逗號區隔
– 一個類別若要 implements 某個介面，就一定要
把所有的抽象方法都作出來。
52

53. 實作一個介面example, important!
public class CenteredRectangle extends Rectangle implements Centered {
private double cx, cy;
public CenteredRectangle( double cx, double cy, double w, double h ) {
super( w, h );
this.cx = cx;
this.cy = cy;
}
// implements all abstract methods in interface Centered
public void setCenter( double x, double y ) { cx = x; cy = y; }
public double getCenterX() { return cx; }
public double getCenterY() { return cy; }
}
53

54. 介面的延伸(子介面)
• 子介面（subinterface）：一個介面可以繼承父介面
（superinterface）中所有的抽象方法與常數，並且可以定
義新的抽象方法與常數。
• 不同於類別的繼承，一個介面可以同時繼承多個的介面。
public interface Positionable extends Centered {
public void setUpperRightCorner( double x, double y );
public double getUpperRightX();
public double getUpperRightY();
}
public interface Transformable extends Scalable, Translatable, Rotatable { … }
public interface SuperShape implements Positionable, Transformable { … }
54

55. 介面與抽象類別的階層
public class CenteredRectangle extends Rectangle implements Centered {…}
Class Hierarchy Interface Hierarchy
Shape
Rectangle
CenteredRectangle Centered
55

56. 抽象類別？介面？
• 對一介面，所有的類別都可以實作它，即使該類別延伸的
某個完全不相干的父類別。
• 介面只是一個 API，使用需要實作它，每 implements一次，
就得完全地、重複地實作所有的抽象方法。
• 這情況會在，多重介面的情況下更加繁複。
• 類別的繼承特性可讓子類別免於繁複的實作動作。
• 但是，類別的繼承上規定了單一繼承的限制，這有時會功
能設計上的困擾。
• 還好，抽象類別內可以有非抽象的方法，這提供了部分的
彈性：爾後可以調整抽象類別內所提供的方法。
56

57. 抽象類別？介面？
相容性！
• 當一個介面被定義完後，會成為公用的 API，爾後若在該
介面中又加進一個新的方法，則先前使用該介面的來實作
的類別將會出現相容性的問題。
• 抽象類別允許爾後可以加入非抽象的方法於該類別中，且
無須對之前繼承該抽象類別的類別進行任何的修改。
57

58. 套件或包裹(Package)
• 套件（a group of classes）很類似函式庫（library ），組織管理一群類
別。
• 編譯單位：
– Java 類別中的程式碼就是一個編譯單位（compilation unit）。
– 要把一個定義好的編譯單位歸類於某個套件，作法是在其程式碼
的第一行敘述寫進：
package mydefine.tools;
package mydefine.*;
– 一個編譯單位只能歸類在一個套件。
– package必須依照相對應的目錄而存在(有路徑概念)
58

59. 封裝(encapsulation) - 資料隱藏
• 封裝（encapsulation）：把類別中的資料作適度的隱藏，
只讓可以信賴的使用者使用（類別中的方法）。
• 當類別中的所有欄位都隱藏起來的時候，類別中的方法就
可以定義這個類別的物件可能執行的運算。
• 這樣就不會讓你所設計的API，在使用上很錯亂，無法規
範。
• 如此，我們可以來規範存取的權限：
– 套件存取權、類別存取權、成員存取權、繼承後的存
取權控制
59

60. 封裝與可視性(Visibility)
• 在同一套件中，所有的編譯單位（類別）都是彼此可看見
對方的、友好的（friendly）類似 C++中 的 friend。
• 基本上，類別對屬於不同套件的類別沒有存取權。
• 若要使用到屬於不同套件的類別中的欄位與方法，則類別
裡面必須先要：（import 類別的參照）
import mydefine.tools.TextEditor ;
import mydefine.tools.* ;
• 有時 在 import 之後，會有類別同名的情況，使用時要指
明
package_name.class_name.method_name
60

61. 可視性 - 存取控制權
• Java 提供類別中的欄位與方法四種基本的存取控制權：
– 沒明定 (default) ：內定的存取權限，可以被同一個套件
中的類別看見、使用。
– public：可被任何套件中的類別使用，
– private：只能在定義它的該類別中使用，就算是繼承它
的子類別也看不見。
– protected：可以被同一個套件中的類別看見、使用，
也可以被其子類別看見，包括放在不同套件中的子類
別。
61

62. 可視性 - 存取控制權
存取類別 成員可見等級
public protected (default) private
相同類別內 o o o o
相同套件內 o o o x
不同套件中 o o x x
的子類別
不同套件中 o x x x
非子類別
62

63. 內部類別（Inner Class） - 概論
• Java 1.1之後，除了先前所探討的一般類別與介面之外，額
外定義了四種型態的內部類別（inner class）
– 靜態成員類別或介面（static member class）
– 成員類別
– 區域類別
– 匿名類別
63

64. 靜態成員類別
• 為了使用上的方便，一個靜態的類別（或介面）
可以被定義在另一個類別中，為一靜態成員（類
別或介面），與外部類別的靜態方法與欄位的位
階相似。
• 內部的介面僅可以被定義為靜態成員。
• 一個類別裡可以有多個靜態的成員類別或介面。
• 因為是靜態不與任何實體有關連，所以沒有 this
物件。
64

65. 靜態成員類別
• 只可以使用同一（外部）類別中的靜態方法與欄
位（包含同一外部類別中的靜態類別與介面），
不能使用與實體有關連的成員。
• 可以存取同一個外部類別中的 private 成員。
65

66. 靜態成員類別
• 靜態成員類別的名稱不能與定義它的外部類別同
名！
• 靜態成員類別或介面只可以被 “一般” 的類別、
與其它的靜態成員類別或介面所定義。換句話說，
不能被其他三種：（實體）成員、區域類別、匿
名類別中被定義。
• 靜態成員類別的語法：
import LinkedStack.*;
• See example
66

67. public class LinkedStack {
public static interface Linkable { // 內部成員類別：靜態成員介面
public Linkable getNext(); // 注意！這樣的作法，其它的套件看不到
public void setNext( Linkable node );
}
Linkable head;
public void push( Linkable node ) { … } // 實體方法，
public Object pop() { … } // 靜態的成員類別或介面無法使用到
}
// 此類別實作了靜態成員介面
class LinkableInteger implements LinkedStack.Linkable {
int I;
public LinkableInteger( int I ) { this.I = I; }
LinkedStack.Linkable next;
public LinkedStack.Linkable getNext() { return next; } // 實作的方法
public void setNext( LinkedStack.Linkable node ) { next = node; }
}
67

68. （實體）成員類別
• 對（外部）類別中的其他欄位與方法的存取方式，相似於
先前所提及的實體方法或欄位。所以可以存取定義的類別
中所有的欄位與方法。
• 成員介面不能夠以方式定義。
• 成員類別不能含有任何 static 欄位、方法或類別（但，允
許同時使用以 static final 宣告的常數欄位。）
• 注意，介面不能被定義為成員類別。因為：介面不能被實
體化！因此跟所處的類別實體沒有關連。
• 成員類別的名稱不能與定義它的外部類別同名！
68

69. public class LinkedStack {
public static interface Linkable { … 內容主體 省略 … // 靜態成員介面 }
private Linkable head;
public void push( Linkable node ) { … } // 實體方法，
public Object pop() { … } // 靜態的成員類別或介面無法使用到
}
//實體方法，傳回值為一java.util.Enumeration 物件
public java.util.Enumeration enumerate() { return new Enumerator(); }
// 定義一個成員類別，並實作 Enumeration 介面
protected class Enumerator implements java.util.Enumeration {
Linkable current;
public Enumerator() {current = head;} // 建構子，可使用 private 欄位
public boolean hasMoreElements() { return ( current != null ); }
public Object nextElement() {
if ( current == null ) throw new java.util.NoSuchElementException();
Object value = current;
current = current.getNext();
return value;
}
}
69

70. 成員類別
• 上述的範例中，
public Enumerator() { current = head; }
// 使用到了 private 欄位
public Enumerator() { this.current = this.head; }
// compiled error!
因為 this.head的 this 會被認為是 成員類別
 public Enumerator() { this.current =
LinkedStack.this.head; }
70

71. 成員類別
• 成員類別的可視度為 protected，表示 在其他套件中
有使用到 LinkedStack 類別的程式區塊，將看不到、無
法存取這成員類別，但是若是繼承 LinkedStack 的子類
別將可以存取它。
• 回想！欄位與方法的遮蔽。可以使用關鍵字 super 來
access被遮蔽的成員。（Java 1.2 新增的功能）
• 建議：儘可能的避免在成員類別中宣告與所處類別相
同名稱的欄位與方法，以避免爾後要使用 this 與
super ，也可降低寫程式的複雜程度。
71

72. 區域類別
• 區域類別（local class）是定義在 Java 程式區塊中的一個
內部類別。
• 區域類別只在該程式區塊中是可見的。
• 區域類別不是成員類別。
• 因為不是類別的成員，所以區域類別不能被宣告為 public、
protected、private 或 static。
• 區域類別與實體相關連，所以可以存取該（外部）類別所
定義的所有成員，也當然包括 private成員。
• 區域類別的名稱不能與跟它所處的類別同名！
• 介面不能被定義為區域類別。
72

73. 區域類別
• 區域類別不能含有任何 static 欄位、方法或類別（但，允
許同時使用以 static final 宣告的常數。）
• 區域類別可以自行定義欄位與方法（只在該區域類別中有
效）。
• 區域類別只能使用在定義它的程式區塊中被宣告為 final
的區域變數、方法參數與例外參數。
因為：區域類別的實體生命可能比定義它的方法的執行時
間還長，為此，區域類別所使用的區域變數必須要是被宣
告為 final，以確保此區域變數永遠一致。
73

74. // 和 前一個 example 比較，
// 以區域類別的方式，來建立並傳回一個java.util.Enumeration 物件
public java.util.Enumeration enumerate() {
// 定義一個區域類別，並實作 Enumeration 介面
class Enumerator implements java.util.Enumeration {
Linkable current;
public Enumerator() { current = head; }
public boolean hasMoreElements() { return ( current != null ); }
public Object nextElement() {
if ( current == null ) throw new java.util.NoSuckElementException();
Object value = current;
current = current.getNext();
return value;
}
}
// 傳回一個Enumerator 類別的實體
return new Enumerator();
}
74

75. 區域類別的有效領域 及 範圍
class A { protected char a = ‘a’; }
class B { protected char b = ‘b’; }
public class C extends A {
private char c = ‘c’;
public static char d= ‘d’;
public void createLocalObject( final char e ) {
final char f = ‘f’;
int I = 0;
class Local extends B {
char g = ‘g’;
public void printVars() {
// (this.) g, f, e, (C.this.) c, (C.this.) d, b, a 都可以被區域類別使用
// 只有 變數 I 不能被區域類別使用
System.out.println( … );
}
}
Local L = new Local(); // 建立一個區域類別
L.printVars(); // 並呼叫它的printVars()方法
}
// 這裡已經脫離了區域類別的範圍，因此 我們不能再使用它了
}
75

76. 區域類別 與 區域變數 的領域
public class Weird {
public static interface IntHolder { // 靜態成員介面
public int getValue();
}
public static void main( String [] args ) {
IntHolder [] holders = new IntHolder[10];
for ( int I = 0; I < 10; I++ ) {
final int fi = I;
class MyIntHolder implements IntHolder { // 定義 區域類別
public int getValue() { return fi; }
}
holders[I] = new MyIntHolder(); // 區域類別在此時實體化
}
// 這裡已經脫離了區域類別的範圍，因此 我們不能再使用它了
// 但holders[] 已將 fi 的值都存起來了
for ( int I = 0; I < 10; I++ ) System.out.println( holders[I].getValue() );
}
}
76

77. 匿名類別
• 匿名（anonymous）類別是一種沒有名稱的類別，它結合了
將類別定義的語法和物件實體化的語法，換句話說，就是將
類別的定義與物件實體化的語法寫在一起。
• 匿名類別出現的型態，就很像是一般 Java 的表示式（一段很
長的表示式）。且可以包含在另一個表示式中。
• 以 new 運算子來定義並且實體化之。
• 相較於 區域類別：其形式是 Java 的程式區塊中的一段敘述。
• 主要用來：定義且使用一個只會在這裡並只被使用一次的類
別（one-shot class）。
77

78. 使用 匿名類別來定義並實作 Enumeration
public java.util.Enumeration enumerate() {
// 將 匿名類別 定義為 return 表示式中（敘述）的一部份。
return new java.util.Enumeration { // 以new 來實體化
Linkable current;
{ current = head; }
//注意！ 原本的建構子要換置成一個實體的初始函式
public boolean hasMoreElements() { return ( current != null ); }
public Object nextElement() {
if ( current == null ) throw new
java.util.NoSuckElementException();
Object value = current;
current = current.getNext();
return value;
}
} ; // 注意！ 要加上分號 作為 return 表示式的結束。
}
78

79. 匿名類別
• 因為匿名類別沒有名稱，因此也就不可能在類別主體中定
義建構子。以實體初始函式來代替建構子。
• 匿名類別一般都是用來延伸較簡單且不需要任何建構子引
數的類別。因此匿名類別定義語法中的小括號裡通常是空
的。
• 匿名類別與區域類別的限制是相同的。
• 因為不是類別的成員，所以匿名類別不能被宣告為 public、
protected、private 或 static。
79

80. 匿名類別
• 只允許同時使用以 static final宣告的常數。（不能
含有任何static 欄位、方法或類別）
• 介面不能被定義成這種型態。
80

81. 何時必須使用匿名類別
• 匿名類別的行為和區域類別一樣。選擇使用匿名
類別的時機：
– 類別主體很短。
– 只需要一個類別的實體，他處不需要。
– 類別在定義後馬上就要使用。
– 類別的名稱是程式易於瞭解的。
81

82. 附註
• 靜態成員類別有時亦被稱為『巢狀最上層類別
（nested top-level classes）』。
• 『巢狀類別』有時已被用來表示內部類別。
82

83. The Universal Superclass
• 所有類別的源頭都來自 class Object。
• 所有我們定義的類別對 Java 而言都來自於一個標準的基底
類別 Object。當我們自行定義一個類別時，實際上已經
（自動）繼承了基底類別。
• 如此，所有的類別物件，都可以（放大）轉型為 Object 物
件。
• 也因為有共同的基底，物件可以被當做一個參數來傳遞。
（只要接收端 知道該還原轉型為何即可）
• 一個型態是 Objects 的參數可以接收任何class 的物件.
83

84. Members in class Object
• 既然所有的類別都來自於基底類別，因此也都繼
承基底類別內所定義的成員。
• 也就是說，每個內別都可以用到這幾個共同的方
法。
84

85. Members in class Object
public 這方法的回傳值是一String物件，且這方法是可以被
toString() override的，藉由 “＋” 來連結、改寫字串。因此，
回傳的內容可自行設定。
此方法的目的是在基底類別中宣告 toString() 已自動
提供編譯器一個字串標籤來識別物件。
public 比較兩個物件是否相等（equivqlent），注意！這裡
equals() 不是 “==” 這裡的equivqlent是比較兩個是否為各
自獨立但型態、內容相同的物件。
public final 這方法會回傳 一個 型態為Class 的類別，用來識別目
getClass() 前的物件。
85

86. Members in class Object
public 這方法會對目前的物件計算出一個整數型態的hash
hashCode() code數值，並回傳之。
其目的是被用來當作索引值來儲存於套件（package）
中的hash table，以利爾後的編譯。
public final 這方法可用來喚醒那與物件結合的執行緒。
notify()
public final 這方法可用來喚醒所有與物件結合的執行緒。
notifyAll()
public final 這方法可使一個執行緒進入等候狀態，讓物件中其他
wait() 相關的動作先執行。
86

87. Members in class Object
protected （任何物件型態）物件實體的複製，非參照的複製。
clone() 注意！ 有實作 Cloneable 介面的類別，其物件才能被
複製。
protected 當一個物件被destroyed時，這方法會被呼叫來清除之。
finalize()
在我們自行延伸定義的類別中，getClass(), notify(), notifyAll(),
wait() 不能被覆蓋來改寫。
87

88. Members of the class Class
• 當程式執行的時候，JVM 會自動建立並載入 每一個類別或
介面的 instances of the class Class。
• 因為是由JVM自動產生，所以這類別中沒有public 的建構
子，所以 我們無法自行建立型態為 Class 的物件。
• Class 中定義有很多的方法，使得我們能夠曉得一個類別
的詳盡內容。其中最重要的：
88

89. Members of class Class
在 class Object 中提供了 getClass() 這方法來獲得一個物件的類別。
而藉由使用 class Class 中的方法，將可以瞭解到一個類別的物件到
底包含了哪些東西。
forName() 這方法可以用來獲得、或測試某物件的類別名稱。
將某物件的名稱以字串的方式傳入，這方法會把這
物件的類別型態的名稱回傳。
newInstance() 這方法會呼叫 class Class 的內定建構子，並回傳
一個型態為 Object 的物件。使用時要強制轉型回
instance 的類別型態。
注意！這方法必須要同時配合使用 Exception
handler，否則編譯時會出錯。
89

90. Members of class Class
getSuperClass() 呼叫這方法會為傳一個父類別型態的類別。
例如： Animal  Dog
System.out.println(dog.getClass().getsuperClass
().getName() );
if your class is not a derived class, this method
will return a Class object for the class Object .
isInterface() return true, 若目前的物件是一個介面的型態。
getInterface() return 一個陣列：內容是這類別物件所有實作的介面。
toString 回傳一字串，用來表示這物件。
90

91. Casting Objects
• 當兩物件之間有繼承關係時，可將一物件放大轉型成
為上層型態的物件（upwards through its direct and
indirect superclass）。
• 當一物件放大轉換成為某一繼承型態的物件時，Java
會依然保留住原有型態的物件資料。
因此，爾後這物件能夠在縮小轉回原來的型態。
此為之前所介紹的：polymorphism！
91

92. A Casting Objects Scenario
class Object
is derived from
class Animal
is derived from is derived from is derived from
class Cat class Dog class Duck
is derived from
class Spaniel
92

93. When to Cast Objects
• 在同一個類別繼承關係中，可以將某一物件放大轉型後，
又縮小轉回來。
• 需要轉型的理由：要使用到某個只存在特定類別中的欄位
或方法。
• 大部分的情況應該要避免使用 casting
– 因為容易造成可能的轉換錯誤和程式的不嚴謹
– 若是 class 設計良好將會減少 casting 的次數
93

94. 了解 Stream(串流)
Stream
Stream
program Data
Data
Input
Stream Stream
Output
Stream Monitor
Stream
Keyboard
Stream printer
94

95. Stream I/O
• Stream 的概念
 Stream 一個輸出入裝置的抽象表示。
• 表達了「資料來源」或「資料目的地」的概念。
• 這些資料以位元組（bytes）為單位，並且以一定的順序依
序傳遞。
• 不論是要從檔案、鍵盤、網路、甚至記憶體中，讀取或寫
入一串循序的資料，都可以 Stream 的方式來達成。
95

96. Stream I/O
• 根據要進行的操作類型，Stream 又分成兩大類：
• InputStream
– 代表「資料的來源」，可以從中讀取資料；
• OutputStream
– 代表「資料的目的地」，可以寫入資料。
注意！串流輸出、輸入的方向都是單向的，也就是說，我
們不能對 InputStream 寫入資料，也不可能從
OutputStream 中讀出資料。
96

97. java.io 套件中的基本串流處理工具
File 此類別的物件可用來表示目前欲使用的檔
案、或目錄路徑。
abstract 此基本抽象類別用來處理位元組型態的輸
OutputStream 出串流。
abstract 此基本抽象類別用來處理位元組型態的輸
InputStream 入串流。
abstract Writer 此基本抽象類別用來處理字元型態的輸出
串流。
abstract Reader 此基本抽象類別用來處理字元型態的輸入
串流。
RandomAccessFile 此類別可用來提供隨機檔案的讀取。
97

98. Java Data Structure
• 動態資料結構
– 執行的時候可以動態變大或縮小
• 自我參考類別 self-referential classes
98

99. 自我參考類別
• 包含參考到相同類別物件的實體欄位
– class Node {
private int data;
private Node nextNode; // reference to next linked node
}
• 成員 nextNode
– nextNode 連結到另一個Node object
15 10
99

100. 動態記憶體配置
• 在執行期要求更多的記憶體來儲存新的物
件
• JVM的記憶體是一個可改變大小的heap
structure
– 可以用-Xms和-Xmx來跟JVM要求起始配置的
heap大小
• java –Xmx1600mb myclass
– WindowsXP+JRE1.4.0最大可以到16xxmb左右
100

101. Package java.util *
• Some Interfaces
– Collection
– EventListener
– Iterator
– List
– Map
– Set
* reference: 台大電機鄭士康教授IA講義
101

102. Exception
• Exception是程式在執行的過程中發生不正
常的現象
• 在Java裡面exception被視作一個object
• 當exception發生時, Java 會產生一個
exception的物件並被該方法丟出(throw)
• 負責處理的函式則接住(catch)並加以處理之
102

103. try {
// block of code to monitor
// for errors
}
catch( ExceptionType1 exOb ) {
// exception handler for
// ExceptionType1
}
finally {
// code to be executed before try
// block ends
}
103

104. Exception Types
Throwable
Exception Error
RuntimeException IOException
104

105. throw
• 用來宣告可能在method裡面發生的exception types
• Error 和某些的 RuntimeExeption 不用自己宣告就
會被丟出
• 但有些exception types一定要宣告
– ClassNotFoundException
– IllegalAccessException
– NoSuchMethodException
– InterruptedException
105

106. finally
• 用來執行需要在try/catch區塊執行的時候一
定要做的事情
• 通常用來歸還資源(如關閉檔案)
106

107. Our Own Exceptions
• 我們也可以自己定義自己的 exceptions
• 必須繼承 class Throwable
• Methods in class Throwable
– String toString()
– void printStackTrace()
– void printStackTrace(PrintWriter stream)
107

108. API Example
• Java Database Connection
108

109. JDBC
• 用於執行SQL的Java API，它將資料庫存取的API
與SQL陳述分開，實現資料庫無關的API介面
• 藉由JDBC統一的介面，開發人員只要專注於SQL
陳述，而可以不必理會底層的資料庫驅動程式與
相關介面。
109

110. JDBC
• 簡單的說，JDBC讓Java程式設計人員在撰寫資料庫程式的
時候，可以「寫一個程式，適用所有的資料庫」。
110

111. JDBC
• JDBC資料庫驅動程式依實作方式分為四種:
– Type1 : JDBC-ODBC Bridge
– Type2 : Native-API Bridge
– Type3 : JDBC-Net
– Type4 : Native-Protocol
• Type3 & 4，純java撰寫，適合跨平台時採用
• MyS QL的JDBC驅動程式屬於Type4，稱為connector-j
111

112. JDBC-連接資料庫
• JDBC URL:
– jdbc:mysql://主機名稱:連接埠/資料庫名稱?參數1=值1&
參數2=值2
• 其中，mysql可以替換成你所使用的橋接驅動程式或
是資料庫管理系統名稱，這裡以MySQL為例
– 主機名稱可以是localhost或其他連線主機，port為3306，
參數可接使用者名稱與密碼(optional)
• Ex.
jdbc:mysql://localhost:3306/NCKU?user=kthuang&pa
ssword=123456
112

113. JDBC-連接資料庫
• 從DriverManager取得Connection
• Method 1:
• String url = "jdbc:mysql://localhost:3306/NCKU?" +
"user=kthuang&password=123456";
Connection conn = DriverManager.getConnection(url);
• Method 2:
– String url = "jdbc:mysql://localhost:3306/NCKU";
String user = “kthuang";
String password = "123456";
Connection conn = DriverManager.getConnection(url,
user, password);
113

114. JDBC-Statement & ResultSet
• conn = DriverManager.getConnection(
url, user, password);
stmt = conn.createStatement();
stmt.execute(“INSERT INTO message VALUES(‘coding好好玩’," + ",
‘kthuang'");
ResultSet result = stmt.executeQuery(
"SELECT * FROM message");
while(result.next()) {
System.out.print(result.getString(“subject”) + "t");
System.out.print(result.getString(“name”) + "t");
• Note:
– Connection物件預設為自動「認可」（Commit），也就是Statement執行
SQL敘述完 後，馬上對資料庫進行操作變更，如果想要對Statement要執行
的SQL進行除錯，可以使用setAutoCommit(false)來將自動認可取 消，在執
行完SQL之後，再呼叫Connection的commit()方法認可變更
114

115. Question?
115