第一篇：java程序設計
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class CardText extends JFrame implementsActionListener {
JButton btn[]=new JButton[6];
CardLayout card=new CardLayout();
Panel p=new Panel();
CardText()
{
setSize(300,200);
setVisible(true);
setTitle(“卡片布局示例”);
setDefaultCloseOperation(EXIT_ON_CLOSE);add(p);
p.setLayout(card);
for(int i=1;i<=5;i++)
{
btn[i]=new JButton(“卡片”+i);
p.add(btn[i],“卡片標識”+i);
btn[i].addActionListener(this);
}
validate();
}
public void actionPerformed(ActionEvent e){
card.next(p);
}
}
public class example58
{
public static void main(String[] args)
{
new CardText();
}
}
第二篇：java程序設計教案
《Java程序設計》
授 課 人：授課班級：電子商務專業(yè)
授
課
教
案
第一章
Java語言簡介
教學目的要求
? 了解Java的基本特點和用途 ? 掌握如何下載Java SDK軟件包 ? 了解設置Java程序的開發(fā)環(huán)境SDK ? 如何運行Java程序 ? 了解Java的概貌 主要內(nèi)容
? Java語言的發(fā)展歷程； ? Java語言的特點； ? ? ? ? Java語言的開發(fā)工具；
Java應用程序和小程序； Java程序的注釋方法； 寫Java程序的風格規(guī)范。
重點內(nèi)容
? Java語言的特點； ? Java語言的開發(fā)工具；
? Java應用程序和小程序；
難點內(nèi)容
無
課時分配
1課時 教學方法
講授法、演示法、對比法 講授內(nèi)容提要
1.1
Java語言的發(fā)展簡介
1991年Sun Mircosystem 公司成立了一個Green項目開發(fā)小組，Jame Gosling 為組長； 設計Java 采用虛擬機代碼（Virtual Machine Code），即.class文件，它通過解釋器運行 ； 1995年5月Sun Mircosystem 公司對外正式發(fā)布Java1.0；
Java2 用途：適用于各種應用開發(fā)，尤其是網(wǎng)絡應用，網(wǎng)絡服務和嵌入式系統(tǒng)。1.2
Java語言的特點 1．簡單性 2．面向?qū)ο?3．網(wǎng)絡適用性 4．健壯性 5．安全性
6．平臺無關性 7．可移植性 8．解釋型 9．高性能 10．多線程 11．動態(tài)性 12．豐富的類庫 13．嵌入瀏覽器運行
1.3
Java類庫的概念 1.4
網(wǎng)絡瀏覽器 1.5
Java開發(fā)工具
NetBeans： 這個集成環(huán)境可以方便地進行程序的編輯、編譯、生成和運行。J2sdk :
http:// java.sun.com免費下載;Visual J++ 6.0 / 8.0： VJ++還吸收了VB集成開發(fā)環(huán)境IDE的特征，是一個強有力的Java程序開發(fā)工具。Jcreator
Eclipse(MyEclipse)等
1.6
Java程序的分類 基于控制臺的應用程序；
基于瀏覽器運行的小程序applet。
小程序與應用程序的區(qū)別是：小程序必須依賴一個HTML文件和支持Java的網(wǎng)絡瀏覽器。老師演示小程序和applet程序
應用程序舉例(程序1-1)： public class hello {
public static void main(String args[ ]){
System.out.println(“Hello Java!”);
} }
小程序舉例(程序1-2)：
import java.awt.Graphics;
// 注意該行的含義 import java.applet.Applet;public class sayhello extends Applet {
public void paint(Graphics g){
g.drawString(“Hello Java!”,35,30);
} }
小程序?qū)腍TML文件：
1.7
1.8 對Java程序的解釋
編寫Java程序的風格要求 課堂練習：
請編寫一個應用程序輸出你自己的學號和姓名 課外練習（作業(yè)）： 下載并安裝J2SDK； 設置系統(tǒng)環(huán)境變量 下載并安裝MyEclipse 熟悉MyEclipse的開發(fā)環(huán)境
第2章
數(shù)據(jù)類型、運算符和表達式
教學目的要求
? 掌握字符常量和符號表示的常量的概念和應用 ? ? ? ? 掌握整形、浮點型、字符型和布爾型變量的概念和應用 掌握數(shù)據(jù)的概念 理解參數(shù)傳遞方式
學會邏輯運算符、算術(shù)運算符和位運算符的使用方法
主要內(nèi)容
? 常量：包括字面常量和符號表示的常量； ? 變量：整形、浮點型、字符型和布爾型； ? 數(shù)組：Java的數(shù)組屬于類類型； ? 參數(shù)傳遞方式；
? 運算符：包括邏輯運算符、算術(shù)運算符和位運算符等；
重點內(nèi)容
? 整形、浮點型、字符型和布爾型變量的概念和應用； ? 符常量和符號表示的常量的概念和應用
難點內(nèi)容
? 參數(shù)傳遞方式
課時分配
2課時 教學方法
講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要
2.1
常量
整形常量：采用八進制、十進制、十六進制表示，但不能采用二進制表示，和C/C++中的一樣。
浮點常量：采用十進制或科學記數(shù)法表示。在缺省情況下一個浮點數(shù)是double型。布爾常量：true和false，它們不是數(shù)，不能進行算術(shù)運算。字符常量：與C/C++中的表示類似
。字符串常量：Java中字符串常量是對象。
2.2
變量
變量的命名原則是：以字母（’a’?’z’和 ’A’?’Z’）、下劃線（‘_’）和‘$’符號開頭的，由字母、數(shù)字（’0’?’9’）、下劃線和‘$’構(gòu)成的一個符號序列。
例如，a，_a，NameOfStudent，$10均是合法變量名，而-a和9a是非法變量名。關鍵字不能用作變量名(見表2-1)注意：Java對變量是區(qū)分大小寫.2.2.1
整形類型的變量 字節(jié)（byte）型，8個位。
短整形(short)，占16個位。整形(int)，占32個位。
長整形(long int)，占64個位。
Java中的整形最值均有符號。例如程序2-1測試最值：
public class Test_Int {
// 程序2-1 測試整形變量的最值
public static void main(String [ ] args){
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
System.out.println(Short.MAX_VALUE);System.out.println(Short.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);
} }
注意： byte、short、int、long是原子類型，而Byte、Short、Integer和Long分別是四種原子類型對應的類類型。
2.2.2
字符類型變量
Java字符量的長度為16個位，表示范圍是從‘u0000’ 到 ‘uffff’ 即從0 到 65535； Character是char類型對應的類類型 ； 最大值 Character.MAX_VALUE ； 最小值 Character.MIN_VALUE ； 2.2.3
浮點類型變量 分類：float和double。
Float、Double 是對應的類類型 ；
Float.MAX_VALUE、Float.MIN_VALUE是最值。Float.POSITIVE_INFINITY 和
Float.NEGATIVE_INFINITY是正/負無限大。2.2.4
布爾類型變量
boolean變量取值：true和false ；
true和false不能轉(zhuǎn)換成任何數(shù)值表示，true不是1，false也不是0。
2.2.5
原子類型變量的生存空間
一個變量的生存空間是由兩個大括號決定的 范圍。下列寫法在C/C++中是正確的，但在Java中是錯誤的(注意)。{
int x=1;{ int x=0;// 錯誤 } }
2.3
變量賦值問題
如果類中定義的原子類型變量，未給出初值，那么它們將有缺省值 ：byte、short、int 和long變量的缺省值是0；char、float、double和boolean變量的缺省值分別是’u0’、0.0f、0.0d和false。
方法內(nèi)定義的局部變量，應當對其賦值，否則無法通過編譯。例如： // 程序2-4 class Test {
// 定義一個類
int Value;// 類中的變量未賦值，缺省就是0 } public class Test_Var{ public static void main(String [ ] args){
int x=100;
// 必須賦值，否則無法通過編譯
Test obj=new Test();// 對象賦值
System.out.println(obj.Value +“
”+x);
} } 2.4
數(shù)組
Java數(shù)組是系統(tǒng)定義類Array 的子類； 數(shù)組的分類同C/C++：一維和多維。
2.4.1
一維數(shù)組
定義數(shù)組的格式 ：int a[ ] ； 或
int[ ] a ；其值是null ；
在定義數(shù)組時不能指定大小。a僅是一個引用，代表一個數(shù)組名，但沒有對應的空間。產(chǎn)生數(shù)組空間的方法有兩種 ：
在定義時直接賦值：int a[ ]={1,2,3};
通過new分配空間： int a[ ]=new int[10];public class Test_Array{
public static void main(String [ ] args){
int a[ ]={1,2,3}, b[ ];
b= a;
for(int i=0;i<3;i++)b[ i ]++;
for(int i=0;i<3;i++)System.out.println(a[i]);
} }
public class Test_Array{
public static void main(String [ ] args){
int a[ ]={1,2,3}, b[ ];
b = new int[6];
System.out.println(“b數(shù)組長度 = ” + b.length);
for(int i=0;i System.out.print(b[i]+“ ”); } } 注意：(1)獲得數(shù)組元素的個數(shù)：數(shù)組名.length； (2)一個整形數(shù)組若僅僅采用new分配空間，而沒有對其賦值，那么每個元素的值是0 注意：Java數(shù)組名是一個引用，當將一個數(shù)組名賦值給另一個數(shù)組時，實際上是名字的復制 2.5 Java中的參數(shù)傳遞方式 Java的參數(shù)傳遞的形式有兩種：基本類型按值傳遞，對象類型按引用傳遞； 通過return語句從方法中返回時，基本類型總是以值的方式返回，而對象總是以引用方式返回。例如程序2-8 ： class test{ int x;} public class Test_Paras { static test fun(test o,int y){ o.x=20; } } y=1; return o;public static void main(String [ ] args){ test obj1 , obj2;int Val = 3;obj1=new test();obj1.x=100; obj2=fun(obj1,Val); System.out.println(obj1.x+“ ”+ obj2.x+“ ”+Val); } 2.6 Java的運算符 主要包括： 算術(shù)運算符、關系運算符、邏輯運算符、位運算符和三元條件運算符。2.6.1 算術(shù)運算符 算術(shù)運算符：+、-、*、/、%、++和--，與C/C++基本相同。 %運算符不但可以對整形數(shù)據(jù)運算，而且可以對浮點型數(shù)據(jù)運算。例如：3.14 % 2.5的值約等于0.64 ； 隠式數(shù)據(jù)類型轉(zhuǎn)換： 當整型與浮點型數(shù)據(jù)進行混合運算時，表達式中的數(shù)據(jù)類型會進行相應的自動轉(zhuǎn)換，規(guī)則為：byte->short->int->long->float->double。 這種轉(zhuǎn)換規(guī)則也適應于賦值語句，當賦值符左右兩側(cè)變量類型不一致時，只要轉(zhuǎn)換過程中不丟失數(shù)據(jù)，便進行自動轉(zhuǎn)換。 class number { int x;} public class relationalOperator{ public static void main(String args[ ]){ } number n1,n2; n1=new number(); n2=new number();n1.x=1; n2.x=1;if(n1.x==n2.x) System.out.println(“對象的數(shù)據(jù)成員x相等！”); if(n1==n2) System.out.println(“n1和n2是一個對象！”);else System.out.println(“n1和n2不是一個對象！”);} 2.6.2 關系運算符 關系運算符不能同其它類型的變量一同 參與運算，例如假設a,b,c是三個整形的變量，那么 a=b==c 是 正確 OR 錯誤？ ； 關系運算符用于對象時，是判別兩個引用是否代表同一個對象。而不是判斷兩個引用所指向的對象是否同屬一個類。 2.6.3 邏輯運算符 邏輯運算符有&&、|| 和!，分別是與、或和非。運算結(jié)果是true或false； 邏輯運算有求值“短路”現(xiàn)象，例如程序2-11 ： public class shortCut { static boolean testOne(int x){ System.out.println(x+“ < ”+1+“ ” +(x<1));return x < 1;} static boolean testTwo(int x){ System.out.println(x+“ < ”+1+“ ” +(x<2));return x < 2; } public static void main(String [ ] args){ } if(testOne(6)&& testTwo(1))System.out.println(“表達式為真”);else System.out.println(“表達式為假”); } 2.6.4 位運算符 位運算符：&、|、^、~、<<、>>，分別稱為位與、或、異或、左移、右移； Java引入一個專門用于邏輯右移運算符>>>，它采用了所謂的零擴展技術(shù)，不論原值是正或負，一律在高位補0。例如： int a=-2 , b; b=a>>>30;2.6.5 三元條件運算符 語法格式：（exp）?(exp1)：(exp2)； Java要求：(exp1)與(exp2)必須同類型。2.6.6 “+”運算符 Java對“+”進行了重載，可以將任何類型的對象（包含原子類型）轉(zhuǎn)化為String類型。例如： int x=1;char ch='A';double d=9.8;System.out.println(“Result: ”+x+ch+9.8);課堂練習： 課外練習（作業(yè)）： P32 3、4、6題。 第3章 控制語句 教學目的要求 ? 了解Java程序的結(jié)構(gòu)，學習使用各種語句結(jié)構(gòu)來控制程序的流程，完成程序的功能任務。 主要內(nèi)容 ? Java的分支語句； ? 循環(huán)控制語句； ? break和continue語句； ? 帶標號的break和continue語句。 重點內(nèi)容 ? Java的分支語句； ? 循環(huán)控制語句； ? break和continue語句； 難點內(nèi)容 ? 循環(huán)控制語句； ? break和continue語句； 課時分配 3課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 3.1 分支語句 if-else語句； switch-case語句。 3.1.1 if 語句 if語句的語法格式 同C/C++； 條件表達式必須是布爾類型，例如： 下面的寫法在C/C++中是合法的，但在Java中卻是非法的 ： int i=10;if(i) ...程序3-1描述了用applet從文本框獲取數(shù)據(jù)，然后將比較的結(jié)果顯示出來。 // 程序 3-1 import java.awt.*;import java.applet.*; public class compareNumbers extends Applet{ Label lab1,lab2;TextField input1,input2; int num1,num2;public void init(){ lab1=new Label(“輸入第1個整數(shù)”); input1=new TextField(10); lab2=new Label(“輸入第2個整數(shù)”);input2=new TextField(10); add(lab1); add(input1);add(lab2);add(input2);} public boolean action(Event e , Object o){ } if(e.target==input1 || e.target==input2){ num1=Integer.parseInt(input1.getText()); num2=Integer.parseInt(input2.getText()); if(num1 switch 語句 switch語句的語法結(jié)構(gòu) 同C/C++； switch后面的表達式類型必須是字符類型或整形 ； case后面的常量不能重復 ； 程序3-3采用小程序?qū)崿F(xiàn)將學生的百分制成績轉(zhuǎn)換為優(yōu)、良，中、及格和不通過五個等級： // 程序3-3 import java.awt.*;import java.applet.*; public class scoreConvert extends Applet{ Label prompt; TextField input;int Excellent,Good,Middle,Pass,Failure;public void init(){ prompt=new Label(“輸入成績”); } public void paint(Graphics g){ g.drawString(“各等級的人數(shù):”,25,40);g.drawString(“優(yōu)秀 : ”+Excellent,25,55);g.drawString(“良好 : ”+Good,25,70);g.drawString(“中等 : ”+Middle,25,85);g.drawString(“及格 : ”+Pass,25,100);g.drawString(“不通過: ”+Failure,25,115);input=new TextField(2);add(prompt);add(input);} public boolean action(Event e , Object o){ int score=Integer.parseInt(input.getText()); showStatus(“"); input.setText(”“); switch(score/10){ case 10: case 9: Excellent++; break;case 8: Good++; break;case 7: Middle++; break;case 6: Pass++; break;case 5: case 4: case 3: case 2: case 1: case 0: Failure++; break;default: showStatus(”輸入有誤，重新輸入!“); } repaint(); return true;} } 程序3-3需要注意的地方 在action（）方法中調(diào)用的repaint()方法，是一個系統(tǒng)方法，它具有自動調(diào)用paint()方法的能力，從而實現(xiàn)對網(wǎng)頁的刷新。3.2 循環(huán)控制語句 Java中的循環(huán)控制語句有三種，分別是：while，do-while和for語句;循環(huán)體內(nèi)的語句會反復執(zhí)行，直到控制布爾表達式的值變?yōu)閒alse為止。3.2.1 while語句 while語句格式： while(Boolean-Expression) StatementS 程序示例3-4 略 3.2.2 do-while語句 do-while語句的語法格式如下： do{ Statement }while(Boolean-Expression); 程序3-5 如下： // 產(chǎn)生一個大于0.9的隨機數(shù)為止 public class GenerateDoubleNumbers { public static void main(String args[ ]){ } double d;do{ d=Math.random();System.out.println(d); }while(d<0.9);} 3.2.3 for語句 for語句語法格式如下： for(ForInitopt;Boolean-Expression;ForUpdateopt) Statement // 程序3-6輸出一個*三角形 public class printGraphics extends Applet{ public void paint(Graphics g){ int xpos,ypos=0; for(int row=6;row>=1;row--){ xpos=25;ypos+=15; } for(int column=1;column<=row;column++){ } g.drawString(”*“,xpos,ypos);xpos+=7; } } 3.3 break語句和continue語句 3.3.1 不帶標號的break語句和continue語句 break語句可以跳出包含它的最內(nèi)層的循環(huán)，不再執(zhí)行剩余的語句； continue語句停止執(zhí)行當前的循環(huán)，回到循環(huán)處，開始執(zhí)行下一輪的循環(huán)。這些特性和C/C++的功能一樣。for(int i=1;i<10;i++) { if(i%3==0) continue; else System.out.println(”i = “+i); } for(int i=1;i<10;i++) { if(i%3==0) break; else System.out.println(”i = “+i); } 課堂練習： 1、仔細分析下面程序，寫出程序的最終運行結(jié)果。public class s_switch { public static void main(String args[]) { int ch=8; int r=10; switch(ch-1){ case 7: r=r+3; case 8: r=r+5; case 9: r=r+6;break; default:; } System.out.println(”r=“+r); } } 2、隨機產(chǎn)生26個英文字母a~z，直到大于u為止。用while和for語句實現(xiàn)。 課外練習（作業(yè)）： P44 1—4 第4章 Java的類 教學目的要求 ? 理解面向?qū)ο缶幊痰幕靖拍?? 了解類的封裝方法 ? 如何創(chuàng)建類和對象 ? 了解成員變量和成員方法的特性 ? 學習使用OOP方式進行程序設計 ? 深刻理解類的繼承性和多態(tài)性 主要內(nèi)容 ? 類的定義和使用； ? 方法的定義和使用； ? 實例變量和局部變量； ? 構(gòu)造方法； ? ? ? ? 方法的覆蓋和重載； 關鍵字this的用法； 繼承的概念和應用； 組合與繼承； ? 抽象方法和抽象類； ? 對象類型轉(zhuǎn)換； ? 訪問權(quán)限限制符：public、private、protected。 重點內(nèi)容 ? 類的定義和使用； ? 方法的定義和使用； ? 構(gòu)造方法； ? 方法的覆蓋和重載； ? 關鍵字this的用法； ? ? ? ? 繼承的概念和應用； 組合與繼承； 抽象方法和抽象類； 對象類型轉(zhuǎn)換； 難點內(nèi)容 ? 構(gòu)造方法； ? 方法的覆蓋和重載； ? 繼承的概念和應用； ? 組合與繼承； ? 抽象方法和抽象類 課時分配 8課時 教學方法 講授法、演示法、對比法、實驗驗證法、學生討論法 講授內(nèi)容提要 4.1 類與對象 在Java程序中，除原子類型的變量以外都是對象，連Java程序本身也不例外。 類是面向?qū)ο蟪绦蛟O計的基礎，OO始終是圍繞著對象的封裝性、繼承性和多態(tài)性展開討論的。 4.1.1 類與對象的區(qū)別 類是一個抽象的概念，對象是一個具體的概念。 類是在一組對象的基礎上，通過抽象和概括獲得的一個概念。 對象是由數(shù)據(jù)和方法緊密結(jié)合的一個封裝體，具有信息隱藏的能力。 對象可以通過方法（函數(shù)）與其它對象進行通信，但并不知道這些方法的實現(xiàn)細節(jié)。4.1.2 Java和C編程思想的區(qū)別 C是結(jié)構(gòu)化的編程語言，以函數(shù)為編程單元，程序員把注意力集中在編寫函數(shù)上。Java是面向?qū)ο蟮木幊陶Z言，以類為編程單元，程序員的精力集中在對類的設計上。 對象將實例變量（instance variable）和對數(shù)據(jù)的操作（即方法）約束在一起，類似一個獨立的程序，易于擴充，易于維護，代碼可復用。 4.1.3 如何定義類 類是對象的模板，它定義了對象的結(jié)構(gòu)和操作數(shù)據(jù)的方法。public class Sayhello extends Applet { public void paint(Graphics g){ int xPos=35; int yPos=30; g.drawString(”Hello Java!“,xPos,yPos); } } 定義類的通用格式如下： class className extends superClassName{ type instance-vairbale1;return-type methodName1(parameter-list){ method-body;} } public class Hello { public static void main(String args[ ]){ System.out.println(”Hello Java!“); } } 系統(tǒng)類Object是整個類層次結(jié)構(gòu)中的根。 如果我們要定義Object的子類，可以不指明extends Object，默認情況下一個類就是Object類的子類。 類內(nèi)定義的變量稱為實例變量，函數(shù)稱為方法； Java將類的定義和類的實現(xiàn)放在一起，便于系統(tǒng)維護。例如： class point { // Object類的子類 int x , y; void init(int a, int b){ int i=0; x=a; y=b; } } 4.1.4 對象和引用 對象是客觀存在的變量，對象的引用就是對象的名字，例如：Point p1;創(chuàng)建對象：p1=new Point(); 一個對象可以有多個別名; p2=p1;將一個變量設置為null，表明該變量不代表任何對象 : p1 = null; 每個對象都有自己的變量，改變一個對象的實例變量并不影響到另外一個對象。例如： class Point { // 程序4-1 int x , y; void init(int a, int b){ x=a; y=b; } } public class TwoPoint{ public static void main(String [ ]args){ Point p1= new Point(), p2= new Point(); p1.x=10;p2.x=30;p1.y=20;p2.y=40;System.out.println(”x = “+ p1.x +” y= “+p1.y);System.out.println(”x = “+ p2.x +” y= “+p2.y); } } 4.2 方法 方法是一個功能模塊，類似C中的函數(shù)； 方法和實例變量都必須定義在類內(nèi)，方法是類的功能接口 ； 定義方法的原則：方法應當只執(zhí)行單一的任務，并且方法名能有效地表達該任務； 方法的返回值類型、方法名和參數(shù)表共同稱之為方法的特征。調(diào)用方法的格式：引用.方法名(參數(shù)表);例如： Point p1=new point()，p2=new point();Point p3=p2;p1.init(10,20);//僅對p1對象的x和y進行賦值 p2.init(30,40);//僅對p2對象的x和y進行賦值 對象是客觀存在的變量，對象的引用就是對象的名字，例如：point p1;創(chuàng)建對象：p1=new point(); 一個對象可以有多個別名; p2=p1;將一個變量設置為null，表明該變量不代表任何對象 : p1 = null; 每個對象都有自己的變量，改變一個對象的實例變量并不影響到另外一個對象。 4.3 實例變量和局部變量 class Loc { // 程序4-2 int x=1;// 實例變量 void printLocVar(){ int x=25;// 局部變量 } System.out.println(”n x is :“+x); ++x; System.out.println(” x is :“+x); void printInstanceVar(){ System.out.println(”n x is :“+x); x*=10; System.out.println(x is :”+x);} } public class TestInstanceVar { // 程序的主類 public static void main(String args[ ]){ System.out.println(“ x is :”+x); obj.printLocVar(); obj.printInstanceVar(); System.out.println(“ x is :”+x); loc obj=new Loc(); int x=5; // 局部變量 x } } 4.3 實例變量和局部變量 Java中的變量分為兩種：類內(nèi)定義的實例變量，方法中定義的局部變量。 在同一個作用域內(nèi)，不允許定義兩個同名的局部變量。 局部變量可以掩蓋實例變量。 實例變量屬于對象，它描述了對象的屬性，隨著對象的存在而存在； 局部變量是隨著方法的調(diào)用而存在，一旦方法調(diào)用結(jié)束，局部變量也就消亡了。4.4 構(gòu)造方法 構(gòu)造方法的功能是在創(chuàng)建對象時初始化對象的實例變量； 討論：構(gòu)造方法的特點： 無返回值，無void 方法名與類名相同 僅在創(chuàng)建對象時調(diào)用 class point { // 程序4-3 } public class createPoint { public static void main(String args[ ]){ point p= new point(10,20); System.out.println(p.x +“ ”+p.y);} int x, y;point(int a, int b){ } x=a;y=b; } 如果類中沒有定義構(gòu)造方法，編譯器會自動創(chuàng)建一個缺省的、不帶參數(shù)的構(gòu)造方法。構(gòu)造方法是在對象創(chuàng)建之后，new操作完成前被調(diào)用的。 4.5 方法重載 方法重載是在一個類中定義二個或多個同名的方法，但方法的參數(shù)個數(shù)或類型不完全相同；例如： class point { int x, y;point(int a, int b){ x=a;y=b;} point(){ x=-1;y=-1;} point(double a, int b){ x=(double)a;y=b;} } 方法重載的一個誤區(qū)：是靠返回值區(qū)別重載，即定義多個方法，它們的名稱和形參類型完全相同，但返回值不同，這是不允許的； 4.6 關鍵字this this指代對象，是對當前對象的一個引用。例如： class IntVector { // 程序4-6 int v[ ]; boolean equals(IntVector other){ if(this == other)return true; return false;} } class testIntVector { public static void main(String args[ ]){ IntVector t1=new IntVector()，t3=new IntVector()，t2=t1; System.out.println(t1.equals(t2)); System.out.println(t3.equals(t2)); } } Java中的級連調(diào)用，仍是指代當前對象的this。例如：// 程序4-7 import java.awt.*;import java.applet.*; class time{ private int hour, min, sec; time(){ setHour(0);setMin(0); setSec(0);} time setHour(int h){ hour=((h>=0 && h<24)? h: 0);return this;} time setMin(int m){ min=((m>=0 && m<60)? m: 0); return this;} time setSec(int s){ sec=((s>=0 && s<60)? s: 0); return this;} String tostring(){ return hour+“:”+min+“:”+sec;} public class timeToString extends Applet{ private time t; public void init(){ } t=new time();} public void paint(Graphics g){ t.setHour(18).setMin(30).setSec(20); } g.drawString(“ time:”+t.tostring(),25,45);} 在構(gòu)造方法內(nèi)部使用this，它用于指代另外一個構(gòu)造方法，但不能指代非構(gòu)造方法。例如： class point { } 4.7 繼承 繼承是軟件重用的一種形式，可以提高系統(tǒng)的性能； 繼承語法： class className extends superClassName{ 各實例變量和方法的定義 } 例如： class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} point(){ this.x=0; this.y=0;} } class circle extends point{ int radius; circle(int r, int x, int y){ radius=r; this.x=x; this.y=y; } } Java不支持多繼承，但支持多接口； 子類的對象也是其超類的對象，反之未必； 繼承具有傳遞性： B繼承于A，C又繼承于B，則C也繼承了A中的實例變量和方法。 關鍵字super 構(gòu)造方法是一種特殊的方法，子類不能繼承超類的構(gòu)造方法，但子類構(gòu)造方法可以通過super調(diào)用超類的構(gòu)造方法。int x, y;point(){ this(-1,-1);} point(int a, int b){ x=a;y=b;} 當創(chuàng)建子類對象時，首先執(zhí)行超類構(gòu)造方法，然后執(zhí)行子類的構(gòu)造方法。例如： class point{ // 程序4-8 int x, y; point(int x, int y){ } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; System.out.println(“子類構(gòu)造函數(shù)被調(diào)用！”); this.x=x;this.y=y; System.out.println(“父類構(gòu)造函數(shù)被調(diào)用！”); } } public class testInherence { public static void main(String args[ ]){ circle c1; c1=new circle(1,1,1); } } 再次討論構(gòu)造方法 若父類沒有定義構(gòu)造方法，那么對父類數(shù)據(jù)的初始化將采用系統(tǒng)缺省的構(gòu)造方法；例如： class point{ int x, y; } class circle extends point{ int radius; circle(int r, int x, int y){ this.x=x; this.y=y; radius=r; } } 若父類定義有缺省構(gòu)造方法，那么子類可根據(jù)自己的需要設置自己的構(gòu)造方法。例如： class point{ int x, y; point(){ this(0,0); } point(int x, int y){ this.x=x;this.y=y; } } class circle extends point{ // 注意子類的構(gòu)造函數(shù) int radius; circle(int r, int x, int y){ radius=r;} } 若父類定義的構(gòu)造方法都是有參的，那么子類構(gòu)造方法必須通過super調(diào)用父類構(gòu)造方法，class point{ private int x, y; point(int x, int y){ this.x=x; this.y=y; } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; } } 4.8 方法的覆蓋 方法的覆蓋發(fā)生在父類和子類之間，若子類中定義的某個方法的特征，與父類中定義的某個方法的特征完全一樣，那么就說子類中的這個方法覆蓋了父類對應的那個方法。 4.8.1 覆蓋與重載的區(qū)別 重載可以出現(xiàn)在一個類中，也可以出現(xiàn)在父類與子類的繼承關系中，并且重載方法的特征一定不完全相同。 覆蓋特點：子類中的方法特征與父類定義的對應方法的特征完全一樣。例如： // 程序4-9 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){super(x, y); radius=r; } double area(){ return Math.PI*radius*radius;} } public class testOverWrite { public static void main(String args[ ]){ } circle c1; c1=new circle(1,1,1); System.out.println(c1.area());} 4.8.2 方法的動態(tài)調(diào)用 Java的所有對象運行時都有一個類型標識(RTTI：Run-Time Type Identification)，該標識記錄了每個對象所屬于的類。Java用此標識在運行時選擇正確的方法。例如： // 程序4-11 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r;} double area(){ // 覆蓋了父類的area方法 return Math.PI*radius*radius; } } public class dynamicalCall { public static void main(String args[ ]){ point p[ ]={new point(2,2), new circle(1,1,1)}; for(int i=0;i System.out.print(“類名： ”+ } p[i].getClass().getName());System.out.print(“父類：”+ p[i].getClass().getSuperclass());System.out.println(“ 面積： ”+ } p[i].area());} 子類對象調(diào)用方法時: (1)子類檢查是否具有同名和同參數(shù)類型的方法，若有則調(diào)用該方法，否則繼續(xù)執(zhí)行。 (2)到父類中尋找同名和同參數(shù)類型的方法，若有則調(diào)用該方法。若找不到，將產(chǎn)生編譯錯誤。 對象決定自己到底該調(diào)用哪個方法，取決于該對象在繼承鏈中的位置。 4.9 多態(tài)性不適合繼承鏈中的實例變量 引用.方法：根據(jù)多態(tài)性調(diào)用； 引用.實例變量：根據(jù)引用的類型調(diào)用。即：多態(tài)性僅僅適用于方法的調(diào)用，而不適合實例變量。例如： class Base{ // 程序4-12 int x=1;void print(){ System.out.println(“當前類為 ”+ } this.getClass().getName());System.out.println(“對象的x= ”+this.x); } class Derived extends Base{ } int x=2;void print(){ System.out.println(“當前類為 ”+ } this.getClass().getName());System.out.println(“對象的x= ”+this.x); public class confusions{ public static void main(String [ ] args){ Base obj=new Derived(); } } obj.print();System.out.println(“對象的x= ”+obj.x); 4.10 finalize Java的垃圾回收器具有自動回收垃圾的能力。 垃圾回收器是一個優(yōu)先級比較低的線程，在系統(tǒng)空閑時運行。 在對象被回收之前，有時需要執(zhí)行一些特殊的操作，例如保存文件、清除屏幕等，這時就要用Java的finalize方法。例如： class point{ // 程序4-13 int x, y; point(int a, int b){ } x=a;y=b;System.out.println(“point constructor:”+getString()); public void finalize(){ // 注意該方法 System.out.println(“point finalizer:”+getString()); } String getString(){ return “x=”+x+“ y=”+y; } } class circle extends point{ int radius; circle(int r, int a, int b){ super(a,b);radius=r;System.out.println(“circle constructor:”+getString()); } public void finalize(){ System.out.println(“circle finalizer:”+getString()); } String getString(){ return super.getString()+“ radius=”+radius; } } public class testFinalize { public static void main(String args[ ]){ point c1,c2;c1=new circle(1,1,1);c2=new circle(2,2,2);c1=null;c2=null;System.gc(); } } 4.11 static static修飾變量（與C中的不同）； static修飾方法（與C中的不同）； 4.11.1 static變量 static變量是指這樣的成員變量：不管在程序運行中生成多少個該類的對象，它們都共享該變量。 即使沒有創(chuàng)建對象，該變量仍然存在。因此，static變量又稱為類變量。定義格式為：static type variableName; static變量和一般的實例變量不同，在構(gòu)造方法中不能對它進行初始化。例如： class point{ // 程序4-14 static int count;int x, y;static{ // 靜態(tài)初始化塊 } } count=0;System.out.println(“static variable is initialized!”); point(int a, int b){ count++;x=a; y=b; System.out.println(“Call point constructor!”);} public class testStaticVariable { public static void main(String args[ ]){ point c1=new point(0,0); System.out.println(“There are ”+ } 4.11.2 static方法 (可舉例說明Math類的PI和sqrt等，為什么要用靜態(tài)變量。)static方法是類中的成員方法，它屬于整個類，即使不創(chuàng)建任何對象，也可使用靜態(tài)方法。調(diào)用靜態(tài)方法格式：類名.方法名（參數(shù)）； 在子類中不能覆蓋父類中定義的靜態(tài)方法。 靜態(tài)方法中只能出現(xiàn)靜態(tài)變量和其它靜態(tài)方法。并且還不能使用this和super。例如： class point{ // 程序4-15 static int count; int x, y; static{ count=0;System.out.println(“static variable is initialized!”); // 定義靜態(tài)變量 } point.count +“ points”); } point(int a, int b){ count++;x=a;y=b; System.out.println(“Call point constructor!”); } static int getCount(){ // 靜態(tài)方法 return count; } } public class testStaticMethod { public static void main(String args[ ]){ } point c1=new point(0,0);point c2=new point(1,1); System.out.println(“There are ”+ point.getCount()+“ points”);} 4.12 關鍵字final 在實例變量、局部變量和方法的形參定義之前加上final，那么這個變量值只能被引用，而不能修改。 final修飾的局部變量和實例變量必須給出初值，因為它修飾的變量代表一個常量。例如： class Base{ // 程序4-16 final int x=1; // 形式1：修飾實例變量 } public class finalVariables{ public static void main(String [ ] args){ final int var=100;// 形式3：修飾局部變量 } Base obj=new Base(); obj.print(var);void print(final int y){ // 形式2：修飾參數(shù) // y=0; // 錯誤 } System.out.println(x+y); } 在方法定義前加上final，該方法就不能被子類覆蓋，成為終極方法 ； 包含終極方法的類仍然可以被子類繼承，子類雖然不能覆蓋父類中的終極方法，但可以重載該方法。例如： class Base{ final int x=1; } class Derived extends Base { void print(){ // 重載了父類中的print方法 } System.out.println(x);final void print(int y){ } // 父類中的final方法 System.out.println(x+y);} 4.12.3 final類 在一個類定義前加上final，意味著這個類就不能被其它類繼承，成為終極類。 系統(tǒng)類基本上都是final類，如String類。 將class定義為final是為了杜絕繼承，類中的方法自然都變成了終極方法。例如： final class Base{ // 聲明為final類 final int x=1; void print(final int y){ System.out.println(x+y); } } // 錯誤：不能繼承final 修飾的Base類 class Derived extends Base { } 4.13 組合與繼承 面向?qū)ο笾械能浖赜帽憩F(xiàn)為兩種形式：繼承和對象組合。 設計這類程序的關鍵是構(gòu)造方法：子類構(gòu)造方法調(diào)用父類構(gòu)造、成員對象的初始化。class date{ // 程序4-17 int year, mon,day; date(int y, int m, int d){ year=y; mon=(m>0 && m<13)?m:1;day=checkday(d); } int checkday(int d){ int daydisp[ ]={0,31,28,31,30,31,30,31,31,30,31,30,31}; if(d>0 && d<=daydisp[mon]) return d; if(mon==2 && d==29 &&(year%400==0 || year%4==0&& year%100!=0)) return d;return 1; } String tostring(){ return year+“/”+mon+“/”+day;} } class employee{ // 雇員類 long id;date birthday; 例如： employee(long no, int year, int mon, int day){ id=no; // 設置組合對象 } String tostring(){ return id+“ , ”+birthday.tostring();} birthday=new date(year,mon,day);} class manager extends employee { // 經(jīng)理類 double basePay; String tostring(){ return basePay+“ , ”+super.tostring();} } public class compositionAndInherence { } public static void main(String [ ] args){ manager boss; } boss=new manager(1001,1971,11,5);System.out.println(boss.tostring()); manager(long no, int y, int m, int d){ super(no,y,m,d); // 調(diào)用父類構(gòu)造函數(shù) } basePay=1000; 4.14 抽象類和抽象方法 抽象方法：僅有方法特征，但沒有代碼； 抽象類：包含抽象方法的類。 抽象類的作用：提供一種適當?shù)某悾宇愅ㄟ^繼承實現(xiàn)父類中的抽象方法。 抽象類不能用final修飾。 抽象類體現(xiàn)了多態(tài)性，通過繼承可以從抽象類派生出具有相似操作的子類。例如： abstract instrument abstract void play()繼承 wind void play()繼承 繼承 stringed void play()percussion void play()繼承 繼承 woodwind void play()brass void play() // 程序4-18 abstract class instrument{ abstract void play();} // wind不是抽象類 class wind extends instrument{ void play(){ System.out.println(“wind play!”);} } // percussion也不是抽象類 class percussion extends instrument{ void play(){ System.out.println(“percussion play!”);} } // stringed也不是抽象類 class stringed extends instrument{ void play(){ System.out.println(“stringed play!”);} } class woodWind extends wind{ // 覆蓋父類中的play方法 void play(){System.out.println(“woodWind play!”);} } class brass extends wind{ // 覆蓋了父類中的play方法 void play(){ System.out.println(“brass play!”);} } public class music { static void tuneAll(instrument e[ ]){ } for(int i=0;i e[i].play(); // 抽象方法 public static void main(String [ ] args){ instrument orchestra[ ] = new instrument[5];int i=0; orchestra[i++]=new wind();orchestra[i++]=new percussion();orchestra[i++]=new stringed();orchestra[i++]=new woodWind();orchestra[i++]=new brass();tuneAll(orchestra); } } 程序運行結(jié)果： wind play!percussion play!stringed play!woodWind play!brass play! 4.15 對象的類型轉(zhuǎn)換 4.15.1 向上類型轉(zhuǎn)換 從子類向父類轉(zhuǎn)換，在繼承圖中是向上移動，通常稱為向上類型轉(zhuǎn)換。 類型向上轉(zhuǎn)換是安全的，因為這是從特殊類型到通用類型的轉(zhuǎn)換。 進行向上類型轉(zhuǎn)換時，出現(xiàn)的唯一問題是可能丟失子類中定義的方法和變量。例如： // 程序4-19 class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} int getX(){ return x;} } class circle extends point{ int radius;circle(int r, int x, int y){ super(x, y);radius=r;} double area(){ return Math.PI*radius*radius; } } public class testUpCasting { } public static void main(String [ ] args){ circle c=new circle(1,1,1);point p=c;// 注意：p和c的類型不同 } System.out.println(p.getX());4.15.2 向下類型轉(zhuǎn)換 從父類向子類轉(zhuǎn)換，在繼承圖中是向下移動，稱為向下類型轉(zhuǎn)換。 類型向下轉(zhuǎn)換是不安全的，因為這是從一般類型到特殊類型的轉(zhuǎn)換。例如： public static void main(String [ ] args){ } 4.16 訪問權(quán)限限制 Java提供的訪問權(quán)限修飾符有四個，即public、private、protected和友元； 修飾符要置于每個類成員（實例變量和成員方法）的定義之前，且僅能控制它所修飾的那個成員。 4.16.1 友員 缺省修飾符的情況就是友員。友員修飾符意味著同一個目錄（包）中的所有類都可以訪問這種類型的成員。 friendly不屬于Java關鍵字，是C++的一個關鍵字。 例如： public class Base{ // 該類位于Base.java文件中 int friend_data=1;// 友員數(shù)據(jù)成員 } // 該類位于Derived.java文件中 public class Derived extends Base{ Base p=new Base(); // 訪問Base類中的friend_data } 4.16.2 public 成員 不管兩個類是否位于同一個目錄中，一個類總可以訪問另一個類的public成員。 public還可以用于修飾主類，文件名必須與主類名一致。除此之外，其它3個修飾符都不能用于修飾類，只能修飾成員。例如： public class Base{ public int friend_data=1;// public成員 } void dataUse(){ System.out.println(“data=”+p.friend_data); } point p=new point(1,1);circle c;c=p; //注意：此處編譯時出錯 c=(circle)p;//注意：此處運行時出錯 System.out.println(c.area()); public class Derived extends Base{ public Base p=new Base(); public void dataUse(){ } 4.16.3 private成員 private成員的特性：除了其所在類能夠訪問該成員以外，其它類都不能訪問它。 在多人合作開發(fā)一個系統(tǒng)的過程中，private可以讓你自由使用自己定義的成員，無須擔心與其他人寫的類相沖突。例如： // 程序4-20 class Base{ private Base(){ } public class testPrivate { public static void main(String args[ ]){ // Base p=new Base(); // 編譯有錯 } } Base p = Base.makeBase();} // 注意 } System.out.println(“data=”+p.friend_data);} static Base makeBase(){ return new Base(); 4.16.4 protected成員 protected與繼承有關，這種類型的成員可以被子類訪問。 同一個包內(nèi)的非子類，也可以訪問這種類型的成員。即：protected天生就具有友元權(quán)限，例如： // 程序4-21 class Base{ // 該類位于Base.java文件中 int friend_data=1; // 友元成員 public int public_data=2; // public成員 private int private_data=3;// private成員 protected int protected_data=4;// protected成員 } class Derived extends Base{ // Derived.java文件 Base a=new Base();void dataUse(){ } System.out.println(a.friend_data);System.out.println(a.public_data);// System.out.println(a.private_data);System.out.println(a.protected_data);} // 將主類存放在testData.java文件中 public class testData { public static void main(String args[ ]){ } Derived d=new Derived();d.dataUse(); } 訪問權(quán)限總結(jié) 課堂練習： 1、定義一個Student類： 該類的功能有：可以保存、修改和獲取學生的姓名、學號等。可以設置學生的英語成績、數(shù)學成績、Java成績，并能計算平均分、最高分和最低分。 2、以下代碼定義了一個類，請指出其中三條不合法的代碼行（行號參見注釋）。 class Test22{ //1 //7 } static float fac1(boolean f){ return f?u:v;} //8 float fac2(boolean f){ return f?u:v;} //9 float u; //2 static float v; //3 static void setUV(boolean f){ //4 u=fac1(f); //5 v=fac2(!f); //6 } 課外練習（作業(yè)）： P87 1、3、4、6 第5章 接口和包 教學目的要求 ? 掌握接口的定義和使用 ? 了解接口與抽象類的異同點 ? 掌握包的定義和使用 主要內(nèi)容 ? 接口的定義和使用 ? 包的定義和使用 重點內(nèi)容 ? 接口的定義和使用 ? 包的定義和使用 難點內(nèi)容 無 1課時 課時分配 教學方法 講授法、演示法 講授內(nèi)容提要 5.1 接口 引入接口的原因：在程序設計中經(jīng)常遇到這樣一個問題：有些類互不相關，但卻具有相似的方法。并且這些方法在各個類中的實現(xiàn)互不相同。我們不能為這些類定義一個共同的父類，但又希望在程序中體現(xiàn)出它們共同的接口。 5.1.1 接口的定義和應用 接口是一系列常量和空方法的集合，它提供了多個類共同的方法，但不限制每個類如何實現(xiàn)這些方法。 Java允許一個類同時實現(xiàn)多個接口，相當于實現(xiàn)多繼承的功能。聲明一個接口的語法格式： [public] interface interfaceName [extends super-interface-List]{ type ConstantName=value; type MethodName(Parameter lists);} 例如： interface Sortable{ // 定義一個接口 int Compare(Sortable s);} 接口中不能聲明任何變量和構(gòu)造方法。 如果一個類實現(xiàn)多個接口，應該在接口名之間用逗號隔開。 當一個類實現(xiàn)接口時，必須實現(xiàn)接口中給出的空方法，若實現(xiàn)接口的類是一個抽象類，可以把實現(xiàn)接口的任務交給子類去實現(xiàn)。例如： // 程序5-1 interface Sortable{ // 定義一個接口 int Compare(Sortable s);} class Sort{ // 定義一個排序類，僅有一個靜態(tài)的方法 public static void SelectSort(Sortable a[ ]){ int i, j, k;Sortable temp; for(i=0;i // 選擇排序 k=i; for(j=i+1;j if(a[k].Compare(a[j])<0)k=j; temp=a[i];a[i]=a[k];a[k]=temp;} } } class Student implements Sortable{ // 定義一個學生類 private int score; Student(int x){score=x;} // 實現(xiàn)接口Sortable中的方法 public int Compare(Sortable s){ Student st=(Student)s; // 類型強制轉(zhuǎn)換 return score-st.score;} public String toString(){ return “score=”+score;} } class Rectangle implements Sortable{ // 矩形類也實現(xiàn)了接口 } public class interfaceTest { public static void main(String args[ ]){ Student stud[ ]=new Student[20];int i;private int length,width; Rectangle(int x,int y){ length=x;width=y;} int area(){return length*width;} public int Compare(Sortable s){ // 實現(xiàn)接口 } public String toString(){ return “area=”+area();} Rectangle rec=(Rectangle)s; // 類型強制轉(zhuǎn)換 return area()-rec.area(); for(i=0;i stud[i]=new Student（(int)(Math.random()*100));Sort.SelectSort(stud); // 排序 for(i=0;i System.out.println(stud[i].toString());Rectangle R[ ]=new Rectangle[10];for(i=0;i R[i]=newRectangle（(int)(Math.random()*10)，(int)(Math.random()*10));Sort.SelectSort(R); // 排序 for(i=0;i System.out.println(R[i].toString()); } } 接口中定義的變量實際上是常量，必須給出它們的初始值，實現(xiàn)接口的類可以自由引用這些常量。例如： // 程序5-2的部分 interface constant { int int int int EXCELLENT=5; GOOD=4; PASS=3; FAIL=2;} 在類中實現(xiàn)接口中方法時，方法的特征必須和接口中聲明的方法特征保持一致； 實現(xiàn)方法時必須在方法前加上public； 若一個類沒有對接口中的方法具體實現(xiàn)，那么必須將該類聲明為abstract類。例如： interface inter { // 接口 } void methodA(); abstract class Derived1 implements inter { // 此處不需要寫出methodA()的原型 } class Derived2 extends Derived1{ public void methodA(){ // 實現(xiàn)方法 } } System.out.println(“Hi,methodA”);5.1.2 接口和抽象類的異同點 接口和抽象類的相同點： (1)都有空的方法，都必須在子類中實現(xiàn)這些方法。 (2)都不能用new關鍵字來創(chuàng)建這兩種類型的對象。 (3)都可以具有繼承關系。 (4)接口和類一樣可以具有public屬性。接口和抽象類的不同點： (1)在抽象類中，空的方法必須加abstract關鍵字，而在接口中不需要。 (2)在抽象類中，除空的方法外，可以定義實例變量和非空的方法，而在接口中，只能定義常量和空的方法。 (3)接口允許多繼承，類僅支持單繼承。 5.2 包 在Java中可以將自己寫的類，按一定的方法歸屬于不同的子目錄中（包）。 在缺省情況下，Java將所有的類歸屬一個缺省包中。在不同的包中可以有同名的類存在。 Java中的包與C++中的名字空間相似。 5.2.1 package語句 package語句告訴編譯器當前類屬于哪個包。如果沒有package語句，類就存放在無名的缺省包中（即當前目錄中）。 引進包的概念主要是為了名字沖突。 格式: package pkgl[．pkg2[．pkg3]]； 5.2.2 import語句 import語句位于package語句之后，類的定義之前;格式：import package1[.package2].(class-name | *)； 采用*號不影響程序的運行性能，但會影響編譯速度。指明具體類比引入整個包更為合理。5.2.3 包應用舉例 package Base; // 將該類存放在d:myjavaBase包中 public class Base { int friend_data=1;// 友元成員 public int public_data=2;// public成員 private int private_data=3;// private成員 protected int protected_data=4;// protected成員 } package Derived; // 將Base類存放在Derived包中 import Base.*; // 需要使用Base包中的類 public class Derived extends Base{ Base a=new Base(); // 為了讓testData類能調(diào)用該方法，修改為public // 不能訪問 public void dataUse(){ // System.out.println(a.friend_data); System.out.println(a.public_data); // System.out.println(a.private_data); // 不能訪問 // System.out.println(a.protected_data);// 不能訪問 } } // testData.java文件的內(nèi)容如下： import Derived.*; //需要使用Derived包中的類 // 該類位于工作目錄，不需要package語句 public class testData { public static void main(String args[ ]){ } } Derived d=new Derived(); d.dataUse(); 課堂練習： 課外練習（作業(yè)）： P108 3~6 第6章 字符串處理 教學目的要求 ? 掌握字符串的分類； ? 掌握內(nèi)容不可改變的字符串類String； ? 掌握字符串常量； ? 掌握內(nèi)容可以改變的字符串類StringBuffer； ? 掌握字符串應用。 主要內(nèi)容 ? 字符串的分類； ? ? ? ? 內(nèi)容不可改變的字符串類String； 字符串常量； 內(nèi)容可以改變的字符串類StringBuffer； 字符串應用。 重點內(nèi)容 ? 掌握內(nèi)容不可改變的字符串類String； ? 掌握內(nèi)容可以改變的字符串類StringBuffer； ? 掌握字符串應用。 難點內(nèi)容 String和StringBuffer的區(qū)別和聯(lián)系 課時分配 2課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 6.1 字符串的分類 java.lang包中定義了 String和StringBuffer兩個類； 在運行中值不會改變的字符串，用String類存儲；值會改變的字符串用StringBuffer類來存儲。 兩個類都有final修飾，這樣可以優(yōu)化字符串的操作。 6.2 String類 String類的定義原型 ： public final class java.lang.String extends java.lang.Object { … } 6.2.1 字符串常量 字符串常量屬于String類型;相同的字符串常量屬于同一個對象，占用同一塊空間，例如: // 程序6-1 public class TestConstString{ public static void main(String args[ ]){ } } String str1=“Hello”, str2=“Hello”; System.out.println(str1==str2);System.out.println(“Java”==“Java”);6.2.2 創(chuàng)建String類對象 用new運算符，并調(diào)用構(gòu)造函數(shù)創(chuàng)建這種類型的對象，常見構(gòu)造函數(shù)如下： 1.public String()采用該構(gòu)造函數(shù)創(chuàng)建一個不含字符的空對象。例如： String str =new String(); 2.public String(char value[ ]) 將字符數(shù)組的內(nèi)容轉(zhuǎn)換為字符串，并賦予新建的對象。例如： char a[ ]={'J','a','v','a'};String str=new String(a);3.public String(char value[ ], int offset, int count) 例如：char a[ ]={'J','a','v','a'}; String str=new String(a,1,2); // 字符串str的內(nèi)容是“av” 4.public String(String value) 采用value對象的值構(gòu)造一個新的string對象。 例如： String str1=“Java”;String str2=new String(“Java”); System.out.println(str2); System.out.println(str1==str2); 5.public String(StringBuffer Buffer)注意采用字符串常量初始化一個String引用的問題。例如： String str = “abc”;相當于： char data[ ] = {'a', 'b', 'c'};String str = new String(data);應用舉例，注意程序6-2的輸出結(jié)果： public class TestString{ // 程序6-2 public static void main(String args[ ]){ String s1=“Java”, s2=“Java”;String s3=new String(s1); System.out.println(“ s1==s2 is ”+(s1==s2));System.out.println(“ s1==s3 is ”+(s1==s3));s1=“ABC”;s2=“DEFG”;System.out.println(“ s1==s2 is ”+(s1==s2));s1=s2; System.out.println(“ s1==s2 is ”+(s1==s2));} } 6.2.3 String類常用方法 1.public int length(): 求串長。例如： String str=“Java” ； System.out.println(str.length());2.public char charAt(int index) 提取指定位置上的字符。 3.public int compareTo(String anotherString) 對字符串內(nèi)容按字典序進行大小比較。例如： public class SortStringArrary{ // 程序6-3 public static void main(String args[ ]){ String str,s[ ]={“Computer”,“CHINA”,“world”,“U.S.A”}; int i,j,k; System.out.print(“排序之前：”);for(i=0;i System.out.print(“t”+s[i]);for(i=0;i for(k=i,j=i+1;j if(s[k].compareTo(s[j])>0) k=j; str=s[i]; s[i]=s[k]; s[k]=str;// 注意該行的含義 } System.out.print(“n排序之后：”);for(i=0;i System.out.print(“t”+s[i]); } } 4.char[ ] toCharArray() 將String對象轉(zhuǎn)換到一個字符數(shù)組中，例如： String s=“Hello,Java!”; char a[ ]; a=s.toCharArray(); for(int i=6;i System.out.print(a[i]);5.public boolean equals(String anString) 比較兩個字符串對象的內(nèi)容是否相等。 6.public boolean equalsIgnoreCase(String anotherString) 以忽略大小寫方式，比較兩個字符串對象的內(nèi)容是否相等。 注意：equals()方法與“==” 之間的區(qū)別。例如： public class ConfuseQuestion{ // 程序6-5 public static void main(String args[ ]){ String s1=“java”; String s2=new String(s1); String s3=s2; } } System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s2==s3);System.out.println(s2.equals(s3));7.public int indexOf(int ch / String str) 在字符串中搜索字符或子串，返回字符或子串在String對象中從左邊起首次出現(xiàn)的位置。如果沒有出現(xiàn)，返回-1。 8.public String substring(int begin, int end) 提取string對象中從begin開始，到end-1結(jié)束的子串，返回提取的子串。 9.public String concat(String str)將str對象接到調(diào)用對象的后面，返回新串。例如： String s1=“Hello ” , s2=“Java” , s3;s3=s1.concat(s2); System.out.println(s3);注意：如果參數(shù)str為空（null），則concat方法不創(chuàng)建新串，而僅僅返回當前串，10.public String replace(char oldChar, char newChar) 將String對象中所有的oldChar字符替換為newChar，返回替換后的新串。例如： String path=“d:/myjava/documents”; System.out.println(path.replace('/' , '')); public String toString() 返回當前字符串對象本身。 12.public static String valueOf(各種類型 f) 將各種數(shù)據(jù)類型轉(zhuǎn)換成一個相應的字符串表示，該方法是一個static方法。 程序6-6演示了valueOf()方法的應用。 程序6-7自學。 public class TestValueOf{ // 程序6-6 public static void main(String args[ ]){ char a[ ]={'A','B','C','D','E','F'}; int i=123456;float f=3.14159f;boolean b=true;Object o=null;System.out.println(String.valueOf(a));System.out.println(String.valueOf(a,2,3));System.out.println(String.valueOf(i));System.out.println(String.valueOf(f));System.out.println(String.valueOf(b)); System.out.println(String.valueOf(o));} } 6.2.4 Java應用程序的命令行參數(shù) 應用程序可以通過main方法的String數(shù)組，訪問由解釋器傳遞的命令行參數(shù)。例如： public class ShowMainArguments{ //程序6-8 public static void main(String args[ ]){ for(int i = 0;i < args.length;i++) System.out.println(args[ i ]); } } 6.3 StringBuffer類 StringBuffer類對象是一個內(nèi)容可以改變的字符串。可以減少由于少量字符的插人而引起的空間分配問題。 StringBuffer類的原型： public final class java.lang.StringBuffer extends java.lang.Object { … } StringBuffer類對象有一塊緩沖區(qū)，字符串被存放在緩沖區(qū)中，緩沖區(qū)的大小可以隨程序的需要進行調(diào)整。緩沖區(qū)的大小稱為對象的容量。 當修改對象的內(nèi)容時，只要StringBuffer對象包含的字符個數(shù)沒有超出容量，就不會分配新的空間，而直接在原空間內(nèi)進行修改。若字符的個數(shù)超出了容量，該對象會自動調(diào)整其容量，從而適應新的存儲。 6.3.1 創(chuàng)建StringBuffer類對象 StringBuffer類的構(gòu)造函數(shù)有三種方式： 1.public StringBuffer()創(chuàng)建一個內(nèi)容為空的StringBuffer對象，容量為16。 例如：StringBuffer s=new StringBuffer();2.public StringBuffer(int length)初始內(nèi)容為空，容量為length指定的大小。注意：length應大于等于0，不能為負數(shù)，否則會產(chǎn)生異常。例如： StringBuffer s2=new StringBuffer(2);3.public StringBuffer(String str) 初始內(nèi)容和參數(shù)str的內(nèi)容相同，容量為參數(shù)str的長度加上16。例如： String s1=“Java”; StringBuffer s2=new StringBuffer(s1);則s2的容量是20，內(nèi)容是“Java”。 6.3.2 StringBuffer類常用方法 1.public int length() 返回字符串的長度 2.public int capacity() 返回緩沖區(qū)大小 3.public void setLength(int newLength) 指定對象的長度，將對象的內(nèi)容進行裁減。如果參數(shù)小于對象的長度，則將對象截斷；如果參數(shù)大于等于對象的長度，則填充空字符('u0')擴充新增加的部分。 4.public void ensureCapacity(int NewCapacity) 設定對象的緩沖區(qū)的大小，若參數(shù) 小于對象的容量，則新的設置將不起作用，也就是說容量只能擴大而不能縮小。 程序6-9演示了這幾個方法的具體應用。 public class TestCapacity{ // 程序6-9 public static void main(String args[ ]){ String s=“Java”; StringBuffer str=new StringBuffer(s);System.out.println(“Length=”+str.length());System.out.println(“Capacity=”+str.capacity());str.setLength(8); // 設置長度為8 str.ensureCapacity(80);// 設置容量為80 System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); str.setLength(3); str.ensureCapacity(20);System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); } } 5.public void setCharAt(int index, char ch) 將參數(shù)index指定位置上的字符，設置成參數(shù)ch 指定的字符。例如： StringBuffer str=new StringBuffer(“Hello,Java”); str.setCharAt(3,'L'); 則str的內(nèi)容變成了“HelLo,Java” 6.public StringBuffer append(多種數(shù)據(jù)類型) 將其它類型的數(shù)據(jù)添加到StringBuffer對象的尾部，返回修改后的StringBuffer對象。 例如：StringBuffer s1,s2=new StringBuffer(); s1=s2;// s1和s2代表同一個對象 s2.append(3.14).append(' ').append(“Java”); System.out.println(s1==s2); // 輸出true System.out.println(s1); // 輸出3.14 Java 7.public String toString() 該方法把StringBuffer對象的內(nèi)容復制到一個新的String類對象中，返回這個新的String類對象。例如程序6-10。 public class BufferToString{ // 程序6-10 public static void main(String args[ ]){ String s1;StringBuffer s2=new StringBuffer(“Hello ”);s1=s2.append(“Java!”).toString();System.out.println(“s1=”+s1+“"+”s2=“+s2); } } 8.public StringBuffer insert(int offset, 多種類型 b)該方法是將一個其它類型的對象b插入到offset指定的位置。例如： StringBuffer str=new StringBuffer(” Java!“); // 將字符串”Hello“插入到下標為0的位置 str.insert(0,”Hello“); System.out.println(”str= “+str);輸出結(jié)果為： str= Hello Java! 6.4 略 應用舉例 課堂練習： 無 課外練習（作業(yè)）： P119 2、3、4 第7章 異常處理 教學目的要求 ? 了解異常的層次結(jié)構(gòu)； ? 掌握異常處理語句； ? 了解自定義異常； ? 了解異常處理中常用的調(diào)試方法。主要內(nèi)容 ? ? ? ? 異常的層次結(jié)構(gòu)； 異常處理語句； 自定義異常； 異常處理中常用的調(diào)試方法。 重點內(nèi)容 ? 異常處理語句； 難點內(nèi)容 無 課時分配 1課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 7.1 異常的層次結(jié)構(gòu) Throwable是異常類的根節(jié)點，定義在java.lang包，它的子類也定義在該包中； Error代表系統(tǒng)錯誤類，由系統(tǒng)直接處理； Exception類及其子類是在程序中可捕捉到的異常。見圖7.1 Throwable Error achineError … AW TError LinkageError VirtualM RuntimeException ArithmeticException ArrayIndexO utO fBoundsException … Interrupted Exception AWTException IOException Exception FileNotFoundException… EOFException 1.java.lang.ArithmeticException 0作除數(shù)（包括模），將產(chǎn)生這類異常。例如：int x=0 , y; y=100/x; 2.java.lang.ArrayIndexOutOfBoundsException 例如：int a[ ]=new int[10]; a[10]=0; 3.java.lang.ArrayStoreException 例如：int a[ ]=new int[10]; boolean b[ ]=new boolean[10]; System.arraycopy(a,0,b,3,6);//有異常 4.java.lang.ClassCastException 例如： Object obj=new Object(); int a[ ]=(int[ ])(obj); 5.java.lang.IndexOutOfBoundsException 例如：char ch=”ABC“.charAt(99); 注意: 2 是5的子類。 6.java.lang.NegativeArraySizeException 例如： int a[ ]=new int[-10]; 7.java.lang.NullPointerException 例如：int a[ ]=null; System.out.print(a.length);7.2 異常處理語句 缺省的異常處理的情況，例如： public class DefaultException{ // 程序7-1 public static void main(String args[ ]){ int a,b=0; a=2/b; // 此處有異常 System.out.println(“a=”+a);// 不運行此行 } } 異常處理語句有try、catch、finally、throw和throws。異常處理的形式為： try{ 程序執(zhí)行體 }catch(異常類型1 異常對象1){ 異常處理程序體1 }catch(異常類型2 異常對象2){ 異常處理程序體2 }finally { 異常處理結(jié)束前的執(zhí)行程序體 } 7.2.1 try和catch語句 try語句指明可能產(chǎn)生異常的代碼段;catch語句在try語句之后，用于捕捉異常，一個try語句可以有多個catch語句與之匹配。異常處理以后，程序從try語句代碼段后繼續(xù)執(zhí)行。例如：程序7-2。public class TryCatchTest{ // 程序7-2 public static void main(String args[ ]){ int a=99,b=0,c; try{ System.out.println(”產(chǎn)生異常之前“);c=a/b; // 該行有異常 System.out.println(”產(chǎn)生異常之后“);}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”處理下標越界異常“);}catch(ArithmeticException e){ System.out.println(”處理算術(shù)異常“);} System.out.println(”異常處理結(jié)束“); } } 注意：用catch語句捕捉異常時，若找不到相匹配的catch語句，將執(zhí)行缺省的異常處理。例如： int a=99,b=0,c; try{ c=a/b;//產(chǎn)生的異常和捕捉的異常類型不一致 }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”處理異常“); } 注意：當有多個catch語句時，系統(tǒng)依照先后順序逐個檢查。例如： try{ c=a/b; }catch(ArithmeticException e){ System.out.println(”Divided by zero“);}catch(RuntimeException e){ System.out.println(”Divided by zero“);} 7.2.2 finally語句 無論是否產(chǎn)生異常，finally語句指明的代碼一定被執(zhí)行。例如： public class testFinally{ // 程序7-3 public static void main(String args[ ]){ int a,b=0; for(int i=0;i<=3;i++){ System.out.println(”Test No: “+(i+1));try{ switch(i){ } case 0: a=3/b; break;case 1: int c[ ]=new int[10]; c[10]=0; break;case 2: char ch=”ABC“.charAt(99); break;case 3: return;}catch(ArithmeticException e){ System.out.println(“零作除數(shù)！”); }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”數(shù)組下標越界！“);}catch(IndexOutOfBoundsException e){ System.out.println(”下標越界！“);}finally{ System.out.println(”在finally塊中！“); } } 7.2.3 throw語句 throw語句用于指出當前行有異常，當程序執(zhí)行到throw語句時，流程就轉(zhuǎn)到相匹配的異常處理語句，所在的方法也不再返回值。 throw語句可以將異常對象提交給調(diào)用者，以進行再次處理。例如：程序7-4。public class ThrowException{ // 程序7-4 public static void Test(){ try{ int c[ ]=new int[10];c[10]=0;}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”t 數(shù)組下標越界！“); } } throw e; // 異常拋出點 //System.out.println(“t產(chǎn)生異常后!”); 該行無法通過編譯 } } public static void main(String args[ ]){ try{ Test();}catch(IndexOutOfBoundsException e){ System.out.println(”t 下標越界！“);}finally{ System.out.println(”t 在finally塊中！“);} } } 7.2.4 throws語句 throws語句指明方法中可能要產(chǎn)生的異常類型，由調(diào)用者進行異常處理。例如： import java.io.*; // 程序7-6 public class testThrows { public static String readString()throws IOException{ int ch;String r=”“;boolean done=false; while(!done){ ch=System.in.read(); } if(ch<0 || ch==0xd) done=true;else r = r +(char)ch; return r; } public static void main(String args[ ]){ String str; try{ str=readString();}catch(IOException e){ System.out.println(”產(chǎn)生了輸出/輸出異常“); return;} System.out.println(”整數(shù)是："+Integer.parseInt(str)); } } 建議：在多人合作寫程序時，一個方法中產(chǎn)生的異常，最好在該方法中進行處理，不要將異常傳播給其他人處理。 7.3 自定義異常類 通過繼承Exception類或它的子類，實現(xiàn)自定義異常類； 對于自定義異常，必須采用throw語句拋出異常，這種類型的異常不會自行產(chǎn)生。總體上分為兩步： 第1步：定義異常類。例如： class userException extends Exception{ int n=0; // 計數(shù)器 Java程序設計 第一講 緒論 一、安裝netbean系統(tǒng) 二、hello world 典型程序結(jié)構(gòu)中各部分的說明： /* * To change this template, choose Tools | Templates * and open the template in the editor.*/ package test1; //@author Jie public class Test1 { public static void main(String[] args){ System.out.println(“Hello World!”); } } 1、注釋語句 2、類定義的包：package 3、public class Test1，定義類，類名稱是Test1，屬性為public 4、public static void main(String[] args)，main函數(shù) 5、main函數(shù)的函數(shù)體{ System.out.println(“Hello World!”); } 三、Java程序設計語言的基本內(nèi)容： 數(shù)據(jù)類型 運算符&表達式 3 程序控制語句 4 數(shù)組 5 類 6 對象 7 繼承 8 接口 9 包 APPLET 11 異常處理 12 線程 13 字符串 14 GUI 15 輸入輸出系統(tǒng) 我們的課堂教學內(nèi)容：時間17周，包括17次課堂教學，17次實驗室上機。 四、幾個案例： 1、計算根號2； 2、顯示1-100 3、從1加到100 4、打印一個“*”組成的10*10的矩形 5、求N!，遞歸算法 6、GUI的例子，在GUI界面下輸入和顯示（this.jLabel1.setText(this.jTextField1.getText());） 7、演示幾個復雜一點例子 五、Java語言中保留的關鍵字： Java語言一共使用了48個保留關鍵字，他們主要可以 分為如下幾類。 1.訪問控制 private , protected , public.2.類、方法和變量修飾符 abstract , class , extends , final , implements , interface, native（用于與其他語言的接口）, new , static strictfp：java 語言采用固定的位數(shù)來存儲浮點型數(shù)據(jù)，但是有些處理器使用更高位的浮點寄存器，這些寄存器增加了中間過程的計算精度。例如double類型數(shù)據(jù)jvm采用64為存儲，二有些處理器使用80位的浮點寄存器來保存中間數(shù)據(jù)。例如：double w = x*y/z;很多處理器計算x*y后將中間結(jié)果存儲在80位的寄存器中，再除以z并將結(jié)果截斷為64位；但是這個結(jié)果可能會與始終在64位機器上計算的結(jié)果不一致，如果將所有的中間結(jié)果都截斷，可能會導致溢出，而截斷操作同樣需要時間，計算速度比較慢。 因此JVM默認允許中間結(jié)果精度擴展。但是在使用關鍵字strictfp標記的方法，必須使用嚴格的浮點計算。使用strictfp標記的類中所有的方法都必須嚴格按照浮點計算。 synchronized：多線程同步訪問控制 transient：transient 關鍵字表示在Serializable 的時候不保存該值 volatile：Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內(nèi)存中重讀該成員變量的值。而且，當成員變量發(fā)生變化時，強迫線程將變化值回寫到共享內(nèi)存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。 3.程序控制語句 break, continue, return, do, while, if, else, for, instanceof, switch, case,default, 4.錯誤處理 catch 捕獲, finally 最后, throw 投試, throws 投試, try 嘗試 5.包相關 import 輸入, package 包.6.基本類型 boolean 布爾型, byte 字節(jié)型, char 字符型, double 雙精度, float 浮點, int 整型, long 長整型, short 短整型 7.變量引用 super 特殊, this 這個, void 無值 除了這48個關鍵字以外,還有3個語法保留字： null 空, true 真, false 假.六、如何學習一門程序設計語言 1、理解什么是程序設計語言 2、練習、練習、再練習 第二講 數(shù)據(jù)類型、運算符與表達式 一、Java語言中的數(shù)據(jù)類型 數(shù)據(jù)類型 大小 范圍 默認值 byte(字節(jié)) -12832768 0 int(整型) -2147483648-2147483648 0 long(長整型) -***7808-***7808 0 float(浮點型) 32-3.40292347E+38-3.40292347E+38 0.0f double(雙精度) -1.797693***E+308-1.797693***E+308 0.0d char(字符型) ? u0000-+=!~ +(一元)-(一元) 左?右 * / % 右?左 +(二元)-(二元) 右?左 << >> >>> 右?左 < > <= >= instanceof 右?左 = =!= 右?左 & 右?左 ^ 右?左 | 右?左 && 右?左 || 右?左 ?： 左?右 = *= /= %= += －= <<= >>= >>>= &= ^= |= 左?右 三、實驗課任務 1、熟悉netbeans的工作環(huán)境，自己編寫HELLO WORLD程序 2、輸入并運行測試，至少10個不同運算符號組合的算術(shù)表達式 3、輸入并運行測試，至少5個不同運算符號組合的邏輯表達式 4、聯(lián)系字符串對象的基本用法：聲明賦值對象，顯示對象，兩個字符串連接，截取子串等 第三講 輸入輸出 一、介紹數(shù)據(jù)流的概念 1、流的基本概念 2、字節(jié)流 字節(jié)是8比特，等價于0-255范圍的十進制數(shù)。字節(jié)是計算機中最基本的編碼單位。如字符型是2個字節(jié)，浮點型是4個字節(jié)。 字符流的頂層包括inputstream和outputstream兩個抽象類。可以通過fileinoutstream和fileoutputstream兩個子類對文件進行輸入和輸出。通過datainputstream和dataoutputstream兩個子類處理整數(shù)、浮點數(shù)等數(shù)據(jù)。 3、字符流 字符流是特殊的字節(jié)流，專門用于處理字符數(shù)據(jù)，目前的字符集通常是unicode，16比特，一個字符是兩個字節(jié)。 頂層有兩個抽象類：reader和writer，有兩個最主要的方法：read()，write() 4、預定義流 標準輸入流：in 標準輸出流：out 出錯流：err 舉例： 輸出一串字符，在顯示器上顯示出來 二、文件字節(jié)流 1、文件字節(jié)流的輸入輸出 常用方法： read()，write(ch)案例1：在顯示器上顯示文本文件的內(nèi)容。案例2：復制文件 2、文件字節(jié)流的隨機訪問 常用方法： 1、讀數(shù)據(jù)方法：readInt()readBoolean()readLine() 2、寫數(shù)據(jù)方法：wirteChar()writerDouble() 3、指針控制方法： long getFilePointer();void seek(long pos);int skipBytes(int n)案例：建立一個可讀寫隨機訪問文件，寫入10個浮點數(shù)，然后關閉該文件。再次以讀寫方式打開該文件，修改其中第3個數(shù)據(jù)，然后關閉該文件。再次以只讀方式打開蓋文件，顯示文件內(nèi)容，然后關閉該文件。 三、過濾流 過濾流是對輸入輸出流提供了一種包裝。我們主要介紹一組： DataInputStream DataOutputStream 案例：從鍵盤輸入一些同學的信息，將信息保存到文件中。 四、字符流 五、File類 六、對象的串行化 第四講 程序控制語句 第五講 綜合練習第六講 數(shù)組 第七講 函數(shù)、函數(shù)調(diào)用、遞歸函數(shù) 第八講 綜合練習第九講 類和對象 第十講 繼承、接口和包與異常處理 第十一講 綜合練習第十二講APPLET、GUI 第十三講 線程 第十四講 綜合練習 第十五講 字符串及信息處理的應用 第十七講 綜合練習 課程教案 （理論教學） 課程名稱： Java程序設計 課程類型：（2） 1、必修； 2、選修； 3、其它 授課對象： 專業(yè)（本科）級 班 授課時間： 至 學年第 學期 計劃學時： 學時（其中：理論，實驗：） 任課教師： 所屬學院： 課程管理部門（教研室）： 大理學院教務處 制 課程名稱：Java程序設計 教 材：Java程序設計教程 講 授 人： 專業(yè)技術(shù)職務：講師 學 歷： 研究生 學 位：碩士 講授題目： 所屬章節(jié)： 計劃學時： 教學目的和要求： 教學重點： 教學難點： 教學方法： 使用教具 大理學院課程教案（教學內(nèi)容） 第一章 Java語言簡介 教學目的要求 了解Java的基本特點和用途 掌握如何下載Java SDK軟件包 了解設置Java程序的開發(fā)環(huán)境SDK 如何運行Java程序 了解Java的概貌 主要內(nèi)容 ? Java語言的發(fā)展歷程； ? Java語言的特點； ? Java語言的開發(fā)工具； ? Java應用程序和小程序； ? Java程序的注釋方法； ? 寫Java程序的風格規(guī)范。重點內(nèi)容 ? Java語言的特點； ? Java語言的開發(fā)工具； ? Java應用程序和小程序； 難點內(nèi)容 無 課時分配 1課時 教學方法 講授法、演示法、對比法 講授內(nèi)容提要 1.1 Java語言的發(fā)展簡介 1991年Sun Mircosystem 公司成立了一個Green項目開發(fā)小組，Jame Gosling 為組長； 設計Java 采用虛擬機代碼（Virtual Machine Code），即.class文件，它通過解釋器運行 ； 1995年5月Sun Mircosystem 公司對外正式發(fā)布Java1.0； Java2 用途：適用于各種應用開發(fā)，尤其是網(wǎng)絡應用，網(wǎng)絡服務和嵌入式系統(tǒng)。1.2 Java語言的特點 1．簡單性 2．面向?qū)ο?3．網(wǎng)絡適用性 4．健壯性 5．安全性 6．平臺無關性 7．可移植性 8．解釋型 9．高性能 / 87 ? ? ? ? ? 大理學院課程教案（教學內(nèi)容） 10．多線程 11．動態(tài)性 12．豐富的類庫 13．嵌入瀏覽器運行 1.3 Java類庫的概念 1.4 網(wǎng)絡瀏覽器 1.5 Java開發(fā)工具 NetBeans： 這個集成環(huán)境可以方便地進行程序的編輯、編譯、生成和運行。J2sdk : http:// java.sun.com免費下載;Visual J++ 6.0 / 8.0： VJ++還吸收了VB集成開發(fā)環(huán)境IDE的特征，是一個強有力的Java程序開發(fā)工具。Jcreator Eclipse(MyEclipse)等 1.6 Java程序的分類 基于控制臺的應用程序； 基于瀏覽器運行的小程序applet。 小程序與應用程序的區(qū)別是：小程序必須依賴一個HTML文件和支持Java的網(wǎng)絡瀏覽器。老師演示小程序和applet程序 應用程序舉例(程序1-1)： public class hello { public static void main(String args[ ]){ System.out.println(“Hello Java!”); } } 小程序舉例(程序1-2)： import java.awt.Graphics; // 注意該行的含義 import java.applet.Applet;public class sayhello extends Applet { public void paint(Graphics g){ g.drawString(“Hello Java!”,35,30); } } 小程序?qū)腍TML文件： / 87 大理學院課程教案（教學內(nèi)容） 1.7 1.8 對Java程序的解釋 編寫Java程序的風格要求 課堂練習： 請編寫一個應用程序輸出你自己的學號和姓名 課外練習（作業(yè)）： 下載并安裝J2SDK； 設置系統(tǒng)環(huán)境變量 下載并安裝MyEclipse 熟悉MyEclipse的開發(fā)環(huán)境 第2章 數(shù)據(jù)類型、運算符和表達式 教學目的要求 掌握字符常量和符號表示的常量的概念和應用 掌握整形、浮點型、字符型和布爾型變量的概念和應用 掌握數(shù)據(jù)的概念 理解參數(shù)傳遞方式 學會邏輯運算符、算術(shù)運算符和位運算符的使用方法 主要內(nèi)容 ? 常量：包括字面常量和符號表示的常量； ? 變量：整形、浮點型、字符型和布爾型； ? 數(shù)組：Java的數(shù)組屬于類類型； ? 參數(shù)傳遞方式； ? 運算符：包括邏輯運算符、算術(shù)運算符和位運算符等； 重點內(nèi)容 ? 整形、浮點型、字符型和布爾型變量的概念和應用； ? 符常量和符號表示的常量的概念和應用 難點內(nèi)容 ? 參數(shù)傳遞方式 課時分配 2課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 2.1 常量 整形常量：采用八進制、十進制、十六進制表示，但不能采用二進制表示，和C/C++中的一樣。 浮點常量：采用十進制或科學記數(shù)法表示。在缺省情況下一個浮點數(shù)是double型。布爾常量：true和false，它們不是數(shù)，不能進行算術(shù)運算。字符常量：與C/C++中的表示類似 。字符串常量：Java中字符串常量是對象。2.2 變量 變量的命名原則是：以字母（’a’?’z’和 ’A’?’Z’）、下劃線（‘_’）和‘$’符號開頭的，由字母、數(shù)字（’0’?’9’）、下劃線和‘$’構(gòu)成的一個符號序列。 例如，a，_a，NameOfStudent，$10均是合法變量名，而-a和9a是非法變量名。關鍵字不能用作變 / 87 ? ? ? ? ? 大理學院課程教案（教學內(nèi)容） 量名(見表2-1)注意：Java對變量是區(qū)分大小寫.2.2.1 整形類型的變量 字節(jié)（byte）型，8個位。 短整形(short)，占16個位。整形(int)，占32個位。 長整形(long int)，占64個位。 Java中的整形最值均有符號。例如程序2-1測試最值： public class Test_Int { // 程序2-1 測試整形變量的最值 public static void main(String [ ] args){ System.out.println(Byte.MAX_VALUE); System.out.println(Byte.MIN_VALUE); System.out.println(Short.MAX_VALUE);System.out.println(Short.MIN_VALUE); System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); System.out.println(Long.MAX_VALUE); System.out.println(Long.MIN_VALUE); } } 注意： byte、short、int、long是原子類型，而Byte、Short、Integer和Long分別是四種原子類型對應的類類型。 2.2.2 字符類型變量 Java字符量的長度為16個位，表示范圍是從‘u0000’ 到 ‘uffff’ 即從0 到 65535； Character是char類型對應的類類型 ； 最大值 Character.MAX_VALUE ； 最小值 Character.MIN_VALUE ； 2.2.3 浮點類型變量 分類：float和double。 Float、Double 是對應的類類型 ； Float.MAX_VALUE、Float.MIN_VALUE是最值。Float.POSITIVE_INFINITY 和 Float.NEGATIVE_INFINITY是正/負無限大。2.2.4 布爾類型變量 boolean變量取值：true和false ； true和false不能轉(zhuǎn)換成任何數(shù)值表示，true不是1，false也不是0。2.2.5 原子類型變量的生存空間 一個變量的生存空間是由兩個大括號決定的 范圍。下列寫法在C/C++中是正確的，但在Java中是錯誤的(注意)。{ int x=1;{ / 87 大理學院課程教案（教學內(nèi)容） int x=0;// 錯誤 } } 2.3 變量賦值問題 如果類中定義的原子類型變量，未給出初值，那么它們將有缺省值 ：byte、short、int 和long變量的缺省值是0；char、float、double和boolean變量的缺省值分別是’u0’、0.0f、0.0d和false。 方法內(nèi)定義的局部變量，應當對其賦值，否則無法通過編譯。例如： // 程序2-4 class Test { // 定義一個類 int Value;// 類中的變量未賦值，缺省就是0 } public class Test_Var{ public static void main(String [ ] args){ int x=100; // 必須賦值，否則無法通過編譯 Test obj=new Test();// 對象賦值 System.out.println(obj.Value +“ ”+x); } } 2.4 數(shù)組 Java數(shù)組是系統(tǒng)定義類Array 的子類； 數(shù)組的分類同C/C++：一維和多維。2.4.1 一維數(shù)組 定義數(shù)組的格式 ：int a[ ] ； 或 int[ ] a ；其值是null ； 在定義數(shù)組時不能指定大小。a僅是一個引用，代表一個數(shù)組名，但沒有對應的空間。產(chǎn)生數(shù)組空間的方法有兩種 ： 在定義時直接賦值：int a[ ]={1,2,3}; 通過new分配空間： int a[ ]=new int[10];public class Test_Array{ public static void main(String [ ] args){ int a[ ]={1,2,3}, b[ ]; b= a; for(int i=0;i<3;i++)b[ i ]++; for(int i=0;i<3;i++)System.out.println(a[i]); } } public class Test_Array{ public static void main(String [ ] args){ int a[ ]={1,2,3}, b[ ]; b = new int[6]; System.out.println(“b數(shù)組長度 = ” + b.length); for(int i=0;i System.out.print(b[i]+“ / 87 ”); 大理學院課程教案（教學內(nèi)容） } } 注意：(1)獲得數(shù)組元素的個數(shù)：數(shù)組名.length； (2)一個整形數(shù)組若僅僅采用new分配空間，而沒有對其賦值，那么每個元素的值是0 注意：Java數(shù)組名是一個引用，當將一個數(shù)組名賦值給另一個數(shù)組時，實際上是名字的復制 2.5 Java中的參數(shù)傳遞方式 Java的參數(shù)傳遞的形式有兩種：基本類型按值傳遞，對象類型按引用傳遞； 通過return語句從方法中返回時，基本類型總是以值的方式返回，而對象總是以引用方式返回。例如程序2-8 ： class test{ int x;} public class Test_Paras { static test fun(test o,int y){ o.x=20; y=1; return o;} public static void main(String [ ] args){ test obj1 , obj2; int Val = 3; obj1=new test(); obj1.x=100; obj2=fun(obj1,Val); System.out.println(obj1.x+“ ”+ obj2.x+“ ”+Val); } } 2.6 Java的運算符 主要包括： 算術(shù)運算符、關系運算符、邏輯運算符、位運算符和三元條件運算符。2.6.1 算術(shù)運算符 算術(shù)運算符：+、-、*、/、%、++和--，與C/C++基本相同。 %運算符不但可以對整形數(shù)據(jù)運算，而且可以對浮點型數(shù)據(jù)運算。例如：3.14 % 2.5的值約等于0.64 ； 隠式數(shù)據(jù)類型轉(zhuǎn)換： 當整型與浮點型數(shù)據(jù)進行混合運算時，表達式中的數(shù)據(jù)類型會進行相應的自動轉(zhuǎn)換，規(guī)則為：byte->short->int->long->float->double。 這種轉(zhuǎn)換規(guī)則也適應于賦值語句，當賦值符左右兩側(cè)變量類型不一致時，只要轉(zhuǎn)換過程中不丟失數(shù)據(jù)，便進行自動轉(zhuǎn)換。 class number { int x;} public class relationalOperator{ public static void main(String args[ ]){ / 87 大理學院課程教案（教學內(nèi)容） number n1,n2; n1=new number(); n2=new number(); n1.x=1; n2.x=1; if(n1.x==n2.x) System.out.println(“對象的數(shù)據(jù)成員x相等！”); if(n1==n2) System.out.println(“n1和n2是一個對象！”);else System.out.println(“n1和n2不是一個對象！”);} } 2.6.2 關系運算符 關系運算符不能同其它類型的變量一同 參與運算，例如假設a,b,c是三個整形的變量，那么 a=b==c 是 正確 OR 錯誤？ ； 關系運算符用于對象時，是判別兩個引用是否代表同一個對象。而不是判斷兩個引用所指向的對象是否同屬一個類。 2.6.3 邏輯運算符 邏輯運算符有&&、|| 和!，分別是與、或和非。運算結(jié)果是true或false； 邏輯運算有求值“短路”現(xiàn)象，例如程序2-11 ： public class shortCut { static boolean testOne(int x){ System.out.println(x+“ < ”+1+“ ” +(x<1)); return x < 1; } static boolean testTwo(int x){ System.out.println(x+“ < ”+1+“ ” +(x<2)); return x < 2; } public static void main(String [ ] args){ if(testOne(6)&& testTwo(1)) System.out.println(“表達式為真”); else System.out.println(“表達式為假”);} } 2.6.4 位運算符 / 87 大理學院課程教案（教學內(nèi)容） 位運算符：&、|、^、~、<<、>>，分別稱為位與、或、異或、左移、右移； Java引入一個專門用于邏輯右移運算符>>>，它采用了所謂的零擴展技術(shù)，不論原值是正或負，一律在高位補0。例如： int a=-2 , b; b=a>>>30;2.6.5 三元條件運算符 語法格式：（exp）?(exp1)：(exp2)； Java要求：(exp1)與(exp2)必須同類型。2.6.6 “+”運算符 Java對“+”進行了重載，可以將任何類型的對象（包含原子類型）轉(zhuǎn)化為String類型。例如： int x=1; char ch='A'; double d=9.8; System.out.println(“Result: ”+x+ch+9.8);課堂練習： 課外練習（作業(yè)）： P32 3、4、6題。 第3章 控制語句 教學目的要求 ? 了解Java程序的結(jié)構(gòu)，學習使用各種語句結(jié)構(gòu)來控制程序的流程，完成程序的功能任務。主要內(nèi)容 ? Java的分支語句； ? 循環(huán)控制語句； ? break和continue語句； ? 帶標號的break和continue語句。 重點內(nèi)容 ? Java的分支語句； ? 循環(huán)控制語句； ? break和continue語句； 難點內(nèi)容 ? 循環(huán)控制語句； ? break和continue語句； 課時分配 3課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 3.1 分支語句 / 87 大理學院課程教案（教學內(nèi)容） if-else語句； switch-case語句。3.1.1 if 語句 if語句的語法格式 同C/C++； 條件表達式必須是布爾類型，例如： 下面的寫法在C/C++中是合法的，但在Java中卻是非法的 ： int i=10;if(i) ...程序3-1描述了用applet從文本框獲取數(shù)據(jù)，然后將比較的結(jié)果顯示出來。 // 程序 3-1 import java.awt.*;import java.applet.*; public class compareNumbers extends Applet{ Label lab1,lab2;TextField input1,input2;int num1,num2;public void init(){ lab1=new Label(“輸入第1個整數(shù)”); input1=new TextField(10); lab2=new Label(“輸入第2個整數(shù)”); input2=new TextField(10); add(lab1); add(input1); add(lab2); add(input2);} public boolean action(Event e , Object o){ if(e.target==input1 || e.target==input2){ num1=Integer.parseInt(input1.getText()); num2=Integer.parseInt(input2.getText()); if(num1 showStatus(num1 + “ < ” + num2); else if(num1>num2) showStatus(num1+“ > ”+num2); else showStatus(num1+“ == ”+num2); } return true;} } 3.1.2 switch 語句 / 87 大理學院課程教案（教學內(nèi)容） switch語句的語法結(jié)構(gòu) 同C/C++； switch后面的表達式類型必須是字符類型或整形 ； case后面的常量不能重復 ； 程序3-3采用小程序?qū)崿F(xiàn)將學生的百分制成績轉(zhuǎn)換為優(yōu)、良，中、及格和不通過五個等級： // 程序3-3 import java.awt.*;import java.applet.*; public class scoreConvert extends Applet{ Label prompt;TextField input;int Excellent,Good,Middle,Pass,Failure;public void init(){ prompt=new Label(“輸入成績”); input=new TextField(2); add(prompt); add(input);} public void paint(Graphics g){ g.drawString(“各等級的人數(shù):”,25,40); g.drawString(“優(yōu)秀 : ”+Excellent,25,55); g.drawString(“良好 : ”+Good,25,70); g.drawString(“中等 : ”+Middle,25,85); g.drawString(“及格 : ”+Pass,25,100); g.drawString(“不通過: ”+Failure,25,115);} public boolean action(Event e , Object o){ int score=Integer.parseInt(input.getText()); showStatus(“"); input.setText(”“); switch(score/10){ case 10: case 9: Excellent++; break; case 8: Good++; break; case 7: Middle++; break; case 6: Pass++; break; case 5: case 4: case 3: case 2: case 1: case 0: Failure++; break; default: showStatus(”輸入有誤，重新輸入!“); } repaint(); / 87 大理學院課程教案（教學內(nèi)容） return true;} } 程序3-3需要注意的地方 在action（）方法中調(diào)用的repaint()方法，是一個系統(tǒng)方法，它具有自動調(diào)用paint()方法的能力，從而實現(xiàn)對網(wǎng)頁的刷新。3.2 循環(huán)控制語句 Java中的循環(huán)控制語句有三種，分別是：while，do-while和for語句;循環(huán)體內(nèi)的語句會反復執(zhí)行，直到控制布爾表達式的值變?yōu)閒alse為止。3.2.1 while語句 while語句格式： while(Boolean-Expression) StatementS 程序示例3-4 略 3.2.2 do-while語句 do-while語句的語法格式如下： do{ Statement }while(Boolean-Expression); 程序3-5 如下： // 產(chǎn)生一個大于0.9的隨機數(shù)為止 public class GenerateDoubleNumbers { public static void main(String args[ ]){ double d; do{ d=Math.random(); System.out.println(d); }while(d<0.9);} } 3.2.3 for語句 for語句語法格式如下： for(ForInitopt;Boolean-Expression;ForUpdateopt) Statement // 程序3-6輸出一個*三角形 public class printGraphics extends Applet{ public void paint(Graphics g){ int xpos,ypos=0; for(int row=6;row>=1;row--){ / 87 大理學院課程教案（教學內(nèi)容） xpos=25; ypos+=15; for(int column=1;column<=row;column++){ g.drawString(”*“,xpos,ypos); xpos+=7; } } } } 3.3 break語句和continue語句 3.3.1 不帶標號的break語句和continue語句 break語句可以跳出包含它的最內(nèi)層的循環(huán)，不再執(zhí)行剩余的語句； continue語句停止執(zhí)行當前的循環(huán)，回到循環(huán)處，開始執(zhí)行下一輪的循環(huán)。這些特性和C/C++的功能一樣。 for(int i=1;i<10;i++) { if(i%3==0) continue; else System.out.println(”i = “+i); } for(int i=1;i<10;i++) { if(i%3==0) break; else System.out.println(”i = “+i); } 課堂練習： 1、仔細分析下面程序，寫出程序的最終運行結(jié)果。public class s_switch { public static void main(String args[]) { int ch=8; int r=10; switch(ch-1){ case 7: r=r+3; / 87 大理學院課程教案（教學內(nèi)容） case 8: r=r+5; case 9: r=r+6;break; default:; } System.out.println(”r=“+r); } } 2、隨機產(chǎn)生26個英文字母a~z，直到大于u為止。用while和for語句實現(xiàn)。 課外練習（作業(yè)）： P44 1—4 第4章 Java的類 教學目的要求 理解面向?qū)ο缶幊痰幕靖拍?了解類的封裝方法 如何創(chuàng)建類和對象 了解成員變量和成員方法的特性 學習使用OOP方式進行程序設計 深刻理解類的繼承性和多態(tài)性 主要內(nèi)容 ? 類的定義和使用； ? 方法的定義和使用； ? 實例變量和局部變量； ? 構(gòu)造方法； ? 方法的覆蓋和重載； ? 關鍵字this的用法； ? 繼承的概念和應用； ? 組合與繼承； ? 抽象方法和抽象類； ? 對象類型轉(zhuǎn)換； ? 訪問權(quán)限限制符：public、private、protected。 重點內(nèi)容 ? 類的定義和使用； ? 方法的定義和使用； ? 構(gòu)造方法； ? 方法的覆蓋和重載； ? 關鍵字this的用法； ? 繼承的概念和應用； / 87 ? ? ? ? ? ? 大理學院課程教案（教學內(nèi)容） ? 組合與繼承； ? 抽象方法和抽象類； ? 對象類型轉(zhuǎn)換； 難點內(nèi)容 ? 構(gòu)造方法； ? 方法的覆蓋和重載； ? 繼承的概念和應用； ? 組合與繼承； ? 抽象方法和抽象類 課時分配 8課時 教學方法 講授法、演示法、對比法、實驗驗證法、學生討論法 講授內(nèi)容提要 4.1 類與對象 在Java程序中，除原子類型的變量以外都是對象，連Java程序本身也不例外。 類是面向?qū)ο蟪绦蛟O計的基礎，OO始終是圍繞著對象的封裝性、繼承性和多態(tài)性展開討論的。4.1.1 類與對象的區(qū)別 類是一個抽象的概念，對象是一個具體的概念。 類是在一組對象的基礎上，通過抽象和概括獲得的一個概念。 對象是由數(shù)據(jù)和方法緊密結(jié)合的一個封裝體，具有信息隱藏的能力。 對象可以通過方法（函數(shù)）與其它對象進行通信，但并不知道這些方法的實現(xiàn)細節(jié)。4.1.2 Java和C編程思想的區(qū)別 C是結(jié)構(gòu)化的編程語言，以函數(shù)為編程單元，程序員把注意力集中在編寫函數(shù)上。Java是面向?qū)ο蟮木幊陶Z言，以類為編程單元，程序員的精力集中在對類的設計上。 對象將實例變量（instance variable）和對數(shù)據(jù)的操作（即方法）約束在一起，類似一個獨立的程序，易于擴充，易于維護，代碼可復用。4.1.3 如何定義類 類是對象的模板，它定義了對象的結(jié)構(gòu)和操作數(shù)據(jù)的方法。public class Sayhello extends Applet { public void paint(Graphics g){ int xPos=35; int yPos=30; g.drawString(”Hello Java!“,xPos,yPos); } } 定義類的通用格式如下： class className extends superClassName{ type instance-vairbale1; return-type methodName1(parameter-list){ method-body;} / 87 大理學院課程教案（教學內(nèi)容） } public class Hello { public static void main(String args[ ]){ System.out.println(”Hello Java!“); } } 系統(tǒng)類Object是整個類層次結(jié)構(gòu)中的根。如果我們要定義Object的子類，可以不指明extends Object，默認情況下一個類就是Object類的子類。類內(nèi)定義的變量稱為實例變量，函數(shù)稱為方法； Java將類的定義和類的實現(xiàn)放在一起，便于系統(tǒng)維護。例如： class point { // Object類的子類 int x , y; void init(int a, int b){ int i=0; x=a; y=b; } } 4.1.4 對象和引用 對象是客觀存在的變量，對象的引用就是對象的名字，例如：Point p1;創(chuàng)建對象：p1=new Point(); 一個對象可以有多個別名; p2=p1;將一個變量設置為null，表明該變量不代表任何對象 : p1 = null; 每個對象都有自己的變量，改變一個對象的實例變量并不影響到另外一個對象。例如： class Point { // 程序4-1 int x , y; void init(int a, int b){ x=a; y=b; } } public class TwoPoint{ public static void main(String [ ]args){ Point p1= new Point(), p2= new Point(); p1.x=10;p1.y=20; p2.x=30;p2.y=40;System.out.println(”x = “+ p1.x +” y= “+p1.y);System.out.println(”x = “+ p2.x +” y= “+p2.y); } } 4.2 方法 方法是一個功能模塊，類似C中的函數(shù)； 方法和實例變量都必須定義在類內(nèi)，方法是類的功能接口 ； 定義方法的原則：方法應當只執(zhí)行單一的任務，并且方法名能有效地表達該任務； / 87 大理學院課程教案（教學內(nèi)容） 方法的返回值類型、方法名和參數(shù)表共同稱之為方法的特征。調(diào)用方法的格式：引用.方法名(參數(shù)表);例如： Point p1=new point()，p2=new point();Point p3=p2;p1.init(10,20);//僅對p1對象的x和y進行賦值 p2.init(30,40);//僅對p2對象的x和y進行賦值 對象是客觀存在的變量，對象的引用就是對象的名字，例如：point p1;創(chuàng)建對象：p1=new point(); 一個對象可以有多個別名; p2=p1;將一個變量設置為null，表明該變量不代表任何對象 : p1 = null; 每個對象都有自己的變量，改變一個對象的實例變量并不影響到另外一個對象。 4.3 實例變量和局部變量 class Loc { // 程序4-2 int x=1;// 實例變量 void printLocVar(){ int x=25;// 局部變量 System.out.println(”n x is :“+x); ++x; System.out.println(” x is :“+x);} void printInstanceVar(){ System.out.println(”n x is :“+x); x*=10; System.out.println(x is :”+x);} } public class TestInstanceVar { // 程序的主類 public static void main(String args[ ]){ loc obj=new Loc(); int x=5; // 局部變量 x System.out.println(“ x is :”+x); obj.printLocVar(); obj.printInstanceVar(); System.out.println(“ x is :”+x);} } 4.3 實例變量和局部變量 Java中的變量分為兩種：類內(nèi)定義的實例變量，方法中定義的局部變量。 在同一個作用域內(nèi)，不允許定義兩個同名的局部變量。 局部變量可以掩蓋實例變量。 / 87 大理學院課程教案（教學內(nèi)容） 實例變量屬于對象，它描述了對象的屬性，隨著對象的存在而存在； 局部變量是隨著方法的調(diào)用而存在，一旦方法調(diào)用結(jié)束，局部變量也就消亡了。4.4 構(gòu)造方法 構(gòu)造方法的功能是在創(chuàng)建對象時初始化對象的實例變量； 討論：構(gòu)造方法的特點： 無返回值，無void 方法名與類名相同 僅在創(chuàng)建對象時調(diào)用 class point { // 程序4-3 int x, y;point(int a, int b){ x=a;y=b;} } public class createPoint { public static void main(String args[ ]){ point p= new point(10,20); System.out.println(p.x +“ ”+p.y);} } 如果類中沒有定義構(gòu)造方法，編譯器會自動創(chuàng)建一個缺省的、不帶參數(shù)的構(gòu)造方法。構(gòu)造方法是在對象創(chuàng)建之后，new操作完成前被調(diào)用的。4.5 方法重載 方法重載是在一個類中定義二個或多個同名的方法，但方法的參數(shù)個數(shù)或類型不完全相同；例如： class point { int x, y;point(int a, int b){ x=a;y=b;} point(){ x=-1;y=-1;} point(double a, int b){ x=(double)a;y=b;} } 方法重載的一個誤區(qū)：是靠返回值區(qū)別重載，即定義多個方法，它們的名稱和形參類型完全相同，但返回值不同，這是不允許的； 4.6 關鍵字this this指代對象，是對當前對象的一個引用。例如： class IntVector { // 程序4-6 int v[ ]; boolean equals(IntVector other){ if(this == other)return true; return false;} } class testIntVector { / 87 大理學院課程教案（教學內(nèi)容） public static void main(String args[ ]){ IntVector t1=new IntVector()，t3=new IntVector()，t2=t1; System.out.println(t1.equals(t2)); System.out.println(t3.equals(t2)); } } Java中的級連調(diào)用，仍是指代當前對象的this。例如：// 程序4-7 import java.awt.*;import java.applet.*; class time{ private int hour, min, sec; time(){ setHour(0);setMin(0);setSec(0);} time setHour(int h){ hour=((h>=0 && h<24)? h: 0); return this;} time setMin(int m){ min=((m>=0 && m<60)? m: 0); return this;} time setSec(int s){ sec=((s>=0 && s<60)? s: 0); return this;} String tostring(){ return hour+“:”+min+“:”+sec;} public class timeToString extends Applet{ private time t; public void init(){ t=new time();} public void paint(Graphics g){ t.setHour(18).setMin(30).setSec(20); / 87 } 大理學院課程教案（教學內(nèi)容） g.drawString(“ time:”+t.tostring(),25,45);} } 在構(gòu)造方法內(nèi)部使用this，它用于指代另外一個構(gòu)造方法，但不能指代非構(gòu)造方法。例如： class point { int x, y; point(){ this(-1,-1);} point(int a, int b){ x=a;y=b;} } 4.7 繼承 繼承是軟件重用的一種形式，可以提高系統(tǒng)的性能； 繼承語法： class className extends superClassName{ 各實例變量和方法的定義 } 例如： class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} point(){ this.x=0; this.y=0;} } class circle extends point{ int radius; circle(int r, int x, int y){ radius=r; this.x=x; this.y=y; } } Java不支持多繼承，但支持多接口； 子類的對象也是其超類的對象，反之未必； 繼承具有傳遞性： B繼承于A，C又繼承于B，則C也繼承了A中的實例變量和方法。關鍵字super 構(gòu)造方法是一種特殊的方法，子類不能繼承超類的構(gòu)造方法，但子類構(gòu)造方法可以通過super調(diào)用超類的構(gòu)造方法。 當創(chuàng)建子類對象時，首先執(zhí)行超類構(gòu)造方法，然后執(zhí)行子類的構(gòu)造方法。例如： class point{ // 程序4-8 int x, y; point(int x, int y){ / 87 大理學院課程教案（教學內(nèi)容） this.x=x;this.y=y; System.out.println(“父類構(gòu)造函數(shù)被調(diào)用！”); } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; System.out.println(“子類構(gòu)造函數(shù)被調(diào)用！”); } } public class testInherence { public static void main(String args[ ]){ circle c1; c1=new circle(1,1,1); } } 再次討論構(gòu)造方法 若父類沒有定義構(gòu)造方法，那么對父類數(shù)據(jù)的初始化將采用系統(tǒng)缺省的構(gòu)造方法；例如： class point{ int x, y; } class circle extends point{ int radius; circle(int r, int x, int y){ this.x=x; this.y=y; radius=r; } } 若父類定義有缺省構(gòu)造方法，那么子類可根據(jù)自己的需要設置自己的構(gòu)造方法。例如： class point{ int x, y; point(){ this(0,0); } point(int x, int y){ this.x=x;this.y=y; } } class circle extends point{ // 注意子類的構(gòu)造函數(shù) int radius; circle(int r, int x, int y){ radius=r;} } 若父類定義的構(gòu)造方法都是有參的，那么子類構(gòu)造方法必須通過super調(diào)用父類構(gòu)造方法，class point{ private int x, y; point(int x, int y){ / 87 大理學院課程教案（教學內(nèi)容） this.x=x; this.y=y; } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; } } 4.8 方法的覆蓋 方法的覆蓋發(fā)生在父類和子類之間，若子類中定義的某個方法的特征，與父類中定義的某個方法的特征完全一樣，那么就說子類中的這個方法覆蓋了父類對應的那個方法。4.8.1 覆蓋與重載的區(qū)別 重載可以出現(xiàn)在一個類中，也可以出現(xiàn)在父類與子類的繼承關系中，并且重載方法的特征一定不完全相同。 覆蓋特點：子類中的方法特征與父類定義的對應方法的特征完全一樣。例如： // 程序4-9 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){super(x, y); radius=r; } double area(){ return Math.PI*radius*radius;} } public class testOverWrite { public static void main(String args[ ]){ circle c1; c1=new circle(1,1,1); System.out.println(c1.area()); } } 4.8.2 方法的動態(tài)調(diào)用 Java的所有對象運行時都有一個類型標識(RTTI：Run-Time Type Identification)，該標識記錄了每個對象所屬于的類。Java用此標識在運行時選擇正確的方法。例如： // 程序4-11 / 87 大理學院課程教案（教學內(nèi)容） class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r;} double area(){ // 覆蓋了父類的area方法 return Math.PI*radius*radius; } } public class dynamicalCall { public static void main(String args[ ]){ point p[ ]={new point(2,2), new circle(1,1,1)}; for(int i=0;i System.out.print(“類名： ”+ p[i].getClass().getName()); System.out.print(“父類：”+ p[i].getClass().getSuperclass()); System.out.println(“ 面積： ”+ p[i].area()); } } } 子類對象調(diào)用方法時: (1)子類檢查是否具有同名和同參數(shù)類型的方法，若有則調(diào)用該方法，否則繼續(xù)執(zhí)行。 (2)到父類中尋找同名和同參數(shù)類型的方法，若有則調(diào)用該方法。若找不到，將產(chǎn)生編譯錯誤。 對象決定自己到底該調(diào)用哪個方法，取決于該對象在繼承鏈中的位置。 4.9 多態(tài)性不適合繼承鏈中的實例變量 引用.方法：根據(jù)多態(tài)性調(diào)用； 引用.實例變量：根據(jù)引用的類型調(diào)用。即：多態(tài)性僅僅適用于方法的調(diào)用，而不適合實例變量。例如： class Base{ // 程序4-12 int x=1;void print(){ System.out.println(“當前類為 ”+ this.getClass().getName()); / 87 大理學院課程教案（教學內(nèi)容） System.out.println(“對象的x= ”+this.x); } } class Derived extends Base{ int x=2;void print(){ System.out.println(“當前類為 ”+ this.getClass().getName()); System.out.println(“對象的x= ”+this.x); } } public class confusions{ public static void main(String [ ] args){ Base obj=new Derived(); obj.print(); System.out.println(“對象的x= ”+obj.x); } } 4.10 finalize Java的垃圾回收器具有自動回收垃圾的能力。 垃圾回收器是一個優(yōu)先級比較低的線程，在系統(tǒng)空閑時運行。 在對象被回收之前，有時需要執(zhí)行一些特殊的操作，例如保存文件、清除屏幕等，這時就要用Java的finalize方法。例如： class point{ // 程序4-13 int x, y; point(int a, int b){ x=a;y=b; System.out.println(“point constructor:”+getString()); } public void finalize(){ // 注意該方法 System.out.println(“point finalizer:”+getString()); } String getString(){ return “x=”+x+“ y=”+y; } } class circle extends point{ int radius; / 87 大理學院課程教案（教學內(nèi)容） circle(int r, int a, int b){ super(a,b);radius=r;System.out.println(“circle constructor:”+getString()); } public void finalize(){ System.out.println(“circle finalizer:”+getString()); } String getString(){ return super.getString()+“ radius=”+radius; } } public class testFinalize { public static void main(String args[ ]){ point c1,c2;c1=new circle(1,1,1); c2=new circle(2,2,2); c1=null; c2=null;System.gc(); } } 4.11 static static修飾變量（與C中的不同）； static修飾方法（與C中的不同）； 4.11.1 static變量 static變量是指這樣的成員變量：不管在程序運行中生成多少個該類的對象，它們都共享該變量。即使沒有創(chuàng)建對象，該變量仍然存在。因此，static變量又稱為類變量。定義格式為：static type variableName; static變量和一般的實例變量不同，在構(gòu)造方法中不能對它進行初始化。例如： class point{ // 程序4-14 static int count;int x, y; static{ // 靜態(tài)初始化塊 count=0; System.out.println(“static variable is initialized!”); } point(int a, int b){ / 87 大理學院課程教案（教學內(nèi)容） count++; x=a; y=b; System.out.println(“Call point constructor!”);} } public class testStaticVariable { public static void main(String args[ ]){ point c1=new point(0,0); System.out.println(“There are ”+ point.count +“ points”); } } 4.11.2 static方法 (可舉例說明Math類的PI和sqrt等，為什么要用靜態(tài)變量。)static方法是類中的成員方法，它屬于整個類，即使不創(chuàng)建任何對象，也可使用靜態(tài)方法。調(diào)用靜態(tài)方法格式：類名.方法名（參數(shù)）； 在子類中不能覆蓋父類中定義的靜態(tài)方法。 靜態(tài)方法中只能出現(xiàn)靜態(tài)變量和其它靜態(tài)方法。并且還不能使用this和super。例如： class point{ // 程序4-15 static int count;// 定義靜態(tài)變量 int x, y; static{ count=0;System.out.println(“static variable is initialized!”); } point(int a, int b){ count++; x=a;y=b; System.out.println(“Call point constructor!”); } static int getCount(){ // 靜態(tài)方法 return count; } } public class testStaticMethod { public static void main(String args[ ]){ point c1=new point(0,0);point c2=new point(1,1); System.out.println(“There are ”+ point.getCount()+“ points”);} / 87 大理學院課程教案（教學內(nèi)容） } 4.12 關鍵字final 在實例變量、局部變量和方法的形參定義之前加上final，那么這個變量值只能被引用，而不能修改。 final修飾的局部變量和實例變量必須給出初值，因為它修飾的變量代表一個常量。例如： class Base{ // 程序4-16 final int x=1; // 形式1：修飾實例變量 void print(final int y){ // 形式2：修飾參數(shù) // y=0; // 錯誤 System.out.println(x+y); } } public class finalVariables{ public static void main(String [ ] args){ final int var=100;// 形式3：修飾局部變量 Base obj=new Base(); obj.print(var);} } 在方法定義前加上final，該方法就不能被子類覆蓋，成為終極方法 ； 包含終極方法的類仍然可以被子類繼承，子類雖然不能覆蓋父類中的終極方法，但可以重載該方法。例如： class Base{ final int x=1; final void print(int y){ // 父類中的final方法 System.out.println(x+y); } } class Derived extends Base { void print(){ // 重載了父類中的print方法 System.out.println(x); } } 4.12.3 final類 在一個類定義前加上final，意味著這個類就不能被其它類繼承，成為終極類。 系統(tǒng)類基本上都是final類，如String類。 / 87 大理學院課程教案（教學內(nèi)容） 將class定義為final是為了杜絕繼承，類中的方法自然都變成了終極方法。例如： final class Base{ // 聲明為final類 final int x=1; void print(final int y){ System.out.println(x+y); } } // 錯誤：不能繼承final 修飾的Base類 class Derived extends Base { } 4.13 組合與繼承 面向?qū)ο笾械能浖赜帽憩F(xiàn)為兩種形式：繼承和對象組合。 設計這類程序的關鍵是構(gòu)造方法：子類構(gòu)造方法調(diào)用父類構(gòu)造、成員對象的初始化。class date{ // 程序4-17 int year, mon,day; date(int y, int m, int d){ year=y; mon=(m>0 && m<13)?m:1;day=checkday(d); } int checkday(int d){ int daydisp[ ]={0,31,28,31,30,31,30,31,31,30,31,30,31}; if(d>0 && d<=daydisp[mon]) return d; if(mon==2 && d==29 &&(year%400==0 || year%4==0&& year%100!=0)) return d; return 1; } String tostring(){ return year+“/”+mon+“/”+day;} } class employee{ // 雇員類 long id;date birthday; employee(long no, int year, int mon, int day){ id=no; // 設置組合對象 birthday=new date(year,mon,day);} / 87 例如： 大理學院課程教案（教學內(nèi)容） String tostring(){ return id+“ , ”+birthday.tostring();} } class manager extends employee { // 經(jīng)理類 double basePay; manager(long no, int y, int m, int d){ super(no,y,m,d); // 調(diào)用父類構(gòu)造函數(shù) basePay=1000;} String tostring(){ return basePay+“ , ”+super.tostring();} } public class compositionAndInherence { public static void main(String [ ] args){ manager boss; boss=new manager(1001,1971,11,5); System.out.println(boss.tostring()); } } 4.14 抽象類和抽象方法 抽象方法：僅有方法特征，但沒有代碼； 抽象類：包含抽象方法的類。 抽象類的作用：提供一種適當?shù)某悾宇愅ㄟ^繼承實現(xiàn)父類中的抽象方法。 抽象類不能用final修飾。 抽象類體現(xiàn)了多態(tài)性，通過繼承可以從抽象類派生出具有相似操作的子類。例如： abstract instrument abstract void play()繼承 wind void play()繼承 繼承 stringed void play()percussion void play()繼承 繼承 woodwind void play()brass void play() // 程序4-18 / 87 大理學院課程教案（教學內(nèi)容） abstract class instrument{ abstract void play();// 抽象方法 } // wind不是抽象類 class wind extends instrument{ void play(){ System.out.println(“wind play!”);} } // percussion也不是抽象類 class percussion extends instrument{ void play(){ System.out.println(“percussion play!”);} } // stringed也不是抽象類 class stringed extends instrument{ void play(){ System.out.println(“stringed play!”);} } class woodWind extends wind{ // 覆蓋父類中的play方法 void play(){System.out.println(“woodWind play!”);} } class brass extends wind{ // 覆蓋了父類中的play方法 void play(){ System.out.println(“brass play!”);} } public class music { static void tuneAll(instrument e[ ]){ for(int i=0;i e[i].play();} public static void main(String [ ] args){ instrument orchestra[ ] = new instrument[5]; int i=0; orchestra[i++]=new wind(); orchestra[i++]=new percussion(); orchestra[i++]=new stringed(); orchestra[i++]=new woodWind(); orchestra[i++]=new brass(); tuneAll(orchestra); } } 程序運行結(jié)果： wind play!percussion play! / 87 大理學院課程教案（教學內(nèi)容） stringed play!woodWind play!brass play! 4.15 對象的類型轉(zhuǎn)換 4.15.1 向上類型轉(zhuǎn)換 從子類向父類轉(zhuǎn)換，在繼承圖中是向上移動，通常稱為向上類型轉(zhuǎn)換。類型向上轉(zhuǎn)換是安全的，因為這是從特殊類型到通用類型的轉(zhuǎn)換。 進行向上類型轉(zhuǎn)換時，出現(xiàn)的唯一問題是可能丟失子類中定義的方法和變量。例如： // 程序4-19 class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} int getX(){ return x;} } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y);radius=r;} double area(){ return Math.PI*radius*radius; } } public class testUpCasting { public static void main(String [ ] args){ circle c=new circle(1,1,1); point p=c;// 注意：p和c的類型不同 } System.out.println(p.getX()); } 4.15.2 向下類型轉(zhuǎn)換 從父類向子類轉(zhuǎn)換，在繼承圖中是向下移動，稱為向下類型轉(zhuǎn)換。 類型向下轉(zhuǎn)換是不安全的，因為這是從一般類型到特殊類型的轉(zhuǎn)換。例如： public static void main(String [ ] args){ point p=new point(1,1);circle c;c=p; //注意：此處編譯時出錯 c=(circle)p;//注意：此處運行時出錯 System.out.println(c.area()); } / 87 大理學院課程教案（教學內(nèi)容） 4.16 訪問權(quán)限限制 Java提供的訪問權(quán)限修飾符有四個，即public、private、protected和友元； 修飾符要置于每個類成員（實例變量和成員方法）的定義之前，且僅能控制它所修飾的那個成員。4.16.1 友員 缺省修飾符的情況就是友員。友員修飾符意味著同一個目錄（包）中的所有類都可以訪問這種類型的成員。 friendly不屬于Java關鍵字，是C++的一個關鍵字。 例如： public class Base{ // 該類位于Base.java文件中 int friend_data=1;// 友員數(shù)據(jù)成員 } // 該類位于Derived.java文件中 public class Derived extends Base{ Base p=new Base(); // 訪問Base類中的friend_data void dataUse(){ System.out.println(“data=”+p.friend_data); } } 4.16.2 public 成員 不管兩個類是否位于同一個目錄中，一個類總可以訪問另一個類的public成員。 public還可以用于修飾主類，文件名必須與主類名一致。除此之外，其它3個修飾符都不能用于修飾類，只能修飾成員。例如： public class Base{ public int friend_data=1;// public成員 } public class Derived extends Base{ public Base p=new Base(); public void dataUse(){ System.out.println(“data=”+p.friend_data); } } 4.16.3 private成員 private成員的特性：除了其所在類能夠訪問該成員以外，其它類都不能訪問它。 在多人合作開發(fā)一個系統(tǒng)的過程中，private可以讓你自由使用自己定義的成員，無須擔心與其他人 / 87 大理學院課程教案（教學內(nèi)容） 寫的類相沖突。例如： // 程序4-20 class Base{ private Base(){ } // 注意 static Base makeBase(){ return new Base();} } public class testPrivate { public static void main(String args[ ]){ // Base p=new Base(); // 編譯有錯 Base p = Base.makeBase();} } 4.16.4 protected成員 protected與繼承有關，這種類型的成員可以被子類訪問。 同一個包內(nèi)的非子類，也可以訪問這種類型的成員。即：protected天生就具有友元權(quán)限，例如： // 程序4-21 class Base{ // 該類位于Base.java文件中 int friend_data=1; // 友元成員 public int public_data=2;// public成員 private int private_data=3;// private成員 protected int protected_data=4;// protected成員 } class Derived extends Base{ // Derived.java文件 Base a=new Base(); void dataUse(){ System.out.println(a.friend_data); System.out.println(a.public_data); // System.out.println(a.private_data); System.out.println(a.protected_data);} } // 將主類存放在testData.java文件中 public class testData { public static void main(String args[ ]){ Derived d=new Derived(); d.dataUse(); } } 訪問權(quán)限總結(jié) / 87 大理學院課程教案（教學內(nèi)容） 課堂練習： 1、定義一個Student類： 該類的功能有：可以保存、修改和獲取學生的姓名、學號等。可以設置學生的英語成績、數(shù)學成績、Java成績，并能計算平均分、最高分和最低分。 2、以下代碼定義了一個類，請指出其中三條不合法的代碼行（行號參見注釋）。 class Test22{ //1 float u; //2 static float v; //3 static void setUV(boolean f){ //4 u=fac1(f); //5 v=fac2(!f); //6 } //7 static float fac1(boolean f){ return f?u:v;} //8 float fac2(boolean f){ return f?u:v;} //9 } 課外練習（作業(yè)）： P87 1、3、4、6 第5章 接口和包 教學目的要求 ? 掌握接口的定義和使用 ? 了解接口與抽象類的異同點 ? 掌握包的定義和使用 主要內(nèi)容 ? 接口的定義和使用 ? 包的定義和使用 重點內(nèi)容 ? 接口的定義和使用 ? 包的定義和使用 難點內(nèi)容 無 課時分配 / 87 大理學院課程教案（教學內(nèi)容） 1課時 教學方法 講授法、演示法 講授內(nèi)容提要 5.1 接口 引入接口的原因：在程序設計中經(jīng)常遇到這樣一個問題：有些類互不相關，但卻具有相似的方法。并且這些方法在各個類中的實現(xiàn)互不相同。我們不能為這些類定義一個共同的父類，但又希望在程序中體現(xiàn)出它們共同的接口。5.1.1 接口的定義和應用 接口是一系列常量和空方法的集合，它提供了多個類共同的方法，但不限制每個類如何實現(xiàn)這些方法。 Java允許一個類同時實現(xiàn)多個接口，相當于實現(xiàn)多繼承的功能。聲明一個接口的語法格式： [public] interface interfaceName [extends super-interface-List]{ type ConstantName=value; type MethodName(Parameter lists);} 例如： interface Sortable{ // 定義一個接口 int Compare(Sortable s);} 接口中不能聲明任何變量和構(gòu)造方法。 如果一個類實現(xiàn)多個接口，應該在接口名之間用逗號隔開。 當一個類實現(xiàn)接口時，必須實現(xiàn)接口中給出的空方法，若實現(xiàn)接口的類是一個抽象類，可以把實現(xiàn)接口的任務交給子類去實現(xiàn)。例如： // 程序5-1 interface Sortable{ // 定義一個接口 int Compare(Sortable s);} class Sort{ // 定義一個排序類，僅有一個靜態(tài)的方法 public static void SelectSort(Sortable a[ ]){ int i, j, k;Sortable temp; for(i=0;i // 選擇排序 k=i; for(j=i+1;j if(a[k].Compare(a[j])<0)k=j; temp=a[i];a[i]=a[k];a[k]=temp;} } } class Student implements Sortable{ // 定義一個學生類 private int score; / 87 大理學院課程教案（教學內(nèi)容） Student(int x){ score=x;} // 實現(xiàn)接口Sortable中的方法 public int Compare(Sortable s){ Student st=(Student)s; // 類型強制轉(zhuǎn)換 return score-st.score; } public String toString(){ return “score=”+score;} } class Rectangle implements Sortable{ // 矩形類也實現(xiàn)了接口 private int length,width; Rectangle(int x,int y){ length=x;width=y;} int area(){return length*width;} public int Compare(Sortable s){ // 實現(xiàn)接口 Rectangle rec=(Rectangle)s; // 類型強制轉(zhuǎn)換 return area()-rec.area(); } public String toString(){ return “area=”+area();} } public class interfaceTest { public static void main(String args[ ]){ Student stud[ ]=new Student[20];int i; for(i=0;i stud[i]=new Student（(int)(Math.random()*100));Sort.SelectSort(stud); // 排序 for(i=0;i System.out.println(stud[i].toString()); Rectangle R[ ]=new Rectangle[10]; for(i=0;i R[i]=newRectangle（(int)(Math.random()*10)，(int)(Math.random()*10));Sort.SelectSort(R); // 排序 for(i=0;i System.out.println(R[i].toString()); / 87 大理學院課程教案（教學內(nèi)容） } } 接口中定義的變量實際上是常量，必須給出它們的初始值，實現(xiàn)接口的類可以自由引用這些常量。例如： // 程序5-2的部分 interface constant { int EXCELLENT=5;int GOOD=4;int PASS=3;int FAIL=2;} 在類中實現(xiàn)接口中方法時，方法的特征必須和接口中聲明的方法特征保持一致； 實現(xiàn)方法時必須在方法前加上public； 若一個類沒有對接口中的方法具體實現(xiàn)，那么必須將該類聲明為abstract類。例如： interface inter { // 接口 void methodA();} abstract class Derived1 implements inter { // 此處不需要寫出methodA()的原型 } class Derived2 extends Derived1{ public void methodA(){ // 實現(xiàn)方法 System.out.println(“Hi,methodA”); } } 5.1.2 接口和抽象類的異同點 接口和抽象類的相同點： (1)都有空的方法，都必須在子類中實現(xiàn)這些方法。 (2)都不能用new關鍵字來創(chuàng)建這兩種類型的對象。 (3)都可以具有繼承關系。 (4)接口和類一樣可以具有public屬性。接口和抽象類的不同點： (1)在抽象類中，空的方法必須加abstract關鍵字，而在接口中不需要。 (2)在抽象類中，除空的方法外，可以定義實例變量和非空的方法，而在接口中，只能定義常量和空的方法。 (3)接口允許多繼承，類僅支持單繼承。 5.2 包 在Java中可以將自己寫的類，按一定的方法歸屬于不同的子目錄中（包）。 在缺省情況下，Java將所有的類歸屬一個缺省包中。在不同的包中可以有同名的類存在。 / 87 大理學院課程教案（教學內(nèi)容） Java中的包與C++中的名字空間相似。5.2.1 package語句 package語句告訴編譯器當前類屬于哪個包。如果沒有package語句，類就存放在無名的缺省包中（即當前目錄中）。 引進包的概念主要是為了名字沖突。 格式: package pkgl[．pkg2[．pkg3]]； 5.2.2 import語句 import語句位于package語句之后，類的定義之前;格式：import package1[.package2].(class-name | *)； 采用*號不影響程序的運行性能，但會影響編譯速度。指明具體類比引入整個包更為合理。5.2.3 包應用舉例 package Base; // 將該類存放在d:myjavaBase包中 public class Base { int friend_data=1;// 友元成員 public int public_data=2;// public成員 private int private_data=3;// private成員 protected int protected_data=4;// protected成員 } package Derived; // 將Base類存放在Derived包中 import Base.*;// 需要使用Base包中的類 public class Derived extends Base{ Base a=new Base(); // 為了讓testData類能調(diào)用該方法，修改為public public void dataUse(){ // System.out.println(a.friend_data); // 不能訪問 System.out.println(a.public_data); // System.out.println(a.private_data); // 不能訪問 // System.out.println(a.protected_data);// 不能訪問 } } // testData.java文件的內(nèi)容如下： import Derived.*; //需要使用Derived包中的類 // 該類位于工作目錄，不需要package語句 public class testData { public static void main(String args[ ]){ Derived d=new Derived(); d.dataUse(); } } / 87 大理學院課程教案（教學內(nèi)容） 課堂練習： 課外練習（作業(yè)）： P108 3~6 第6章 字符串處理 教學目的要求 掌握字符串的分類； 掌握內(nèi)容不可改變的字符串類String； 掌握字符串常量； 掌握內(nèi)容可以改變的字符串類StringBuffer； 掌握字符串應用。 主要內(nèi)容 ? 字符串的分類； ? 內(nèi)容不可改變的字符串類String； ? 字符串常量； ? 內(nèi)容可以改變的字符串類StringBuffer； ? 字符串應用。 重點內(nèi)容 ? 掌握內(nèi)容不可改變的字符串類String； ? 掌握內(nèi)容可以改變的字符串類StringBuffer； ? 掌握字符串應用。 難點內(nèi)容 String和StringBuffer的區(qū)別和聯(lián)系 課時分配 2課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 6.1 字符串的分類 java.lang包中定義了 String和StringBuffer兩個類； 在運行中值不會改變的字符串，用String類存儲；值會改變的字符串用StringBuffer類來存儲。兩個類都有final修飾，這樣可以優(yōu)化字符串的操作。 6.2 String類 String類的定義原型 ： public final class java.lang.String extends java.lang.Object { … } 6.2.1 字符串常量 / 87 ? ? ? ? ? 大理學院課程教案（教學內(nèi)容） 字符串常量屬于String類型;相同的字符串常量屬于同一個對象，占用同一塊空間，例如: // 程序6-1 public class TestConstString{ public static void main(String args[ ]){ String str1=“Hello”, str2=“Hello”; System.out.println(str1==str2); System.out.println(“Java”==“Java”);} } 6.2.2 創(chuàng)建String類對象 用new運算符，并調(diào)用構(gòu)造函數(shù)創(chuàng)建這種類型的對象，常見構(gòu)造函數(shù)如下： 1.public String()采用該構(gòu)造函數(shù)創(chuàng)建一個不含字符的空對象。例如： String str =new String(); 2.public String(char value[ ]) 將字符數(shù)組的內(nèi)容轉(zhuǎn)換為字符串，并賦予新建的對象。例如： char a[ ]={'J','a','v','a'}; String str=new String(a);3.public String(char value[ ], int offset, int count) 例如：char a[ ]={'J','a','v','a'}; String str=new String(a,1,2); // 字符串str的內(nèi)容是“av” 4.public String(String value) 采用value對象的值構(gòu)造一個新的string對象。 例如： String str1=“Java”; String str2=new String(“Java”); System.out.println(str2); System.out.println(str1==str2); 5.public String(StringBuffer Buffer)注意采用字符串常量初始化一個String引用的問題。例如： String str = “abc”;相當于： char data[ ] = {'a', 'b', 'c'};String str = new String(data);應用舉例，注意程序6-2的輸出結(jié)果： public class TestString{ // 程序6-2 public static void main(String args[ ]){ String s1=“Java”, s2=“Java”; String s3=new String(s1); System.out.println(“ s1==s2 is ”+(s1==s2)); / 87 大理學院課程教案（教學內(nèi)容） System.out.println(“ s1==s3 is ”+(s1==s3)); s1=“ABC”; s2=“DEFG”; System.out.println(“ s1==s2 is ”+(s1==s2)); s1=s2; System.out.println(“ s1==s2 is ”+(s1==s2));} } 6.2.3 String類常用方法 1.public int length(): 求串長。例如： String str=“Java” ； System.out.println(str.length());2.public char charAt(int index) 提取指定位置上的字符。 3.public int compareTo(String anotherString) 對字符串內(nèi)容按字典序進行大小比較。例如： public class SortStringArrary{ // 程序6-3 public static void main(String args[ ]){ String str,s[ ]={“Computer”,“CHINA”,“world”,“U.S.A”};int i,j,k; System.out.print(“排序之前：”);for(i=0;i System.out.print(“t”+s[i]);for(i=0;i for(k=i,j=i+1;j if(s[k].compareTo(s[j])>0) k=j; str=s[i]; s[i]=s[k]; s[k]=str;// 注意該行的含義 } System.out.print(“n排序之后：”);for(i=0;i System.out.print(“t”+s[i]); } } 4.char[ ] toCharArray() 將String對象轉(zhuǎn)換到一個字符數(shù)組中，例如： String s=“Hello,Java!”; char a[ ]; a=s.toCharArray(); for(int i=6;i System.out.print(a[i]);5.public boolean equals(String anString) 比較兩個字符串對象的內(nèi)容是否相等。 / 87 大理學院課程教案（教學內(nèi)容） 6.public boolean equalsIgnoreCase(String anotherString) 以忽略大小寫方式，比較兩個字符串對象的內(nèi)容是否相等。 注意：equals()方法與“==” 之間的區(qū)別。例如： public class ConfuseQuestion{ // 程序6-5 public static void main(String args[ ]){ String s1=“java”; String s2=new String(s1); String s3=s2; System.out.println(s1.equals(s2)); System.out.println(s2.equals(s3)); System.out.println(s2==s3); System.out.println(s2.equals(s3));} } 7.public int indexOf(int ch / String str) 在字符串中搜索字符或子串，返回字符或子串在String對象中從左邊起首次出現(xiàn)的位置。如果沒有出現(xiàn)，返回-1。 8.public String substring(int begin, int end) 提取string對象中從begin開始，到end-1結(jié)束的子串，返回提取的子串。 9.public String concat(String str)將str對象接到調(diào)用對象的后面，返回新串。例如： String s1=“Hello ” , s2=“Java” , s3; s3=s1.concat(s2); System.out.println(s3);注意：如果參數(shù)str為空（null），則concat方法不創(chuàng)建新串，而僅僅返回當前串，10.public String replace(char oldChar, char newChar) 將String對象中所有的oldChar字符替換為newChar，返回替換后的新串。例如： String path=“d:/myjava/documents”; System.out.println(path.replace('/' , '')); public String toString() 返回當前字符串對象本身。 12.public static String valueOf(各種類型 f) 將各種數(shù)據(jù)類型轉(zhuǎn)換成一個相應的字符串表示，該方法是一個static方法。 程序6-6演示了valueOf()方法的應用。 程序6-7自學。 public class TestValueOf{ // 程序6-6 public static void main(String args[ ]){ char a[ ]={'A','B','C','D','E','F'}; int i=123456; float f=3.14159f; boolean b=true; Object o=null; / 87 大理學院課程教案（教學內(nèi)容） System.out.println(String.valueOf(a)); System.out.println(String.valueOf(a,2,3)); System.out.println(String.valueOf(i)); System.out.println(String.valueOf(f)); System.out.println(String.valueOf(b)); System.out.println(String.valueOf(o));} } 6.2.4 Java應用程序的命令行參數(shù) 應用程序可以通過main方法的String數(shù)組，訪問由解釋器傳遞的命令行參數(shù)。例如： public class ShowMainArguments{ //程序6-8 public static void main(String args[ ]){ for(int i = 0;i < args.length;i++) System.out.println(args[ i ]); } } 6.3 StringBuffer類 StringBuffer類對象是一個內(nèi)容可以改變的字符串。可以減少由于少量字符的插人而引起的空間分配問題。 StringBuffer類的原型： public final class java.lang.StringBuffer extends java.lang.Object { … } StringBuffer類對象有一塊緩沖區(qū)，字符串被存放在緩沖區(qū)中，緩沖區(qū)的大小可以隨程序的需要進行調(diào)整。緩沖區(qū)的大小稱為對象的容量。 當修改對象的內(nèi)容時，只要StringBuffer對象包含的字符個數(shù)沒有超出容量，就不會分配新的空間，而直接在原空間內(nèi)進行修改。若字符的個數(shù)超出了容量，該對象會自動調(diào)整其容量，從而適應新的存儲。 6.3.1 創(chuàng)建StringBuffer類對象 StringBuffer類的構(gòu)造函數(shù)有三種方式： 1.public StringBuffer()創(chuàng)建一個內(nèi)容為空的StringBuffer對象，容量為16。 例如：StringBuffer s=new StringBuffer();2.public StringBuffer(int length)初始內(nèi)容為空，容量為length指定的大小。注意：length應大于等于0，不能為負數(shù)，否則會產(chǎn)生異常。例如： StringBuffer s2=new StringBuffer(2);3.public StringBuffer(String str) 初始內(nèi)容和參數(shù)str的內(nèi)容相同，容量為參數(shù)str的長度加上16。例如： String s1=“Java”; StringBuffer s2=new StringBuffer(s1);則s2的容量是20，內(nèi)容是“Java”。 / 87 大理學院課程教案（教學內(nèi)容） 6.3.2 StringBuffer類常用方法 1.public int length() 返回字符串的長度 2.public int capacity() 返回緩沖區(qū)大小 3.public void setLength(int newLength) 指定對象的長度，將對象的內(nèi)容進行裁減。如果參數(shù)小于對象的長度，則將對象截斷；如果參數(shù)大于等于對象的長度，則填充空字符('u0')擴充新增加的部分。4.public void ensureCapacity(int NewCapacity) 設定對象的緩沖區(qū)的大小，若參數(shù) 小于對象的容量，則新的設置將不起作用，也就是說容量只能擴大而不能縮小。 程序6-9演示了這幾個方法的具體應用。 public class TestCapacity{ // 程序6-9 public static void main(String args[ ]){ String s=“Java”;StringBuffer str=new StringBuffer(s); System.out.println(“Length=”+str.length());System.out.println(“Capacity=”+str.capacity());str.setLength(8); // 設置長度為8 str.ensureCapacity(80);// 設置容量為80 System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); str.setLength(3); str.ensureCapacity(20);System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); } } 5.public void setCharAt(int index, char ch) 將參數(shù)index指定位置上的字符，設置成參數(shù)ch 指定的字符。例如： StringBuffer str=new StringBuffer(“Hello,Java”); str.setCharAt(3,'L'); 則str的內(nèi)容變成了“HelLo,Java” 6.public StringBuffer append(多種數(shù)據(jù)類型) 將其它類型的數(shù)據(jù)添加到StringBuffer對象的尾部，返回修改后的StringBuffer對象。 例如：StringBuffer s1,s2=new StringBuffer(); s1=s2; // s1和s2代表同一個對象 s2.append(3.14).append(' ').append(“Java”); / 87 大理學院課程教案（教學內(nèi)容） System.out.println(s1==s2); // 輸出true System.out.println(s1); // 輸出3.14 Java 7.public String toString() 該方法把StringBuffer對象的內(nèi)容復制到一個新的String類對象中，返回這個新的String類對象。例如程序6-10。 public class BufferToString{ // 程序6-10 public static void main(String args[ ]){ String s1;StringBuffer s2=new StringBuffer(“Hello ”); s1=s2.append(“Java!”).toString();System.out.println(“s1=”+s1+“"+”s2=“+s2); } } 8.public StringBuffer insert(int offset, 多種類型 b)該方法是將一個其它類型的對象b插入到offset指定的位置。例如： StringBuffer str=new StringBuffer(” Java!“); // 將字符串”Hello“插入到下標為0的位置 str.insert(0,”Hello“); System.out.println(”str= “+str);輸出結(jié)果為： str= Hello Java! 6.4 應用舉例 略 課堂練習： 無 課外練習（作業(yè)）： P119 2、3、4 第7章 異常處理 教學目的要求 了解異常的層次結(jié)構(gòu)； 掌握異常處理語句； 了解自定義異常； 了解異常處理中常用的調(diào)試方法。 主要內(nèi)容 ? 異常的層次結(jié)構(gòu)； ? 異常處理語句； ? 自定義異常； ? 異常處理中常用的調(diào)試方法。 / 87 ? ? ? ? 大理學院課程教案（教學內(nèi)容） 重點內(nèi)容 ? 異常處理語句； 難點內(nèi)容 無 課時分配 1課時 教學方法 講授法、演示法、對比法、實驗驗證法 講授內(nèi)容提要 7.1 異常的層次結(jié)構(gòu) Throwable是異常類的根節(jié)點，定義在java.lang包，它的子類也定義在該包中； Error代表系統(tǒng)錯誤類，由系統(tǒng)直接處理； Exception類及其子類是在程序中可捕捉到的異常。見圖7.1 Throwable Error … AWTError LinkageError VirtualMachineError RuntimeException ArithmeticException ArrayIndexOutOfBoundsException … Interrupted Exception FileNotFoundException… EOFException AWTException IOException Exception 1.java.lang.ArithmeticException 0作除數(shù)（包括模），將產(chǎn)生這類異常。例如：int x=0 , y; y=100/x; 2.java.lang.ArrayIndexOutOfBoundsException 例如：int a[ ]=new int[10]; a[10]=0; 3.java.lang.ArrayStoreException 例如：int a[ ]=new int[10]; boolean b[ ]=new boolean[10]; System.arraycopy(a,0,b,3,6);//有異常 4.java.lang.ClassCastException 例如： Object obj=new Object(); int a[ ]=(int[ ])(obj); 5.java.lang.IndexOutOfBoundsException 例如：char ch=”ABC“.charAt(99); / 87 大理學院課程教案（教學內(nèi)容） 注意: 2 是5的子類。 6.java.lang.NegativeArraySizeException 例如： int a[ ]=new int[-10]; 7.java.lang.NullPointerException 例如：int a[ ]=null; System.out.print(a.length);7.2 異常處理語句 缺省的異常處理的情況，例如： public class DefaultException{ // 程序7-1 public static void main(String args[ ]){ int a,b=0; a=2/b; // 此處有異常 System.out.println(“a=”+a);// 不運行此行 } } 異常處理語句有try、catch、finally、throw和throws。異常處理的形式為： try{ 程序執(zhí)行體 }catch(異常類型1 異常對象1){ 異常處理程序體1 }catch(異常類型2 異常對象2){ 異常處理程序體2 }finally { 異常處理結(jié)束前的執(zhí)行程序體 } 7.2.1 try和catch語句 try語句指明可能產(chǎn)生異常的代碼段;catch語句在try語句之后，用于捕捉異常，一個try語句可以有多個catch語句與之匹配。異常處理以后，程序從try語句代碼段后繼續(xù)執(zhí)行。例如：程序7-2。public class TryCatchTest{ // 程序7-2 public static void main(String args[ ]){ int a=99,b=0,c; try{ System.out.println(”產(chǎn)生異常之前“); c=a/b; // 該行有異常 System.out.println(”產(chǎn)生異常之后“);}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”處理下標越界異常“);}catch(ArithmeticException e){ System.out.println(”處理算術(shù)異常“);} System.out.println(”異常處理結(jié)束“); / 87 大理學院課程教案（教學內(nèi)容） } } 注意：用catch語句捕捉異常時，若找不到相匹配的catch語句，將執(zhí)行缺省的異常處理。例如： int a=99,b=0,c; try{ c=a/b;//產(chǎn)生的異常和捕捉的異常類型不一致 }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”處理異常“); } 注意：當有多個catch語句時，系統(tǒng)依照先后順序逐個檢查。例如： try{ c=a/b; }catch(ArithmeticException e){ System.out.println(”Divided by zero“);}catch(RuntimeException e){ System.out.println(”Divided by zero“);} 7.2.2 finally語句 無論是否產(chǎn)生異常，finally語句指明的代碼一定被執(zhí)行。例如： public class testFinally{ // 程序7-3 public static void main(String args[ ]){ int a,b=0; for(int i=0;i<=3;i++){ System.out.println(”Test No: “+(i+1));try{ switch(i){ case 0: a=3/b; break; case 1: int c[ ]=new int[10]; c[10]=0; break; case 2: char ch=”ABC“.charAt(99); break; case 3: return; } }catch(ArithmeticException e){ System.out.println(“零作除數(shù)！”); }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”數(shù)組下標越界！“);}catch(IndexOutOfBoundsException e){ System.out.println(”下標越界！“);}finally{ / 87 大理學院課程教案（教學內(nèi)容） System.out.println(”在finally塊中！“);} } } } 7.2.3 throw語句 throw語句用于指出當前行有異常，當程序執(zhí)行到throw語句時，流程就轉(zhuǎn)到相匹配的異常處理語句，所在的方法也不再返回值。 throw語句可以將異常對象提交給調(diào)用者，以進行再次處理。例如：程序7-4。public class ThrowException{ // 程序7-4 public static void Test(){ try{ int c[ ]=new int[10]; c[10]=0;}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”t 數(shù)組下標越界！“); throw e; // 異常拋出點 //System.out.println(“t產(chǎn)生異常后!”); 該行無法通過編譯 } } public static void main(String args[ ]){ try{ Test();}catch(IndexOutOfBoundsException e){ System.out.println(”t 下標越界！“);}finally{ System.out.println(”t 在finally塊中！“); } } } 7.2.4 throws語句 throws語句指明方法中可能要產(chǎn)生的異常類型，由調(diào)用者進行異常處理。例如： import java.io.*; // 程序7-6 public class testThrows { public static String readString()throws IOException{ int ch; String r=”"; boolean done=false; while(!done){ ch=System.in.read(); if(ch<0 || ch==0xd) done=true; / 87 楚雄師范學院 2015年春季期末Java程序設計報告 項目名稱：基于Java平臺開發(fā)的五子棋程序設計 學 院： 物理與電子科學學院 專 業(yè)：電子信息科學與技術(shù) 班 級：2 0 1 3 級 電 信 一 班 組員姓名：楊邦桂 許勇 董俊宏 課程教師： 程 滿 目錄 引言...........................................................................................................................................4 第一章 設計目的和要求.........................................................................................................4 第二章JAVA語言概述.........................................................................................................4 2.1 JAVA簡介........................................................................................................................4 2.1.1 JAVA的基本特點.....................................................................................................4 2.2 JAVA工具 JDK............................................................................................................5 第三章 程序的設計思路和算法.............................................................................................5 3.1 人機博弈的要點............................................................................................................5 3.2 五子棋特點及規(guī)則......................................................................................................5 3.3 設計思路......................................................................................................................6 3.3.1...................................................................................................................................6 第四章 測試及運行效果.........................................................................................................6 4.1棋盤系統(tǒng)主界面.............................................................................................................6 4.2下期博弈過程界面.........................................................................................................7 4.3黑方贏的結(jié)果.................................................................................................................7 4.4白方贏的結(jié)果.................................................................................................................8 第五章 設計體會與總結(jié).........................................................................................................9 附錄.........................................................................................................................................10 源程序代碼及簡要說明：.................................................................................................10 引言 隨著計算機技術(shù)的不斷發(fā)展，網(wǎng)絡技術(shù)的普及范圍越來越廣，網(wǎng)絡能夠提供的服務多樣、便捷，已經(jīng)成為人們生產(chǎn)生活中不可缺少的重要組成部分。如今網(wǎng)絡休閑游戲發(fā)展迅速，它憑借健康、方便、互動性強、益智等諸多優(yōu)點，成為大部分現(xiàn)代人休閑娛樂的首選。 網(wǎng)絡五子棋游戲是使用Java語言開發(fā)的一款游戲。它使用SOCKET建立連接，多線程處理數(shù)據(jù)，以及可嵌入網(wǎng)絡瀏覽器的APPLET作為客戶端，這些特點使這款游戲無論是服務器還是客戶端的實現(xiàn)都相對容易。通過對該軟件的編寫，還可以鞏固學生對以上各種知識的掌握和理解。 第一章 設計目的和要求 1.1 實現(xiàn)一個簡單的五子棋游戲程序，包括如下兩個界面:（1）對弈及角色（黑方先落棋）。 （2）在游戲界面，有游戲欄（開局、悔棋、退出），幫助欄； 顯示區(qū)；棋盤區(qū)。1.2在實際系統(tǒng)中使用、實現(xiàn)人工智能的相關算法 1.3進一步加深對人工智能算法的理解 第二章JAVA語言概述 2.1 JAVA簡介 JAVA是Sun Microsystem公司開發(fā)的編程語言，是一個簡單，面向?qū)ο螅植际剑忉屝裕瑥妷眩踩c系統(tǒng)無關，可移植，高性能，多線程和動態(tài)的語言。 2.1.1 JAVA的基本特點 (1)簡單性 Java與C++語言非常相近，但Java比C++簡單，它拋棄了C++中的一些不是絕對必要的功能，如頭文件、預處理文件、指針、結(jié)構(gòu)、運算符重載、多重繼承以及自動強迫同型。Java實現(xiàn)了自動的垃圾收集，簡化了內(nèi)存管理的工作。 (2)面向?qū)ο?/p> Java提供了簡單的類機制和動態(tài)的構(gòu)架模型。對象中封裝了它的狀態(tài)變量和方法，很好地實現(xiàn)了模塊化和信息隱藏；而類則提供了一類對象的原型，通過繼承和重載機制，子類可以使用或重新定義父類或超類所提供的方法，從而既實現(xiàn)了代碼的復用，又提供了一種動態(tài)的解決方案。 (3)多線程 多線程使應用程序可以同時進行不同的操作，處理不同的事件。在多線程機制中，不同的線程處理不同的任務，他們之間互不干涉，不會由于一處等待影響其他部分，這樣容易實現(xiàn)網(wǎng)絡上的實時交互操作。 (4)分布性 Java是面向網(wǎng)絡的語言。通過它提供的類庫可以處理TCP/IP協(xié)議，用戶可以通過URL地址在網(wǎng)絡上很方便的訪問其他對象。（5）體系結(jié)構(gòu)中立 Java是一種網(wǎng)絡語言，為使Java程序能在網(wǎng)絡的任何地方運行，Java解釋器生成與體系結(jié)構(gòu)無關的字節(jié)碼結(jié)構(gòu)的文件格式。為了使Java的應用程序能不依賴于具體的系統(tǒng)，Java語言環(huán)境還提供了用于訪問底層操作系統(tǒng)功能的類組成的包，當程序使用這些包時，可以確保它能運行在各種支持Java的平臺上。 (6)安全性 用于網(wǎng)絡、分布環(huán)境下的Java必須要防止病毒的入侵，Java不支持指針，一切對內(nèi)存的訪問都必須通過對象的實例變量來實現(xiàn)，這樣就防止了程序員使用欺騙手段訪問對象的私有成員，同時也避免了指針操作中容易產(chǎn)生的錯誤。 2.2 JAVA工具 JDK （1）Java編譯器 Java編譯器將Java源代碼文件編譯成可執(zhí)行的Java字節(jié)碼。Java源代碼文件的擴展名為.java，Java編譯器把這種擴展名的文件編譯成擴展名為.class的文件。源文件中的每個類在編譯后都將產(chǎn)生一個class文件，這意味一個Java源代碼文件可能編譯生成多個class文件。 （2）Java解釋器 Java解釋器對編譯生成的字節(jié)碼格式的可執(zhí)行程序的運行提供支持，它是運行非圖形Java程序的命令行工具。 第三章 程序的設計思路和算法 3.1 人機博弈的要點 人機對弈的程序，至少應具備以下5個部分： (1)某種在機器中表示棋局的方法，能夠讓程序知道博弈的狀態(tài)。(2)產(chǎn)生合法走法的規(guī)則，以使博弈公正地進行，并可判斷人類對手是否亂走。(3)從所有合法的走法中選擇最佳的走法技術(shù)。(4)一種評估局面優(yōu)劣的方法，用以同上面的技術(shù)配合做出智能的選擇。(5)一個界面，有了他，這個程序才能用。 3.2 五子棋特點及規(guī)則 五子棋的娛樂性強、規(guī)則簡單、易學、流行性廣。普通人不需長時間專門訓練即可自如行棋。因此極受大眾歡迎。五子棋的規(guī)則為： (1)棋盤 采用像圍棋盤一樣的15路或19路線的棋盤，在此采用19路的棋盤。 (2)下法 兩人分別執(zhí)黑白兩色棋子。輪流在棋盤上選擇一個無子的交叉點落子，無子的交叉點又被稱為空點。 (3)輸贏判斷 黑、白雙方有一方的五個棋子在橫、豎或斜方向上連接成一線即為該方贏。 (4)特殊規(guī)定 職業(yè)五子棋雖然對黑棋采取了種種限制，但黑子先行的優(yōu)勢依然很大。因此，在高段位的職業(yè)比賽中，又出現(xiàn)了三種特殊的規(guī)定。 a.指定打法：是指比賽雙方按照約定好的開局進行對弈，由白棋先行。 b.三手可交換：是指黑棋下盤面第3手棋后，白方在下第四手之前，如感覺黑方棋形不利于己方，可提出交換，即執(zhí)白棋一方變?yōu)閳?zhí)黑棋一方，而黑方不可以不換。 c.五手兩打法：是指黑棋在下盤面上關鍵的第5手棋時，必須下兩步棋，讓白棋在這兩步棋中拿掉一粒棋子，然后再繼續(xù)對弈。一般說來，白棋肯定拿掉對白方不利的一點，而保留對黑方較為不利的那點讓黑方行棋。3.3 設計思路 3.3.1開始——下棋——判斷輸贏——結(jié)束游戲或重新再來——退出。 1.建立一個棋盤類，繪制棋盤的樣式，在棋盤面板上添加各種按鈕及相應胡觸發(fā)事件。同時注意面板的設計，使面板設計的盡量胡的合理美觀。2.編寫一個功能判斷落子的位置及畫出相應的黑白棋子。3.判斷勝負 第四章 測試及運行效果 4.1棋盤系統(tǒng)主界面 圖4-1初始化棋盤效果，玩家為黑棋 4.2下棋博弈過程界面 圖4-2黑白棋博弈 4.3黑方贏的結(jié)果 圖4-3黑方勝利界面 4.4白方贏的結(jié)果 圖4-4白方勝利界面 第五章 設計體會與總結(jié) Java編程最強大的地方不是它是容易學，或者難學，而是它擁有一個強大的庫。JAVA是一個完全面向?qū)ο蟮恼Z言，JAVA的命名規(guī)則是很容易讓人接受的。而且容易被編程人員記住。經(jīng)過實踐訓練，對JAVA的綜合應用能力有了較大的提高，另外對JAVA的特點有了更深層次的認識。這次實踐中使用的代碼雖然不長，但類與類之間也有很強的邏輯關系，這就是面向?qū)ο笳Z言的最大優(yōu)勢，這樣可使我們更輕松的運用JAVA。 經(jīng)過努力，查閱相關資料，終于完成該課題，雖然效果不是很好，但親手做過之后還是很有成就感的。 通過此次課程設計，將我本學期所學的JAVA知識得到鞏固和應用，在設計的過程中我遇到了很到問題，不過在老師和同學們的幫助和自己的思考下還是很好的完成了。這此課程設計還讓我懂得了寫程序不能閉門造車，要努力拓寬知識面，開闊視野，拓展思維。它還讓我學會了在網(wǎng)上查閱那些無限的資料。通過對此課題的開發(fā)，使我對用Eclipse開發(fā)平臺有了一個比較清楚的認識，體會到理論和實踐的重要性。由于自己的分析設計和程序經(jīng)驗不足，該系統(tǒng)設計和實現(xiàn)過程中，還有許多沒有完善的地方，比如用戶界面設計不夠美觀，異常出錯處理比較差等多方面問題，這些都有待進一步完善和提高。 附錄 源程序代碼及簡要說明： import java.awt.*;import java.awt.event.*;import javax.swing.*;import java.util.Timer;import java.util.TimerTask;import java.lang.Thread;public class WZQ_2008 extends Frame implements ActionListener { Timer t=new Timer(true);//Thread mt=new MyThread(this);MenuBar mb=new MenuBar();Menu myx=new Menu(“游戲”);Menu mbz=new Menu(“幫助”);MenuItem mikj=new MenuItem(“開局”);MenuItem mihq=new MenuItem(“悔棋”);MenuItem mitc=new MenuItem(“退出”);MenuItem migy=new MenuItem(“關于”);int x=0;int y=0;String stb=“五子棋游戲 請黑方落子”;String stw=“五子棋游戲 請白方落子”;boolean isBlack=true;String str=“Game Over”;boolean over=false;int count=0;int jj=30;int r=25;String str1;int [][]date=new int[15][15]; int i=0;public WZQ_2008(){ this.setMenuBar(mb); mb.add(myx); mb.add(mbz); myx.add(mikj);mikj.addActionListener(this);mikj.setEnabled(false);myx.add(mihq);mihq.setEnabled(false);mihq.addActionListener(this);myx.add(mitc);mitc.addActionListener(this);mbz.add(migy);migy.addActionListener(this);this.setTitle(stb);this.setBounds(100,100,485,500);this.setBackground(new Color(206,148,49));this.setResizable(false);this.addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });this.addMouseListener(new MouseAdapter(){ public void mousePressed(MouseEvent e){ if(over) { return; } x=(e.getX()-30+jj/2)/jj; y=(e.getY()-60+jj/2)/jj; if(x<0||x>14||y<0||y>14) { return; } if(date[x][y]!=0) { return; } if(isBlack) { setTitle(stw); date[x][y]=1; } else { setTitle(stb); date[x][y]=2; } mikj.setEnabled(true); mihq.setEnabled(true); isBlack=!isBlack; pd(); repaint(); } });this.setVisible(true); } public void pd(){ int xq=0,xz=14;int yq=0,yz=14;if(x-4>0){ xq=x-4;} if(x+4<14){ xz=x+4;} if(y-4>0){ yq=y-4;} if(y+4<14){ yz=y+4;} pdh(xq,xz);count =0;pds(yq,yz);count=0;pdfx(xq,xz);count=0;pdzx(xq,xz);} public void pdzx(int xq,int xz){ for(int i=xq;i<=xz;i++){ if(y+x-i<0) { break; } if(y+x-i>14) { continue; } if(date[i][y+x-i]==date[x][y]) { count++; isOver(); } else { count=0; } } } public void pdfx(int xq,int xz){ for(int i=xq;i<=xz;i++){ if(y-x+i<0) { continue; } if(y-x+i>14) { break; } if(date[i][y-x+i]==date[x][y]) { count++; isOver(); } else { count=0; } } } public void pds(int yq,int yz){ for(int i=yq;i<=yz;i++){ if(date[x][i]==date[x][y]) { count++; isOver(); } else { count=0; } } } public void pdh(int xq,int xz){ for(int i=xq;i<=xz;i++){ if(date[i][y]==date[x][y]) { count++; isOver(); } else { count=0; } } } public void isOver(){ if(count==5){ over=true; if(date[x][y]==1) { str1=“黑方勝利”; } else if(date[x][y]==2) { str1=“白方勝利”; } //mt.start(); //for(int i=0) t.schedule(new MyTimer(this),100,500); this.repaint();} } public void actionPerformed(ActionEvent e){ if(e.getSource()==mikj){ mikj.setEnabled(false); mihq.setEnabled(false); for(int i=0;i { for(int j=0;j { date[i][j]=0; } } isBlack=true; this.setTitle(stb); over=false; this.repaint();} if(e.getSource()==mihq){ mihq.setEnabled(false); date[x][y]=0; if(isBlack) { this.setTitle(stw); } else { this.setTitle(stb); } isBlack=!isBlack; this.repaint();} if(e.getSource()==mitc){ this.dispose();} if(e.getSource()==migy){ new MyAbout(this);} } public void update(Graphics g){ paint(g);} public void paint(Graphics g){ Image ii=this.createImage(485,500);Graphics gg=ii.getGraphics();paintBuffer(gg);g.drawImage(ii,0,0,this);} public void paintBuffer(Graphics g){ for(int i=0;i<15;i++){ g.drawLine(30,60+i*jj,30+14*jj,60+i*jj); g.drawLine(30+i*jj,60,30+i*jj,60+14*jj);} for(int i=0;i for(int j=0;j { if(date[i][j]==1) { g.setColor(Color.BLACK); } else if(date[i][j]==2) { g.setColor(Color.WHITE); } else { continue; } //抗鋸齒,使繪畫出來的圖形更圓滑 Graphics2D g2d=(Graphics2D)g; g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING，RenderingHints.VALUE_ANTIALIAS_ON); g.fillOval(30-jj/2+i*jj,60-jj/2+j*jj,r,r); } } if(over) { g.setColor(Color.GRAY); g.setFont(new Font(“楷體”,3,70)); g.drawString(str,45,250); g.drawString(str1,48,350); g.setColor(Color.RED); g.setFont(new Font(“楷體”,3,70)); g.drawString(str,50,253); g.drawString(str1,60,353); mihq.setEnabled(false); } } public static void main(String[]args){ new WZQ_2008(); } } class MyAbout extends Dialog { Button bok=new Button(“確定”);public MyAbout(WZQ_2008 wzq){ super(wzq,“百納科技五子棋”,true); this.add(bok); bok.setBounds(180,250,60,20); this.setLayout(null); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); } }); bok.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { dispose(); } }); this.setBounds(100,100,400,300); this.setResizable(false); this.setVisible(true);} public void paint(Graphics g){ Image ii=new ImageIcon(“about.jpg”).getImage(); g.drawImage(ii,0,0,this);} } class MyTimer extends TimerTask { WZQ_2008 wzq;boolean b=true;public MyTimer(WZQ_2008 wzq){ this.wzq=wzq;} public void run(){ if(!wzq.over) { return; } if(b) { wzq.str=“Game Over”; } else { wzq.str=“"; } b=!b; wzq.repaint(); wzq.i++; if(wzq.i==11) { cancel(); wzq.i=0; } System.out.println(wzq.i);} } /*class MyThread extends Thread { WZQ_2008 wzq;boolean b=true;public MyThread(WZQ_2008 wzq){ this.wzq=wzq;} public void run(){ if(!wzq.over) { return; } if(b) { wzq.str=”Game Over“; } else { wzq.str=”"; } b=!b; wzq.repaint();} }*/第三篇：Java程序設計教案
第四篇：java程序設計教案
第五篇：Java程序設計報告
![下載java程序設計[優(yōu)秀范文5篇]word格式文檔](http://static.xiexiebang.com/skin/default/images/icon_word.png){kind=icon}
點擊咨詢 