了得網研究生_Java 8程序設計及實驗

產品特色

編輯推薦

本書由多位長期從事Java教學的教師根據其實際授課經驗編寫，從教師和學生的角度來編寫教材，並在教學環境中加以試用，不斷修改完善。本書配有習題解答、電子課件及源程序。

內容簡介

本書是講述Java程序設計的教材，在一般知識的基礎上增加了JDK 8中的新功能，包括在接口中聲明靜態方法、默認方法，還有Lambda表達式、方法引用、Stream。在圖形界面部分，去掉了介紹Applet的內容，增加了用JavaFX實現圖形界面的內容及案例。本書由多位長期從事Java教學的教師根據實際授課經驗編寫而成，通過在教學環境中的試用，具有較好的教學效果。本書適合作為普通高等學校教材使用，為了便於學習，本書配有習題解答、電子課件及源程序，在本書附錄中還有相應的授課計劃和實驗項目，為教師備課、授課和安排實驗環節的項目提供參考，為讀者的學習提供引導。

目錄
部分Java程序設計第1章Java入門3
1.1Java簡介3
1.1.1Java的由來3
1.1.2Java的特點4
1.2Java平臺5
1.2.1Java平臺的構成5
1.2.2Java平臺的版本6
1.2.3JRE和JDK7
1.2.4JDK的下載與安裝8
1.2.5環境變量的配置9
1.3Java程序的開發流程10
1.3.1Java程序的種類10
1.3.2Java程序的開發流程10目錄
部分Java程序設計第1章Java入門3
1.1Java簡介3
1.1.1Java的由來3
1.1.2Java的特點4
1.2Java平臺5
1.2.1Java平臺的構成5
1.2.2Java平臺的版本6
1.2.3JRE和JDK7
1.2.4JDK的下載與安裝8
1.2.5環境變量的配置9
1.3Java程序的開發流程10
1.3.1Java程序的種類10
1.3.2Java程序的開發流程10
1.4小試身手11
1.5Java API文檔的使用12
1.6Java Doc文檔13
1.6.1語法13
1.6.2標簽簡介14
1.6.3生成Java Doc文檔15
本章小結16
習題117第2章Java基本語法18
2.1原始類型18
2.1.1整數類型19
2.1.2實數類型21
2.1.3字符類型21
2.1.4布爾類型22
2.1.5強制類型轉換222.2引用類型23
2.3String23
2.4聲明變量23
2.4.1變量的賦值24
2.4.2變量的默認值24
2.4.3常量24
2.4.4變量作用範圍24
2.5命名25
2.6運算符與表達式26
2.6.1算術運算符26
2.6.2關繫運算符27
2.6.3邏輯運算符27
2.6.4位運算符29
2.6.5賦值運算符31
2.6.6其他運算符31
2.7數組32
2.7.1一維數組32
2.7.2多維數組33
本章小結35
習題235第3章流程控制36
3.1分支語句36
3.1.1if…else語句36
3.1.2switch語句38
3.2循環語句40
3.2.1while語句40
3.2.2do…while語句41
3.2.3for語句42
3.2.4for…each語句43
3.2.5嵌套循環44
3.2.6循環語句對比45
3.3跳轉語句45
3.3.1break語句45
3.3.2continue語句47
3.3.3return語句48
本章小結49
習題349第4章面向對像編程51
4.1面向對像編程概述51
4.2類的定義52
4.2.1類的基本結構52
4.2.2成員變量和局部變量54
4.2.3成員方法55
4.2.4Overloading62
4.2.5構造方法63
4.2.6this65
4.3對像66
4.3.1對像的創建66
4.3.2對像的使用68
4.3.3對像的清除*68
4.4static69
4.4.1類變量69
4.4.2類方法71
4.4.3靜態語句塊71
4.5包*72
4.5.1包的定義73
4.5.2編譯和運行包中的類73
4.5.3import語句75
4.6訪問權限修飾符76
4.6.1private76
4.6.2friendly77
4.6.3protected77
4.6.4public78
4.7常用類78
4.7.1Object類79
4.7.2String類與StringBuffer類80
4.7.3數值包裝類83
4.7.4Math類85
4.7.5Random類*86
4.7.6處理日期的類*87
4.7.7Arrays類89
本章小結91
習題491第5章繼承93
5.1繼承的語法93
5.2成員變量的隱藏和方法的覆蓋94
5.3super95
5.4final96
5.5多態97
5.6繼承與組合99
5.7初始化順序*102
本章小結105
習題5105第6章抽像類、接口和內部類106
6.1抽像類106
6.1.1聲明抽像類106
6.1.2繼承抽像類106
6.1.3抽像類的應用106
6.2接口109
6.2.1聲明接口109
6.2.2實現接口110
6.2.3default方法和static方法110
6.3內部類111
6.3.1什麼是內部類111
6.3.2匿名內部類112
6.4Lambda表達式114
6.4.1定義114
6.4.2常見函數式接口116
6.4.3方法引用116
本章小結117
習題6117第7章枚舉*118
本章小結120
習題7120第8章異常121
8.1異常121
8.1.1異常信息121
8.1.2異常的處理122
8.1.3異常的類型124
8.2finally124
8.3throws125
8.4自定義異常*125
8.5異常進一步的處理126
8.5.1在何處處理異常126
8.5.2同時處理父、子類異常127
8.5.3同時處理多個異常128
本章小結129
習題8129第9章輸入輸出130
9.1File130
9.1.1創建一個File對像130
9.1.2訪問File對像的方法131
9.1.3列出目錄下的文件132
9.1.4列出目錄下滿足條件的文件132
9.1.5Path135
9.2輸入流136
9.2.1字節輸入流136
9.2.2try…with…resources語句141
9.2.3字符輸入流141
9.2.4Scanner145
9.2.5從控制臺輸入147
9.3輸出流150
9.3.1字節輸出流151
9.3.2字符輸出流154
9.3.3格式化輸出156
9.4數字字節輸入輸出流157
9.4.1DataInputStream和DataOutputStream157
9.4.2RandomAccessFile*158
9.5對像輸入輸出流*160
9.6壓縮、解壓縮流*161
9.6.1壓縮162
9.6.2解壓縮163
9.7讀寫Excel文件*164
9.7.1讀取已有的工作簿164
9.7.2生成新的工作簿166
9.7.3修改已有的工作簿168
9.7.4應用168
9.8Files工具類171
本章小結172
習題9172第10章圖形用戶界面174
10.1AWT包與Swing包174
10.1.1輔助類176
10.1.2組件類176
10.1.3容器類176
10.2版面布局管理器180
10.2.1FlowLayout181
10.2.2BorderLayout182
10.2.3GridLayout184
10.2.4CardLayout*185
10.2.5無布局管理器186
10.3事件處理187
10.3.1事件處理機制187
10.3.2事件處理示例190
10.3.3事件適配器196
10.4Swing常用組件198
10.4.1標簽198
10.4.2按鈕199
10.4.3文本框203
10.4.4文本區205
10.4.5列表*205
10.4.6組合框*206
10.4.7對話框*211
10.4.8計時器*215
10.4.9菜單組件*215
10.5Swing組件應用217
10.5.1圖片瀏覽器217
10.5.2文本編輯器221
本章小結226
習題10226第11章JavaFX227
11.1JavaFX概述227
11.1.1JavaFX的發展227
11.1.2JavaFX架構圖227
11.2JavaFX程序228
11.2.1場景Scene228
11.2.2JavaFX應用程序的生命周期228
11.2.3JavaFX應用程序228
11.3Java FX布局229
11.3.1FlowPane229
11.3.2BorderPane230
11.3.3HBox232
11.3.4VBox233
11.3.5GridPane235
11.3.6StackPane236
11.4事件處理237
11.4.1事件238
11.4.2事件分發流程239
11.4.3事件處理240
11.5JavaFX UI組件247
11.5.1標簽247
11.5.2按鈕247
11.5.3文本框249
11.5.4文本區249
11.5.5菜單組件251
11.5.6文件選擇器253
11.6在UI控件上使用CSS257
11.6.1創建樣式257
11.6.2JavaFX CSS選擇器257
11.6.3美化UI控件258
11.6.4使用setStyle()方法設置樣式260
本章小結260
習題11260第12章JDBC261
12.1驅動程序下載262
12.2創建到數據庫的連接262
12.3使用Statement執行SQL語句263
12.3.1executeUpdate263
12.3.2executeQuery266
12.4使用PreparedStatement執行SQL語句267
12.4.1executeUpdate267
12.4.2executeQuery269
12.5事務*269
12.6得到ResultSet中的記錄數*272
12.6.1執行另一條SQL語句272
12.6.2操作遊標272
12.7驗證登錄*273
本章小結274
習題12274第13章集合類*275
13.1用Java實現一個鏈式堆棧276
13.2List277
13.2.1自動包裝和解包279
13.2.2Stack280
13.3Set281
13.3.1SortedSet282
13.3.2equals()、hashCode()和Comparable283
13.3.3Comparator285
13.4Map286
13.4.1SortedMap289
13.4.2Properties289
13.5Stream292
13.5.1什麼是Stream292
13.5.2常用方法292
本章小結294
習題13294第14章Java相關框架*295
14.1Spring295
14.1.1DI295
14.1.2JDBC297
14.1.3事務支持302
14.2Hibernate305
本章小結309
習題14310第二部分實驗實驗ⅠJDK安裝、配置及Java程序的編譯和運行313實驗ⅡJava基本語法313實驗ⅢJava的類繼承機制、接口314實驗ⅣJava的輸入機制315實驗ⅤJava的輸出機制315實驗Ⅵ綜合性程序設計——簡單學生信息管理繫統(序列化版)*316實驗Ⅶ綜合性程序設計——簡單學生信息管理繫統(GUI版)317實驗Ⅷ綜合性程序設計——簡單學生信息管理繫統(數據庫版)318實驗Ⅸ綜合性程序設計——簡單學生信息管理繫統(集合版)*319附錄附錄A進行輸入和輸出323附錄BSQL語句簡單介紹325
B.1Java中數據類型和SQL類型的對應關繫325
B.2SQL中對表的操作325
B.3SQL中對表中記錄的操作325附錄CHsqldb使用指南328
C.1啟動Hsqldb數據庫服務器328
C.2用圖形界面管理Hsqldb數據庫服務器328
C.3編譯、運行JDBC程序329
C.4幾個SQL語句的例子329
C.5幾個JDBC的例子330附錄D連接SQL Server 2016 Express數據庫341附錄EEclipse使用指南343
E.1設置Workspace目錄343
E.2建立工程344
E.3編輯、編譯、運行Java類345
E.4調試349
E.5在工程中使用第三方類庫350
E.6使用技巧352附錄F使用Ant354
F.1下載、設置354
F.2定義property、target355
F.3編譯、運行Java程序356
F.4打包Java程序357
F.5啟動、管理、停止Hsqldb數據庫服務器357
F.6備份358
F.7在Eclipse使用Ant358附錄G授課計劃和方法359參考文獻364

