《面向?qū)ο缶幊?JAVA編程綜合實驗報告》由會員分享，可在線閱讀，更多相關(guān)《面向?qū)ο缶幊?JAVA編程綜合實驗報告（22頁珍藏版）》請在裝配圖網(wǎng)上搜索。
1、 成績：
JAVA編程B綜合實驗報告
實驗名稱：面向?qū)ο缶幊?
實驗時間：2012年 5月 31日星期四
JAVA編程B綜合實驗報告
一、實驗名稱
面向?qū)ο缶幊?
二、實驗目的
1、理解Java語言是如何體現(xiàn)面向?qū)ο缶幊袒舅枷耄?
2、了解類的封裝方法，以及如何創(chuàng)建類和對象，
3、了解成員變量和成員方法的特性。
4、掌握OOP方式進行程序設(shè)計的方法，
5、了解類的繼承性和多態(tài)性的作用。
三、實驗環(huán)境配置
Windows XP、JDK 1.6與Eclipse 3.5
四、實驗記錄
2、
1）創(chuàng)建Applet 應用小程序
2）創(chuàng)建對象并使用對象
3）使用修飾符
五、代碼分析
一、創(chuàng)建Applet 應用小程序
1、創(chuàng)建一個Applet應用程序文件。
（1）程序功能：建立一個Applet小程序，使其可以進行簡單的加法運算。該程序要包含類、接口、屬性、方法、事件等面向?qū)ο蟮幕驹亍?
（2）程序源代碼如下。
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Applet1 extends Applet implements Action
3、Listener {
Label label1 = new Label("+");
Label label2 = new Label("=");
TextField field1 = new TextField(6);
TextField field2 = new TextField(6);
TextField field3 = new TextField(6);
Button button1 = new Button("相加");
public void init() { // 初始化
add(field1);
add(label1);
ad
4、d(field2);
add(label2);
add(field3);
add(button1);
button1.addActionListener(this);
}
public void actionPerformed(ActionEvent e) { // 處理按鈕事件
int x = Integer.parseInt(field1.getText())
+ Integer.parseInt(field2.getText());
field3.setText(Integer.toString(x)); // 數(shù)值轉(zhuǎn)換為字符串
5、
}
}
2、編寫一個瀏覽Applet應用程序的頁面文件Applet1.HTML，源代碼如。
3、將Applet1.java 源程序編譯為Applet1.class文件
4、使用瀏覽器或使用小程序查看器瀏覽Applet1.HTML文件（即在命令提示符窗口輸入：appletviewer Applet1.HTML）。
二、創(chuàng)建對象并使用對象
1、編寫Applet 程序
（1）程序功能：這個Applet程序要在頁面上輸出兩
6、個矩形，并伴有文字輸出。
（2）Applet2.java程序的源代碼如下。
import java.awt.*;
import java.applet.Applet;
public class Applet2 extends Applet {
MyBox b1 = new MyBox();// 創(chuàng)建對象b1
MyBox b2 = new MyBox(170, 20, 60, 60); // 創(chuàng)建對象b2
public void paint(Graphics g) {
b1.setPosition(20, 20);
b1.setSize(60, 60)
7、;
b1.draw(g);
g.drawString("矩形 1 的 X 位置: " + b1.getX(), 20, 100);
g.drawString("矩形 1 的 Y 位置: " + b1.getY(), 20, 120);
b2.draw(g);
g.drawString("矩形 2 的 X 位置: " + b2.getX(), b2.getX(), b2.getY() + 80);
g.drawString("矩形 2 的 Y 位置: " + b2.getY(), b2.getX(), b2.getY() + 100);
}
}
c
8、lass MyBox {
private int x, y, width, height;
MyBox() {
x = 0;
y = 0;
width = 0;
height = 0;
}
MyBox(int xPos, int yPos, int w, int h) {
x = xPos;
y = yPos;
width = w;
height = h;
}
public void setPosition(int xPos, int yPos) {
x = xPos;
y = yPos;
}
9、
public void setSize(int w, int h) {
width = w;
height = h;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void draw(Graphics g) {
g.drawRect(x, y, width, height);
}
}
2、編寫一個瀏覽Applet 應用程序的頁面文件Applet2.HTML。
3、將Applet2.java 源程序編譯為Applet2.class 文件
4、使用瀏覽器或使用小程序查看器瀏覽Applet2.HTML 文件（即在命令提示符下輸入：appletviewer Applet2.HTML）。
三、使用修飾符
有時需要公開一些變量和方法，有時需要禁止其他對象使用變量和方法，這時可以使用修飾符來實現(xiàn)這個目的。
常用的修飾符有：[public] [private] [protected] [package] [static] [final] [tr
11、ansient] [volatile]，不同修飾符的訪問控制權(quán)限如下表所示。
1、程序功能：通過兩個類StaticDemo、JAVA_B_3_1 說明靜態(tài)變量/方法與實例變量/方法的區(qū)別。
2、編寫類文件JAVA_B_3_1.java，程序源代碼如下。
class StaticDemo {
static int x;
int y;
public static int getX() {
return x;
}
public static void setX(int newX) {
x = newX;
}
public int ge
12、tY() {
return y;
}
public void setY(int newY) {
y = newY;
}
}
public class JAVA_B_3_1 {
public static void main(String[] args) {
System.out.println("靜態(tài)變量x=" + StaticDemo.getX());
System.out.println("實例變量y=" + StaticDemo.getY()); // 非法，編譯時將出錯
StaticDemo a = new StaticDemo
13、();
StaticDemo b = new StaticDemo();
a.setX(1);
a.setY(2);
b.setX(3);
b.setY(4);
System.out.println("靜態(tài)變量a.x=" + a.getX());
System.out.println("實例變量a.y=" + a.getY());
System.out.println("靜態(tài)變量b.x=" + b.getX());
System.out.println("實例變量b.y=" + b.getY());
}
}
3、對上面的源程序進
14、行編譯，會出現(xiàn)錯誤。
4、將源程序中的出錯語句刪除或使用解釋符//隱藏起來，例如， //System.out.println("實例變量y="+StaticDemo.getY());
5、重新編譯并運行該程序，記錄程序運行過程。
static 聲明的成員變量/方法被視為類的成員變量/方法，而不把它當作實例對象的成員變量/方法。換句話說，靜態(tài)變量/方法是類固有的，可以直接引用，其它成員變量/方法僅僅被聲明，生成實例對象后才存在，才可以被引用。基于這樣的事實，也把靜態(tài)變量/方法稱為類變量/方法，非靜態(tài)變量稱為實例變量/方法。
從實驗結(jié)果可以得出以下幾點結(jié)論：
類的靜態(tài)變量可以直接引用，而
15、非靜態(tài)變量則不行。類的靜態(tài)變量相當于某些程序語言的全局變量。
靜態(tài)方法只能使用靜態(tài)變量，不能使用實例變量。因為對象實例化之前，實例變量不可用。
類的靜態(tài)變量只有一個版本，所有實例對象引用的都是同一個版本。
對象實例化后，每個實例變量都被制作了一個副本，它們之間互不影響。
四、方法中參數(shù)傳遞的練習
在其它語言中，函數(shù)調(diào)用或過程調(diào)用時參數(shù)有傳值調(diào)用和傳地址調(diào)用之分。在Java 中，方法中的參數(shù)傳遞可以分為傳值調(diào)用或?qū)ο蠓椒ㄕ{(diào)用等方式。傳值調(diào)用即傳遞的參數(shù)是基本數(shù)據(jù)類型，調(diào)用方法時在方法中將不能改變參數(shù)的值，這意味著只能使用它們。對象調(diào)用是指先調(diào)用對象，再調(diào)用對象的方法，這種方式可以修改允
16、許存取的成員變量。所以，如果不想改變參數(shù)的值，可以采用傳值調(diào)用的方法。如果想改變參數(shù)的值，可采用對象調(diào)用的方法，間接修改參數(shù)的值。
1、編寫一個傳值調(diào)用的程序文件JAVA_B_3_2.java。
（1）程序功能：程序首先給整型變量x 和y 賦一個初值10，然后使用傳值調(diào)用方式調(diào)用方法ff1對x 和y 做乘方及輸出x 和y 的乘方值，最后再輸出x 和y 的乘方值。
（2）程序源代碼如下。
class JAVA_B_3_2 {
public static void main(String[] args) {
int x = 10, y = 10;
ff1(x, y);
17、
System.out.println("x=" + x + ", y=" + y);
}
static void ff1(int passX, int passY) {
passX = passX * passX;
passY = passY * passY;
System.out.println("passX=" + passX + ", passY=" + passY);
}
}
（3）編譯JAVA_B_3_2.java，記錄并分析其運行結(jié)果。
這個程序沒有實現(xiàn)預期的結(jié)果，原因是ff1 方法采用了傳值調(diào)用。調(diào)用ff1方法時，將產(chǎn)生兩個參數(shù)p
18、assX和passY，x和y的值被傳遞給這兩個參數(shù)。盡管在方法中計算了參數(shù)的平方，但從ff1方法返回后，參數(shù)消失，此時x和y的值仍是初值。
2、編寫一個調(diào)用對象方法的程序文件JAVA_B_3_3.java。
（1）程序功能：通過調(diào)用對象的方法在方法調(diào)用后修改了成員變量的值。
（2）JAVA_B_3_3.java 程序源代碼如下。
class JAVA_B_3_3 {
public static void main(String[] args) {
Power p = new Power();
p.ff2(10, 10);
System.out.println(
19、"方法調(diào)用后 x=" + p.x + ", y=" + p.y);
}
}
class Power {
int x = 10, y = 10;
void ff2(int passX, int passY) {
System.out.println("初始時 x=" + x + ", y=" + y);
x = passX * passX;
y = passY * passY;
System.out.println("方法調(diào)用中 x=" + x + ", y=" + y);
}
}
（3）編譯JAVA_B_3_3.java，記錄并分析其
20、運行結(jié)果。
五、類的繼承性練習
1、進一步理解繼承的含義
新類可從現(xiàn)有的類中產(chǎn)生，并保留現(xiàn)有類的成員變量和方法并可根據(jù)需要對它們加以修改。新類還可添加新的變量和方法。這種現(xiàn)象就稱為類的繼承。
當建立一個新類時，不必寫出全部成員變量和成員方法。只要簡單地聲明這個類是從一個已定義的類繼承下來的，就可以引用被繼承類的全部成員。被繼承的類稱為父類或超類（superclass），這個新類稱為子類。
Java 提供了一個龐大的類庫讓開發(fā)人員繼承和使用。設(shè)計這些類是出于公用的目的，因此很少有某個類恰恰滿足你的需要。你必須設(shè)計自己的能處理實際問題的類，如果你設(shè)計的這個類僅僅實現(xiàn)了繼承，則和父類毫
21、無兩樣。所以，通常要對子類進行擴展，即添加新的屬性和方法。這使得子類要比父類大，但更具特殊性，代表著一組更具體的對象。繼承的意義就在于此。
2、創(chuàng)建公共類JAVA_B_3_4P
（1）編寫程序文件JAVA_B_3_4P.java，源代碼如下。
public class JAVA_B_3_4P {
protected String xm; // 具有保護修飾符的成員變量
protected int xh;
void setdata(String m, int h) // 設(shè)置數(shù)據(jù)的方法
{
xm = m;
xh = h;
}
public v
22、oid print() // 輸出數(shù)據(jù)的方法
{
System.out.println(xm + ", " + xh);
}
}
（2）編譯JAVA_B_3_4P.java，產(chǎn)生類文件JAVA_B_3_4P.class。
3、創(chuàng)建繼承的類
（1）程序功能：通過JAVA_B_3_4P 類產(chǎn)生子類JAVA_B_3_5，其不僅具有父類的成員變量xm（姓名）、xh（學號），還定義了新成員變量xy（學院）、xi（系）。在程序中調(diào)用了父類的print方法，同時可以看出子類也具有該方法。
（2）編寫JAVA_B_3_5.java 程序，源代碼如下。
class JAVA_B
23、_3_5 extends JAVA_B_3_4P {
protected String xy;
protected String xi;
public static void main(String args[]) {
JAVA_B_3_4P p1 = new JAVA_B_3_4P();
p1.setdata("帥零", 12321);
p1.print();
JAVA_B_3_5 s1 = new JAVA_B_3_5();
s1.setdata("郭麗娜", 12345); // 調(diào)用父類的成員方法
s1.xy = "經(jīng)濟管理學院";
24、// 訪問本類的成員變量
s1.xi = "信息管理系"; // 訪問本類的成員變量
s1.print();
System.out.print(s1.xm + ", " + s1.xy + ", " + s1.xi);
}
}
（3）編譯并運行程序，記錄并分析其運行結(jié)果。
3、了解成員變量的隱藏方式
所謂隱藏是指子類重新定義了父類中的同名變量，在子類Line中重新定義了x 為x1，y 為y1，隱藏了父類Point 中的兩個成員變量x和y。子類執(zhí)行自己的方法時，操作的是子類的變量，子類執(zhí)行父類的方法時，操作的是父類的變量。在子類中要特別注意成員變量的命名，防止無
25、意中隱藏了父類的關(guān)鍵成員變量，這有可能給程序帶來麻煩。
4、了解成員方法的覆蓋方式
（1）方法覆蓋的定義與作用
通過繼承子類可以繼承父類中所有可以被子類訪問的成員方法，但如果子類的方法與父類方法同名，則不能繼承，此時稱子類的方法覆蓋了父類的方法，簡稱為方法覆蓋（override）。方法覆蓋為子類提供了修改父類成員方法的能力。例如，子類可以修改層層繼承下來的Object 根類的toString 方法，讓它輸出一些更有用的信息。下面的程序顯示了在子類Circle 中添加toString 方法，用來返回圓半徑和圓面積信息。
（2）編寫覆蓋Object 類toString 方法的程序文件JAV
26、A_B_3_6.java，源代碼如下。
class Circle {
private int radius;
Circle(int r) {
setRadius(r);
}
public void setRadius(int r) {
radius = r;
}
public int getRadius() {
return radius;
}
public double area() {
return 3.14159 * radius * radius;
}
public String toString
27、() {
return "圓半徑：" + getRadius() + " 圓面積：" + area();
}
}
public class JAVA_B_3_6 {
public static void main(String args[]) {
Circle c = new Circle(10);
System.out.println("\n" + c.toString());
}
}
（3）編譯并運行程序，記錄并分析程序結(jié)構(gòu)及其運行結(jié)果。
5、This、super和super()的使用
（1）程序功能：說明this、super 和super
28、()的用法。程序首先定義Point（點）類，然后創(chuàng)建點的子類Line（線）。最后通過JAVA_B_3_7類輸出線段的長度。
程序中通過super(a,b)調(diào)用父類Point 的構(gòu)造方法為父類的x 和y 賦值。在子類Line的setLine方法中，因為參數(shù)名和成員變量名相同，為給成員變量賦值，使用this引用，告訴編譯器是為當前類的成員變量賦值。在length和toString方法中使用父類成員變量時，使用super引用，告訴編譯器使用的是父類的成員變量。
（2）使用this、super和super()的程序文件JAVA_B_3_7.java，源代碼如下。
class Point {
29、
protected int x, y;
Point(int a, int b) {
setPoint(a, b);
}
public void setPoint(int a, int b) {
x = a;
y = b;
}
}
class Line extends Point {
protected int x, y;
Line(int a, int b) {
super(a, b);
setLine(a, b);
}
public void setLine(int x, int y) {
thi
30、s.x = x + x;
this.y = y + y;
}
public double length() {
int x1 = super.x, y1 = super.y, x2 = this.x, y2 = this.y;
return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
public String toString() {
return "直線端點：[" + super.x + "," + super.y + "] [" + x + "," + y
31、 + "] 直線長度：" + this.length();
}
}
public class JAVA_B_3_7 {
public static void main(String args[]) {
Line line = new Line(50, 50);
System.out.println("\n" + line.toString());
}
}
（3）編譯并運行程序，記錄、分析程序結(jié)構(gòu)及其運行結(jié)果。
六、類的多態(tài)性練習
1、理解類的多態(tài)性
類的繼承發(fā)生在多個類之間，而類的多態(tài)只發(fā)生在同一個類上。在一個類中，可以定義多個同名的方法，只要確定
32、它們的參數(shù)個數(shù)和類型不同。這種現(xiàn)象稱為類的多態(tài)。
多態(tài)使程序簡潔，為程序員帶來很大便利。在OOP中，當程序要實現(xiàn)多個相近的功能時，就給相應的方法起一個共同的名字，用不同的參數(shù)代表不同的功能。這樣，在使用方法時不論傳遞什么參數(shù)，只要能被程序識別就可以得到確定的結(jié)果。
類的多態(tài)性體現(xiàn)在方法的重載（overload）上，包括成員方法和構(gòu)造方法的重載。
2、方法的重載
方法的重載是指對同名方法的不同使用方式。
（1）程序功能：在IntSort類中定義3個同名的方法sort，對不同的數(shù)進行排序輸出。
（2）編寫JAVA_B_3_8.java文件，源代碼如下。
import java.a
33、wt.Graphics;
import java.applet.Applet;
class IntSort {
public String sort(int a, int b) {
if (a > b)
return a + " " + b;
else
return b + " " + a;
}
public String sort(int a, int b, int c) {
int swap;
if (a
34、p;
}
if (b arr[j + 1]) {
swap = arr[j];
arr[j] = arr[j +
35、1];
arr[j + 1] = swap;
}
for (int i = 0; i < arr.length; i++)
s = s + arr[i] + " ";
return s;
}
}
public class JAVA_B_3_8 extends Applet {
IntSort s = new IntSort();
public void paint(Graphics g) {
int a = 30, b = 12, c = 40;
int arr[] = { 34, 8, 12, 67, 44, 98
36、, 52, 23, 16, 16 };
g.drawString("兩個數(shù)的排序結(jié)果：" + s.sort(a, b), 30, 30);
g.drawString("三個數(shù)的排序結(jié)果：" + s.sort(a, b, c), 30, 60);
g.drawString("數(shù)組的排序結(jié)果：" + s.sort(arr), 30, 90);
}
}
（3）、將JAVA_B_3_8.java 源程序編譯為JAVA_B_3_8.class 文件，編寫一個瀏覽Applet 應用程序的頁面文件JAVA_B_3_8.HTML。
（4）、使用瀏覽器或使用小程序查看器瀏覽JAVA_B_3_8.HTML 文件（即在命令提示符下輸入：appletviewer JAVA_B_3_8.ML）
3、構(gòu)造方法的重載
構(gòu)造方法的名稱和類同名，沒有返回類型。盡管構(gòu)造方法看起來和一般的成員方法沒有差別，但它不是方法，也不是類的成員。因此，構(gòu)造方法不能直接調(diào)用，只能由new操作符調(diào)用。
構(gòu)造方法對于類是十分重要的，對象的初始化任務(wù)要靠構(gòu)造方法來完成。
重載構(gòu)造方法的目的是提供多
38、種初始化對象的能力，使程序員可以根據(jù)實際需要選用合適的構(gòu)造方法來初始化對象。
（1）編寫構(gòu)造方法RunDemo的重載程序文件JAVA_B_3_9，源代碼如下。
class RunDemo {
private String userName, password;
RunDemo() {
System.out.println("全部為空!");
}
RunDemo(String name) {
userName = name;
}
RunDemo(String name, String pwd) {
this(name);
pas
39、sword = pwd;
check();
}
void check() {
String s = null;
if (userName != null)
s = "用戶名：" + userName;
else
s = "用戶名不能為空！";
if (password != "12345678")
s = s + " 口令無效！";
else
s = s + " 口令：********";
System.out.println(s);
}
}
public class JAVA_B_3_9 {
40、 public static void main(String[] args) {
new RunDemo();
new RunDemo("劉新宇");
new RunDemo(null, "邵麗萍");
new RunDemo("張馳", "12345678");
}
}
（2）編譯并運行程序，記錄并分析程序結(jié)構(gòu)及其運行結(jié)果。
七、實驗截圖
1、編寫一個瀏覽Applet 應用程序的頁面文件Applet1.HTML
2、編寫Applet 2程序
3、編寫類文件JAVA_B_3_1.java
4、編寫一個調(diào)用對象方法的程序文件JA
41、VA_B_3_2.java
5、編寫一個調(diào)用對象方法的程序文件JAVA_B_3_3.java。
6、創(chuàng)建公共類JAVA_B_3_4P
7、編寫JAVA_B_3_5.java
8、編寫覆蓋Object 類toString 方法的程序文件JAVA_B_3_6.java
9、使用this、super和super()的程序文件JAVA_B_3_7.java
10、編寫JAVA_B_3_8.java文件
11、編寫構(gòu)造方法RunDemo的重載程序文件JAVA_B_3_9
八、結(jié)果分析
在JAVA中，有時需要公開一些變量和方法，有時需要禁止其他對象使用變量和方
42、法，這時可以使用修飾符來實現(xiàn)這個目的。常用的修飾符有：[public] [private] [protected] [package] [static] [final] [transient] [volatile]。類的靜態(tài)變量可以直接引用，而非靜態(tài)變量則不行。類的靜態(tài)變量相當于某些程序語言的全局變量。靜態(tài)方法只能使用靜態(tài)變量，不能使用實例變量。因為對象實例化之前，實例變量不可用。類的靜態(tài)變量只有一個版本，所有實例對象引用的都是同一個版本。對象實例化后，每個實例變量都被制作了一個副本，它們之間互不影響。在Java 中，方法中的參數(shù)傳遞可以分為傳值調(diào)用或?qū)ο蠓椒ㄕ{(diào)用等方式。傳值調(diào)用即傳遞的參數(shù)是
43、基本數(shù)據(jù)類型，調(diào)用方法時在方法中將不能改變參數(shù)的值，這意味著只能使用它們。對象調(diào)用是指先調(diào)用對象，再調(diào)用對象的方法，這種方式可以修改允許存取的成員變量。所以，如果不想改變參數(shù)的值，可以采用傳值調(diào)用的方法。如果想改變參數(shù)的值，可采用對象調(diào)用的方法，間接修改參數(shù)的值。
繼承：
新類可從現(xiàn)有的類中產(chǎn)生，并保留現(xiàn)有類的成員變量和方法并可根據(jù)需要對它們加以修改。新類還可添加新的變量和方法。這種現(xiàn)象就稱為類的繼承。
當建立一個新類時，不必寫出全部成員變量和成員方法。只要簡單地聲明這個類是從一個已定義的類繼承下來的，就可以引用被繼承類的全部成員。被繼承的類稱為父類或超類（superclass），這個新
44、類稱為子類。
Java 提供了一個龐大的類庫讓開發(fā)人員繼承和使用。設(shè)計這些類是出于公用的目的，因此很少有某個類恰恰滿足你的需要。你必須設(shè)計自己的能處理實際問題的類，如果你設(shè)計的這個類僅僅實現(xiàn)了繼承，則和父類毫無兩樣。所以，通常要對子類進行擴展，即添加新的屬性和方法。這使得子類要比父類大，但更具特殊性，代表著一組更具體的對象。繼承的意義就在于此。
構(gòu)造方法的重載：
構(gòu)造方法的名稱和類同名，沒有返回類型。盡管構(gòu)造方法看起來和一般的成員方法沒有差別，但它不是方法，也不是類的成員。因此，構(gòu)造方法不能直接調(diào)用，只能由new操作符調(diào)用。構(gòu)造方法對于類是十分重要的，對象的初始化任務(wù)要靠構(gòu)造方法來完成。重載構(gòu)造方法的目的是提供多種初始化對象的能力，使程序員可以根據(jù)實際需要選用合適的構(gòu)造方法來初始化對象。
21
面向?qū)ο缶幊?JAVA編程綜合實驗報告