前言

前言
本書的內容主要來自於為計算機專業本科生授課的講義。本書在正式出版前，經過了兩年的試用，根據試用中的反饋意見對內容進行了不斷的修改和完善。
本書主要介紹Java編程語言的基礎知識，側重實際應用，力求引導學生提高動手編寫程序的能力。本書內容精練，盡量將復雜的問題進行簡化，主要目的是幫助學生克服畏難情緒，提高學習興趣，從而快速入門。在入門之後可以進行自學，對書中某些知識進行補充。書中加星號（*）部分為選學部分，供有一定基礎的讀者學習使用。
要想學會一門編程語言，需要的是動手編程，隻看書，不寫程序，即使看無數本書也是學不會一門語言的。正如我們的先輩所說：“書上得來終覺淺，絕知此事要躬行”。書上的習題以及實驗數量不多，讀者在學習時要自己給自己找問題來編程解決。這些問題完全可以來自生活中。編程語言特別適宜用來解決手工計算的問題，例如高等數學、線性代數、概率與統計中都有很多需要計算的問題，可以試著編程求兩個矩陣相乘，更難的可以用來求矩陣的分解等。學習數據結構時，可以用Java來實現鏈表、鏈式堆棧等，這樣既可以學好基礎知識，又可以學習如何用程序解決實際問題。前言
本書的內容主要來自於為計算機專業本科生授課的講義。本書在正式出版前，經過了兩年的試用，根據試用中的反饋意見對內容進行了不斷的修改和完善。
本書主要介紹Java編程語言的基礎知識，側重實際應用，力求引導學生提高動手編寫程序的能力。本書內容精練，盡量將復雜的問題進行簡化，主要目的是幫助學生克服畏難情緒，提高學習興趣，從而快速入門。在入門之後可以進行自學，對書中某些知識進行補充。書中加星號（*）部分為選學部分，供有一定基礎的讀者學習使用。
要想學會一門編程語言，需要的是動手編程，隻看書，不寫程序，即使看無數本書也是學不會一門語言的。正如我們的先輩所說：“書上得來終覺淺，絕知此事要躬行”。書上的習題以及實驗數量不多，讀者在學習時要自己給自己找問題來編程解決。這些問題完全可以來自生活中。編程語言特別適宜用來解決手工計算的問題，例如高等數學、線性代數、概率與統計中都有很多需要計算的問題，可以試著編程求兩個矩陣相乘，更難的可以用來求矩陣的分解等。學習數據結構時，可以用Java來實現鏈表、鏈式堆棧等，這樣既可以學好基礎知識，又可以學習如何用程序解決實際問題。
在學會Java的基本語法後，繼續學習分為兩個方面：一是學習使用Java自帶的類庫、第三方提供的類庫；另一個是自己寫類。這兩方面同樣重要。站在巨人的肩上纔能看得更高。同樣，每個人遇到的情況都是不一樣的，通用的類庫隻能解決共有的問題，無法解決每個人特定的問題。
學習Java有一個非常大的方便，就是有詳細的幫助文檔。如果想學會Java，必須學會使用Java自帶類庫的API文檔。該文檔可以從官方網站上下載。同樣，第三方類庫也提供有API文檔，這些都是極好的參考。大部分的第三方Java類庫都是開源的，包括Java類庫也提供了源代碼（JDK下src.zip中就是），可以同時下載源代碼，從這些源代碼中進行學習。對某一個方法不明白，也可看源代碼。Sun還提供了Java Tutorial，這是Java的教程——如何使用類。在有些類的API文檔中有在線教程的鏈接。該教程也可以下載。
這些文檔中，雖然有些有中文版，但是學生在學習時應盡量看英文版，可以同時提高自己的英文水平。目前，大量的資料和比較新的資料都是英文的，直接看英文資料就不用等待翻譯，況且有些資料也根本不會有相應的翻譯。
做事取得的結果取決於熱情、堅持、付出的程度！學編程也是如此！
明天的幸福生活，來自於今天的努力！讓我們攜手共進，繼續創造更美好的生活！
本書由河南工業大學信息科學與工程學院老師編寫，按章節順序，第1、10章由王社偉完成，第2、6、7、8、9、12、13、14章及附錄由劉繼承完成，第3章由韓璐完成，第4、5章由宋敏完成，第11章及實驗由鄭麗萍完成。
在編寫、審校過程中，編著力求敘述清楚、內容正確，如果讀者發現欠妥之處，懇請指正。作者郵箱 ljcyu@163.com（劉繼承），隨時歡迎大家的信件。

編者2018年7月

在線試讀

第5章繼承
繼承是面向對像程序設計（OOP）的三大特征之一，描述了類不同抽像級別之間的關繫: “is a”的關繫，即“特殊與一般”的關繫。換句話說，一般（父類）是特殊（子類）更高級別的抽像。子類可以繼承父類所有的非private類型的屬性和方法，也可以具有自己獨有的屬性和方法。通過類的繼承關繫，使公共的特性能夠共享，提高了軟件的重用性。但在Java中隻允許單繼承。
5.1繼承的語法
在Java中描述兩個類之間的繼承關繫時，使用關鍵字extends，格式如下: class SubClass extends SuperClass{
…
}其中SubClass為子類,SuperClass為父類（或超類）。
在第4章中定義了Person類: class Person{
private String name;
private char sex='M';
Person(String name){
this.name=name;
}
Person(String name,char sex){
this.name=name;
this.sex=sex;
}
public void show(){第5章繼承
繼承是面向對像程序設計（OOP）的三大特征之一，描述了類不同抽像級別之間的關繫: “is a”的關繫，即“特殊與一般”的關繫。換句話說，一般（父類）是特殊（子類）更高級別的抽像。子類可以繼承父類所有的非private類型的屬性和方法，也可以具有自己獨有的屬性和方法。通過類的繼承關繫，使公共的特性能夠共享，提高了軟件的重用性。但在Java中隻允許單繼承。
5.1繼承的語法
在Java中描述兩個類之間的繼承關繫時，使用關鍵字extends，格式如下: class SubClass extends SuperClass{
…
}其中SubClass為子類,SuperClass為父類（或超類）。
在第4章中定義了Person類: class Person{
private String name;
private char sex='M';
Person(String name){
this.name=name;
}
Person(String name,char sex){
this.name=name;
this.sex=sex;
}
public void show(){
String str="下面展示姓名和性別";
System.out.println(str);
System.out.println("姓名: " name " 性別: " sex);
}
}現在要定義一個學生類（Stu），由於“學生是人”，所以學生類和Person類之間是“is a”的關繫，即“繼承”關繫，那麼就可以這樣來定義Stu類:
例5.1Stu類的定義（ch05\\\\Stu.java）。class Stu extends Person {
long id;
private String name;//僅為演示用,實際編程中無須聲明該變量
private char sex='M';
public Stu (String name, long id, char sex){
super(name,sex);
this.id=id;
}
}前面講過子類可以繼承父類的非private類型的屬性和方法，在這個例子中可以看到: 雖然在Person類中定義了name、sex屬性，但它們是private類型的數據，如果Stu也想擁有這些屬性的話，就必須重新定義，不能繼承於父類，也可以定義這些屬性為protected；但show方法，在Person類中是以public的身份定義的，所以Stu類雖然沒有顯式地定義該方法，但卻擁有該方法，因為它繼承了父類的show()方法，編寫測試類如下: class UseStu{
public static void main(String\\[\\] args){
Stu s=new Stu("王強",20094140213L,'M');
s.show();
}
}運行結果: 下面展示姓名和性別
姓名: 王強性別: M另外，還可以在子類中定義子類獨有的屬性和方法，例如本例中的id。
在這裡需要說明以下幾點:
(1) 父類的構造函數不能被子類繼承。
(2) 子類不能繼承或訪問父類中的private屬性和方法。
(3) 父類中的friendly(包訪問權限)的屬性和方法隻有在父類和子類在同一包中時，纔能被子類繼承和訪問。
(4) 父類中由protected或public修飾的屬性和方法，都可以被子類繼承訪問（無論子類是否與父類在同一包中）。
5.2成員變量的隱藏和方法的覆蓋
當子類和父類中定義的成員變量的名字相同時，子類可以隱藏父類的成員變量。同樣，子類也可以通過方法重寫（或稱為覆蓋，Overriding）來隱藏從父類繼承的方法。方法覆蓋是指子類中定義的方法的頭部（方法的名字、返回類型、參數個數和類型）與父類的方法完全相同，而方法體可以不同。但在進行方法覆蓋時，請注意: 在覆蓋時訪問權限隻能放大或相同，不能縮小；覆蓋方法不能拋出新的異常（關於異常，將在第8章介紹）。
例5.2成員變量的隱藏和方法的覆蓋（ch05\\\\OverriddingTest.java）。class Father{
String s="Father";
int i=1;
public void f(){
System.out.println("Father s=" s);
System.out.println("Father i=" i);
}
}
class Child extends Father{
String s="Child";//隱藏了父類的成員變量s
public void f(){//覆蓋了父類的f()方法,但訪問權限隻能是public
System.out.println("Child s=" s);
System.out.println("Child i=" i);
}
}
class OverriddingTest{
public static void main(String\\[\\] args){
Father f=new Father();
Childc=new Child();
f.f();
c.f();
}
}運行結果:Father s=Father
Father i=1
Child s=Child
Child i=1方法覆蓋與方法重載的區別如下: 方法覆蓋發生在父類和子類之間，即子類重寫了父類的某個方法，子類中定義的方法的頭部（方法的名字、返回類型、參數個數和類型）與父類的方法完全相同，而方法體可以不同；重載是在同一類中出現的現像，是指一個類中可以有多個方法具有相同的名字，但這些方法的參數不同。
5.3super
如果想在子類中使用父類的非private類型的變量和方法（特別是被隱藏變量和方法），可以使用super關鍵字。例如，要在例5.2中訪問父類的變量s，就要使用super.s，請試驗在子類Child的f()方法中加入如下的代碼，查看輸出結果。System.out.println("Father s=" super.s);
super.f();如果要在子類的構造方法中訪問父類的構造方法，也要使用super關鍵字，例如例5.1中的super(name,sex);但要注意，該調用語句必須出現在子類構造方法非注釋語句的行。
注意: 如果在子類的構造方法中，沒有使用super調用父類的構造方法，編譯器將自動添加: super();即調用父類不帶參數的構造方法，此時就應保證父類中有不帶參數的構造方法（當父類未定義任何構造方法時，繫統會自動合成；一旦父類定義了一個或多個構造方法，繫統將不再提供默認的構造方法，必須手工定義），否則就會產生錯誤。如例5.1中，由於父類Person未定義無參的構造方法，所以必須用super(name,sex)顯式地調用父類中某個已定義的構造方法。
5.4final
final關鍵字可以用來修飾類、方法、變量(包括成員變量和局部變量及方法中的參數)。
(1) 當final修飾類時，意味著該類不能被繼承，即該類不能有String類等子類。
例5.3final修飾類（ch05\\\\FinClass .java）。final class FinClass{//終類
int i;
FinClass(){
System.out.println("This is a final class.");
}
}
class SubFinClass extends FinClass{//錯誤,不能從終類繼承
}編譯時會出現下面的出錯信息: FinClass.java:7: 無法從終 FinClass 進行繼承
class SubFinClass extends FinClass{(2) 當final修飾方法時，代表該方法不能被重寫。
(3) 當final修飾成員變量時，該變量可以理解為常量，必須賦以初值（可在聲明時賦值，或在類的構造方法中賦值），並且該變量的值不能再改變；當final修飾局部變量時，該局部變量隻能被賦一次值；當final修飾方法中的參數時，該參數的值不能被改變。
例5.4final修飾方法和變量（ch05\\\\UseFinal.java）。class UseFinal{
final int i=1;
final int j;//終變量若不在聲明時賦值,就要在其所屬的類的構造方法中賦值
int k;
UseFinal(){
j=2;
}
final void f(){//終方法,在子類中不能被覆蓋
System.out.println("This is a final method.");
}
void g(){
//i ;錯誤,不能重新指定終變量的值
//j ;錯誤,不能重新指定終變量的值
k ;
final String s="Hello ";
//s="Hi";錯誤,當final修飾局部變量時,該變量隻能被賦一次值
final String str;
str="Java";
System.out.println(s str "i=" i "j=" j "k=" k);
}
void h(final int a){
//a ;錯誤,不能指定終參數
System.out.println("a=" a);
}
public static void main(String\\[\\] args){
UseFinal uf=new UseFinal();
uf.f();
uf.g();
uf.h(100);
}
}
5.5多態
多態是OOP的三大特征之一，此處結合上節講述的覆蓋來理解多態的含義。當一個類(如Instrument類)有多個子類(Wind、Percussion、Stringed)，並且這些類都重寫了父類中的某個方法(void play()方法)，如圖5.1所示。那麼根據前面所講的內容，下面的代碼很容易理解。
圖5.1Instrument及其子類
Wind w=new Wind();//產生Wind類的對像
w.play();//調用Wind類中的play方法
Percussion p=new Percussion();//產生Percussion類的對像
p.play();//調用Percussion類中的play方法
Stringed s=new Stringed();//產生Stringed類的對像
s.play();//調用Stringed類中的play方法那麼下面的代碼又如何理解呢？Instrument insw=new Wind();
insw.play();把Wind類的對像賦值給Instrument類型的變量(insw)對嗎？insw調用的是Instrument類中的play方法，還是Wind類中的play方法呢？
子類和父類之間的關繫是“is a” 的關繫，即“特殊與一般”的關繫，可以說管樂器(Wind)是樂器(Instrumen)，打擊樂器(Percussion)是樂器（Instrument），弦樂器(Stringed)是樂器(Instrument)，所以下面的代碼是正確的。Instrument insw=new Wind();
Instrument insp=new Percussion();
Instrument inss=new Stringed();這就是常說的向上轉型(upcasting)。向上轉型後的對像(簡稱上轉型對像)，如insw、insp、inss。例如play()，在調用方法時，其實調用的仍是子類中所重寫的play方法，而不是父類的play方法。這是因為Java對Override方法調用采用的是運行時綁定，也就是按照對像的實際類型來決定調用的方法，不是按照對像的聲明類型來決定調用的方法。但Overload方法則相反，在編譯時已經進行了方法綁定，按照對像的聲明類型決定調用的方法。
例5.5多態示例（ch05\\\\Music.java）。class Instrument {
public void play() {
System.out.println("Instrument.play()");
}
}
class Wind extends Instrument {
public void play() {
System.out.println("Wind.play()");
}
}
class Percussion extends Instrument {
public void play() {
System.out.println("Percussion.play()");
}
}
class Stringed extends Instrument {
public void play() {
System.out.println("Stringed.play()");
}
}
public class Music {
static void tune(Instrument i) {
i.play();
}
public static void main(String\\[\\] args) {
Instrument\\[\\] ins=new Instrument\\[3\\];
int i=0;
ins\\[i \\]=new Wind();
ins\\[i \\]=new Percussion();
ins\\[i \\]=new Stringed();
for( i=0; i< ins.length; i )
tune(ins\\[i\\]);
}
}運行結果: Wind.play()
Percussion.play()
Stringed.play()那麼能否將父類的對像賦值給子類類型的變量呢？答案是否定的，除非進行強制類型轉換。例如: Wind w=new Instrument();//錯誤
Wind w=(Wind) new Instrument();//正確
5.6繼承與組合
通過使用繼承，提高了類的可重用性，減少了代碼的重復書寫，提高了效率。除了繼承這種方式外，還可以通過組合的方式來重復使用類。所謂組合，就是在一個新類中創建已有類的對像，即新類由已有類的對像組成。例如，下面的學生成績管理程序， Score類中使用了已有類（Student類和Course類）中的對像，所以這種重復使用類的方式就是組合。
例5.6組合示例，學生成績管理程序（ch05\\\\StuApp.java）。package app;
//學生類
class Student {
String name;
long id;
public Student() {
}
public Student(String name,long id){
this.name=name;
this.id=id;
}
}
//課程類
class Course{
long id;
String name;
Course(long id, String name){
this.id=id;
this.name=name;
}
}
//成績類
class Score{
Student stu;
Course course;
double grade;
Score(Student stu,Course course,double grade){
this.stu=stu;
this.course=course;
this.grade=grade;
}
}
//應用類
class StuApp{
private static Course\\[\\] courses=new Course\\[5\\];
private static Student\\[\\] stus=new Student\\[10\\];
private static Score\\[\\] scores=new Score\\[50\\];
//添加課程
private static int coursesIndex=0;
public static void addCourse(Course course){
if(coursesIndex>courses.length) {
System.out.println("too many courses");
return;
}
courses\\[coursesIndex \\]=course;
}
//添加學生
private static int stusIndex=0;
public static void addStu(Student stu){
if(stusIndex>stus.length) {
System.out.println("too many student");
return;
}
stus\\[stusIndex \\]=stu;
}
//添加學生的成績
private static int scoreIndex=0;
public static void addScoreToStu(Student stu,String courseName,double grade){
if(scoreIndex>scores.length){
System.out.println("too many student");
return;
}
for(int i=0;i<=coursesIndex;i ){
if(courses\\[i\\].name.equals(courseName)){
scores\\[scoreIndex \\]=new Score(stu,courses\\[i\\],grade);
break;
}
}
}

public static void main(String\\[\\] args){
//添加課程
Course java=new Course(1,"java");
addCourse(java);
Course os=new Course(2,"os");
addCourse(os);
Course math=new Course(3,"math");
addCourse(math);
//添加學生張三並為其添加成績
Student stua=new Student("張三",1L);
addStu(stua);
addScoreToStu(stua,"java",86);
addScoreToStu(stua,"math",89.5);
//添加學生李四,並為其添加成績
Student stub=new Student("李四",2L);
addStu(stub);
addScoreToStu(stub,"os",100);
//打印標題欄
System.out.println("學號\\\姓名\\\\\\課程名\\\\\\成績");
//顯示學生的成績
for(int i=0;iStringBuilder sb=new StringBuilder();
sb.append(scores\\[i\\].stu.id).append("\\\").append(scores\\[i\\].stu.name);
for(int j=1;j<=16-(scores\\[i\\].stu.name.getBytes()).length;j )
sb.append(" ");
sb.append(scores\\[i\\].course.name);
for(int k=1;k<=16-(scores\\[i\\].course.name.getBytes()).length;k )
sb.append(" ");
sb.append(scores\\[i\\].grade);
System.out.println(sb);
}
}
}對於重復使用類的兩種方式——繼承和組合，如何選擇呢？這裡給出一個小訣竅: 如果類之間的關繫是“B is a A”的關繫，如貓是動物，弦樂器是樂器等，那麼A、B之間就應該是繼承的關繫，即B繼承A，B是子類，A是父類。如果類之間的關繫是“A has a B ”，那麼A、B之間的關繫就應該是組合的關繫，例如汽車有門、窗、引擎等，那麼在定義汽車（A）類時，就可以采用組合的方式，即將門類、窗類、引擎類的對像作為汽車的成員。
5.7初始化順序*
在第4章曾講過，類在加載後，其內部變量的初始化順序是按照它們在類中的定義的順序進行的，當遇到靜態變量或語句塊時，靜態數據要先於實例變量（靜態數據在加載類時隻初始化一次，而實例變量則是在創建對像時初始化的，也就是每創建一個對像，就要初始化其實例變量），並且變量的初始化總是在方法（包括構造方法）調用前進行。那麼類在何時會被加載呢？當一個類首次被使用時繫統就會加載該類。首次使用類的情況可以是以下方式之一:
(1) 次創建該類的對像；
(2) 首次訪問該類的靜態變量或靜態方法時。
為了更好地理解變量的初始化順序，請看下面的例子。
例5.7初始化順序（1）（ch05\\\\InitOrder.java）。class Star {
Star(int marker) {
System.out.println("Star(" marker ")");
}
void f1(int marker) {
System.out.println("f(" marker ")");
}
}
class Flag {
Star s1=new Star(11);
Flag() {
System.out.println("Flag()");
s3=new Star(555);
s3.f1(66);
}
static Star s2=new Star(22);
void f() {
System.out.println("f()");
}
Star s3=new Star(33);
}
public class InitOrder {
Star s1=new Star(1);
public static void main(String\\[\\] args) {
System.out.println("Creating new Flag() in main");

書摘插畫

商品搜索

商品分类

【醫學】

【各大出版社】