目錄

目錄

摘要........................................................3

ABSTRACT................................................................................................................4

第一章面向對象概述............................................5

1.1面向對象的基本概念......................................5

1.1.1對象................................................5

1.1.2類..................................................6

1.1.3消息和方法..........................................6

L2面向對象的基本特征......................................7

1.2.1封裝................................................7

1.2.2繼承.................................................8

1.2.3多態性...............................................8

第二章類與對象................................................9

2.1類的定義格式............................................9

小結......................................................9

2.2類中成員的訪問修飾符....................................10

小結.....................................................11

2.3類中的數據成員........................................11

231常數據成員...........................................11

小結...................................................13

2.3.2靜態數據成員.........................................13

小結...................................................15

2.4類中的成員函數........................................15

2.4.1普通成員函數........................................15

小結...................................................18

2.4.2靜態成員函數........................................18

小結...................................................20

2.4.3構造函數............................................20

小結...................................................23

2.5對象的撤銷............................................23

小結...................................................24

第三章繼承...................................................25

3.1繼承的定義格式........................................25

第1頁

小結.....................................................27

3.2類中成員的屬性：......................................28

小結.....................................................29

3.3派生類的構造函數.......................................30

小結.....................................................31

3.4類中的同名覆蓋.........................................32

小結.....................................................37

3.5對象轉換..............................................37

小結.....................................................40

3.5多重繼承...............................................40

3.5.1接口的定義格式....................................41

小結...................................................42

3.5.2接口多重繼承的實現................................42

小結...................................................45

3.5.3復雜的多重繼承....................................46

小結...................................................50

第四章多態性.................................................51

4.1靜態聯編..............................................51

4.1.1函數重載與模板.....................................51

小結...................................................55

4.1.2運算符重載.........................................55

小結...................................................56

4.1.3指針與強制多態.......................................56

小結...................................................59

4.2動態聯編...............................................60

4.2.1虛函數............................................60

小結...................................................62

4.2.2抽象類...............................................63

小結...................................................66

總結......................................錯誤！未定義書簽。

致謝.......................................................68

參考文獻69

摘要

摘要

面向對象的程序設計技術是目前最流行、最實用的軟件開發手段。與

傳統的面向過程程序設計結構化技術完全不同。它的出現是程序設計語言

的一場革命。它主要包括類、對象、消息、方法、屬性等基本概念，具有

封裝性、繼承、多態性、重載等特點。在面向對象的程序設計中，現實世

界的對象被抽象為“類工程序員將精力主要集中于要處理的對象的設計

和研究上，通過繼承、多態、重載可以很方便的實現代碼的重用，從而大

大提高了軟件的開發效率。C++、Java和C#都是目前最流行的面向對象程

序設計語言，它們都可以為面向對象的技術提供全面的支持。

本文共分為四章，第一章主要介紹了面向對象的基本概念和特征。第

二章主要比較了C++、Java和C#語言類中成員的定義、訪問權限、對象

的撤消等。第三章主要比較了C++、Java和C#語言在繼承方面的異同點，

并且給出了相關的程序。第四章主要比較了C++、Java和C#語言在多態

性方面的異同點，并且給出了相關的程序。最后總結了C++、Java和C#語

言的優劣并給出了進行畢業設計的心得體會。

關鍵詞：面向對象類繼承多態性重載

第3頁

第一章面向對象概述

ABSTRACT

TheObjectOrientedProgramming(OOP)isthemostpopularanduseful

methodofsoftwaredevelopingnow.Itisdifferentfromthetraditional

ProcessOrientedstructuredProgramming.Itsemergenceisarevolution

ofprogramminglanguage.Itmainlyincludesthesebasicconceptssuchas

classes、objects、messages、methods、attributesetc9andthese

characteristicssuchasencapsulation>inheritancepolymorphism^

overloadingandsoon.IntheObjectOrientedProgramming,the

objectsintheworldareabstractedasclasses.Programmerschiefly

concentratethedesignandresearchofobjects.Bymeansofthe

encapsulation、inheritance、polymorphismandoverloading,

programmerscanveryconvenientlycompletecodesofreusing,thus

greatlyincreasingthedevelopmentefficiencyofsoftware.C++、Javaand

C#arethemostpopularObjectOrientedProgramminglanguageat

present.TheycanprovidoverallsupportforObjectOriented

Programming.

Therearefourchaptersinthethesis.Inthefirstchapter,thebasic

conceptandcharacteristicofobject-orientedisintroduced.Inthesecond

chapter,thedefinitionofmember,theaccessauthority,theobjectremove

werechieflycomparedintheC++、JavaandC#language.Inthethird

chapter,similaritiesanddifferencesattheaspectoftheinheritancein

theC++、JavaandC#languagewerecomparedandgivenoutthe

programofcorrelation.Inthe4thchapter,similiaritiesanddifferencesat

theaspectofthepolymorphismintheC++>JavaandC#languagewere

comparedandgivenouttheprogramofcorrelation.Finallysumupthe

goodandbadofC++,JavaandC#*slanguageandgivenoutthetagof

graduationdesign.

KeyWords:

ObjectOrientedClassInheritPolymorphismOverloading

第7頁

第四章繼承

第一章面向對象概述

1.1面向對象的基本概念

1.1.1對象

客觀世界的問題都是由客觀世界的實體及實體間的相互關系構成的,

我們把客觀世界的實體稱為問題空間的對象。顯然，“對象”不是固定的。

一本書是一個對象，一家書店也可以是一個對象。世界上的各個事物都是

由各種“對象”組成的。任何事物都是對象，復雜的對象可以由相對比較

簡單的對象以某種方式組成。從這種意義上講，整個客觀世界可認為是一

個最復雜的對象。

從動態的觀點看，對象的操作就是對象的行為。問題空間對象的行為

是極其豐富多彩的，而解空間對象的行為是死板的，只有借助于復雜的算

法才能操縱解空間的對象而得到解。傳統的程序設計語言限制了程序員定

義解空間對象，而面向對象語言提供了“對象”概念。這樣，程序員就可

以自己去定義解空間對象。

從存儲的角度看，“對象”是一片私有存儲，其中有數據也有方法。

其他對象的方法不能直接操縱該對象的私有數據，只有對象自己的方法才

可操縱它。

從對象的實現機制來看，“對象”是一臺自動機，其中私有數據表示

了對象的狀態，該狀態只能由自身的方法改變它。每當需要改變對象的狀

態時。只能由其他對象向該對象發進消息，對象響應消息后按照消息模式

找出匹配的方法，并執行該方法。

在面向對象的設計中，“對象”是應用領域中的建模實體。所有對象

在外觀上都表現出相同的特性,即固有的處理能力和通過傳邀消息實現的

統一的聯系方式。

在面向對象的程序設計中，“對象”是系統中的基本運行實體。換

句話說，“對象”是具有特殊屬性（數據）和行為方式（方法）的實體。

對象占有存儲空間且具有傳統程序設計語言的數據，如變量、數組、字

第30頁

第四章繼承

符串等。給對象分配存儲空間就確定了給定時刻對象的狀態，與每一個

對象相關的方法定義了該對象上的操作。

1.1.2類

在面向對象的程序設計中，“對象是程序的基本單位，相似的對象可

以和傳統語言中的變量與類型關系一樣，歸并到一類（class）中去。類

實質上定義的是一種對象類型，它是對具有相似行為的對象的一種抽象,

描述了屬于該類型的所有對象的性質。

例如：integer是一個類，它描述了所有整數的性質，“1”、“2”

等具體整數都是integer這個類的對象，都具備算術運算和大小比較的處

理能力。

對象是在執行過程中由其所屬的類動態生成的,一個類可以生成多個

不同的對象。同一個類的所有對象具有相同的性質，即其外部特性和內部

實現都是相同的。一個對象的內部狀態（私有屬性）只能由其自身來修改,

任何別的對象都不能來修改名。因此，同一個類的對象雖然在內部狀態的

表現形式上相同，但它們可以有不同的內部狀態。這些對象并不是一模

一樣的。

1.1.3消息和方法

如何要求對象完成一定的處理工作？對象間如何進行聯系？所有這

一切都只能通過傳遞消息來實現。消息用來請求對象執行某一處理或回答

某些信息的要求，消息統一了數據流和控制流。某一對象在執行相應的處

理時，如果需要，它可以通過傳遞消息請求其他對象完成某些處理工作或

回答某些信息。其他對象在執行所要求的處理活動時，同樣可以通過傳

遞消息與別的對象聯系。因此，程序的執行是靠在對象間傳遞消息來完成

的。

發送消息的對象稱為發送者，接收消息的對象稱為接收者。消息中只

包含發送者的要求，它告訴接收者需要完成哪些處理，但并不指示接收者

應該怎樣完成這些處理。消息完全由接收者解釋，接收者獨立決定采用什

么方式完成所需的處理。一個對象能夠接收不同形式、不同內容的多個消

息：相同形式的消息可以送往不同的對象；不同的對象對于形式相同的消

息可以有不同的解釋，能夠作出不同的反應。對于傳來的消息，對象可以

返回相應的應答信息，但這種返回并不是必需的。

消息的形式用消息模式（messagepattern）刻畫，一個消息模式定義

第54頁

第四章繼承

了一類消息,它可以對應不同內容的消息。對于同一消息模式的不同消息,

同一個對象所作的解釋和處理都是相同的，只是處理的結果可能不同。因

此有處理能力接消息分類，一個消息模式定義對象的一種處理能力。這種

處理能力是通過該模式及消息引用表現出來的。所以，只要給出對象的所

有消息模式及相應于每個消息模式的處理能力，也就定義了一個對象的固

有處理能力。它是定義對象接口的唯一信息。使用對象只需了解它的消

息模式，所以對象具有極強的“黑盒”性。把所有對象分成各種對象類,

每個對象類都定義一組“方法”，代表允許作用于該類對象上的各種操作。

1.2面向對象的基本特征

1.2.1封裝

封裝是一利信息隱蔽技術，用戶只能看到對象封裝界面上的信息,

對象內部對用戶是隱蔽的。封裝的目的在于將對象的使用者和設計者分

開，使用者不必知道行為實現的細節，只需用設計者提供的消息來訪問這

對象。

封裝的定義為。

（1）一個清楚的邊界，所有對象的內部軟件的范圍被限定在這個邊界內；

（2）一個接口，這個接口描述該對象和其他對象之間的相互作用：

（3）受保護的內部實現。這個實現給出了由軟件對象提供的功能的細節,

實現細節不能在定義這個對象的類的外面訪問。

封裝的概念和類說明有關,而且同樣提供如何將一個問題解的各個組

件組裝在一起的求精過程。封裝的基本單位是對象。這個對象的性質由它

的糞說明來描述，這個性質被具有同樣類的其他對象共享。對象用作封裝

比講一個類表示的封裝更具體化。有了封裝這個定義一個類的每個實例在

一個問題求解中是一個單獨的封裝，或稱作組件。

對象用于封裝的概念可以和集成電路芯片作一類比「?塊集成電路芯

片被封裝起來，其內部電路是不可見的，也是使用者不關心的。芯片的使

用者只關心芯片引腳的個數、引腳的電氣參數以及引卿提供的功能，通過

對各個引腳功能的了解，可以將不同的芯片引腳連在一起，組裝成具有一

定功能的產品。同樣，軟件設計者可以通過對類和對象的使用達到這個目

的。

顯式地將對象的定義和對象的實現分開是面向對象系統的一大特色。

封裝本身即模塊化，把定義模塊和實現模塊分開，就使得用面向對象技術

第54頁

第四章繼承

所開發設計的軟件的維護性、修改性大為改善，這也是軟件技術追求的目

標之一。

1.2.2繼承

廣義地說，繼承是指能夠直接獲得已有的性質和特性，而不必重復定

義它們。在面向對象的軟件技術中，繼承是子類自動地共享基類（或父類）

中定義的數據和方法的機制。一個類直接繼承其父類的全部描述（數據和

操作）。

繼承具有傳遞性，繼承性使得相似的對象可以共享程序代碼和數據結

構，從而大大減少了程序中的冗余信息。使得對軟件的修改變得比過去容

易得多了。

繼承性使得用戶在開發新的應用系統時不必完全從零開始，可以繼承

原有的相似系統的功能或者從類庫中選取需要的類,再派生出新的類以實

現所需要的功能，所以，繼承的機制主要是支持程序的重用和保持接口的

一致性。

1.2.3多態性

所謂多態（plymorphic）即一個名字可具有多種語義。在大多數面向

對象的語言中，如果類P是子類S的父類，則子類S的對象s可以用在

父類P的對象p使用的地方，這就意味著一個公共的消息集（操作）可

以送到類P和類S的對象上。當同樣的消息可以被送到一個父類的對象

和其子類的對象上時這被稱作多態性（polymophism）。在不同的對象上

對一個相似的操作使用相同消息的方法和人們在解決問題中的思考方式

是相遇的，我們不必為打印整數、浮點數、字符而使用不同的束語。

面向對象的語言中，多態引用表示可引用多個類的實例。由于多態具

有可表示對象的多個類的能力，因此，它既與動態類型有關，又與靜態類

型有關。

動態類型是在程序執行期間隨時可以改變的類型。在強類型面向對象

環境中，運行系統根據動態類型

自動地保留標記的全部多態引用。靜態類型是在程序正文中聲明實體

時確定下來的類型。在編譯時已經知邀并確定了對象在運行時的有效類型

集合。

第54頁

第四章繼承

第二章類與對象

2.1類的定義格式

C++中類的定義格式：

Class〈類名稱）

（

修飾符：〈成員函數或數據成員的說明;〉

）；

其中是定義類的關鍵字。〈類名稱〉是一中標識符，一對花括號內是

類的說明部分。說明該類成員。類的成員包含數據成員和成員函數兩部分。

Java中類的定義格式：

修飾符Class類名稱

（

類的屬性與方法；

）

類名稱的第一個字母為大寫，例如：Systemo

C#中類的定義格式：

修飾符Class類名稱

（

類的成員；

小結

在C++中類定義不存在類修飾符，而C#和Java中類修飾符決定了

這個類的屬性。在Java中類名稱的第一個字母必須大寫，而C#和C++

中類名稱無需這個必要。

第30頁

第四章繼承

2.2類中成員的訪問修飾符

C++提供了3個不同的訪問權符，它們規定的成員訪問屬性互不同：

（1）public（公有的）具有這種訪問屬性的成員，可被與該類對象處在同

一作用域內的任何函數使用。

（2）private（私有的）私有的成員只能被它所在類中的成員函數及該類

的友元函數使用。

（3）protected（保護的）具有這種訪問屬性的成員只能被它所在類及從

該類派生的子類的成員函數及友元函數使用

成員訪問控制類自身派生類其他類

Public可被訪問可被訪問可被訪問

Private可被訪問不可被訪問不可被訪問

Protected可被訪問可被訪問不可被訪問

Java提供了4個不同的訪問權符，它們規定的成員訪問屬性互不同：

（1）public（公有的）定義成這種等級的屬性，可以被任何對象存取，適

用于完全公開的數據。

（2）private（私有的）定義成這種等級的屬性，只可以被同一類的方法

所存取，適用于類中不欲公開的數據。

（3）protected（保護的）則具有半公開性質的數據，定義成這種等級的

數據可以被類，子類及從同一包的其他類的方法存取。

（4）default（無修飾符）定義成這種等級的屬性，將可以被同一package

類的方法存取。

注意：使用default等級時，只是在屬性前不加上任何修飾符，而不是在

屬性前使用default關鍵字。

同一package不同package

存取等級同一類

其他類子類其他類子類

Public可被訪問可被訪問可被訪問可被訪問可被訪問

Private可被訪問不可被訪問不可被訪問不可被訪問不可被訪問

Protected可被訪問可被訪問可被訪問不可被訪問可被訪問

無修飾符可被訪問可被訪問可被訪問不可被訪問不可被訪問

C#提供了5個不同的訪問權符，它們規定的成員訪問屬性互不同:

第54頁

第四章繼承

（1）public（公有的）具有這種訪問屬性的成員，可以被任何隨意訪問。

（2）private（私有的）定義成這種等級的屬性成員，只可以被類自身訪問。

（3）protected（保護的）具有這種訪問屬性的成員只能被它所在類及從

該類繼承的任何成員訪問。

（4）internal（內部的）具有這種訪問屬性的成員，可被與同一程序集內

部的任何類的任何成員訪問。

（5）internalprotected（內部保護的）具有這種訪問屬性的成員只能被可

被與同一程序集內部的中或繼承類中被訪問。

存取等級同一類同一程序集的內部不同一程序集的內部

其他類子類其他類子類

Public可被訪問可被訪問可被訪問可被訪問可被訪問

Private可被訪問不可訪問不可訪問不可訪問不可訪問

Protected可被訪問不可訪問可被訪問不可訪問不可訪問

Internal可被訪問可被訪問可被訪問不可訪問不可訪問

Protectedinternal可被訪問可訪問可被訪問不可訪問可訪問

小結

Protected關鍵字在C++、java和C#中的作用是完全不同的。標記

為Protected的C++類，成員函數和變量可以在所在類及從該類派生的

子類的成員函數及友元函數使用。標記為Protected的java類，成員函數

和變量可以在同一包中或繼承類中被訪問。標記為Protected的C#類，

方法和變量可以被類或其繼承類的任何成員訪問。Java中的Protected與

C#中的Protectedinternal相似。Java中的無修飾符與C#中internal的

相似。Public和Private修飾符在C++、java和C#中用法都一樣。

2.3類中的數據成員

2.3.1常數據成員

常數據成員是類中定義的常量。在類中使用的某個常數值都可以定義

為常量。如圓周率，一個星期的天數，每小時的分鐘數等。

第54頁

第四章繼承

在C++中定義const常量的格式是：

［常量修飾符］類型標識符常量名

注意:在C++中不允許在類中對一個const型數據成員直接進行初始化。

例如：classMyClass

{constfloatpi=3.14;〃錯誤用法floatx,y;

)；

正確的初始化方法是：常數據成員由構造函數初始化列表方法初始化

classMyClass

{constfloatpi;floatx,y;

public:MyClass();};

MyClass::MyClass():pi(3.14){}

在C#中定義const常量的格式是：

［常量修飾符］類型標識符常量名=常量表達式值；

例：

classMyClass

{public:constfloatpi=3.14

floatx,y;

)；

在C#中定義readonly常量的格式是：

［訪問修飾符］［static］readonly類型關鍵字成員標志符=［表達式］;

例：

usingSystem;

classStudent{

publicreadonlyStudentID

publicStudent(stringspecifedStudentID){StudentID=specifedStudentID;}

)

classClassroom{

publicstaticvoidMain()

StudentStudentl=newStudent(“2002001");

Console.WriteLine("學號為：,,+Student.StudentID);

)

運行結果為：

學號為：2002001

注意：與常量成員(由const關鍵字聲明)一樣，只讀成員也用與表

示一個不變化的值。但是，賦值給常量的值必須在源代碼中指定。而只讀

成員的值直到程序運行時才知道。只讀成員的值在一個構造函數中初始

化，而且此后不能在修改。所以常量成員在編譯后程序的整個生存周期內

保持不變。而只讀成員只在此對象生存周期內保持不變

第54頁

第四章繼承

Java:定義常量的格式是：

［修飾符］final數據類型常量名=常量表達式值

例：

classMyClass

{publicfinalfloatpi=3.14;

floatx,y;

小結

在C++中不允許在類中對一個const型數據成員直接進行初始化。

常數據成員由構造函數初始化列表方法初始化。和C++不同C#可以在類

中對一個const型數據成員直接進行初始化，并且在C#中存在readonly

常量。和C++、C#不同java用的是final標識符對一個常數據成員直接

進行初始化。

2.3.2靜態數據成員

靜態數據成員是為了解決同一個類的不同對象之間的數據和函數共

享問題。例如，我們可以抽象出某公司的全體雇員的共性，設計如下的雇

員類：

classemployee

{private:

intEmpNo;intID;char*name;...

}

如果需要統計雇員總數，這個數據存放在什么地方呢？若以類外的變

量來存儲總數，不能實現數據的隱藏。若以類中增加一個數據成員用以存

放總數，必然在每一個對象中都存儲一副本，僅冗余，而且每一個對象分

別維護一個“總數，，，勢必造成數據的不一致性。因此，比較理想的方案是

類的所有對象共同擁有一個用于存放總數的數據成員。

類中的靜態數據成員只存儲在一個地方,靜態數據成員的值對每一個

對象都是一樣的。如果在某個對象中對靜態數據成員的值進行了更新，則

所有對象都存取到更新后的相同的值。即所有對象實例共享靜態變量，靜

態變量有且僅有一個副本。

在C++中靜態成員必須初始化，初始化方法是在類外進行，格式為：

數據類型名類名::靜態數據成員名=表達式。

第54頁

第四章繼承

在C++中訪問靜態成員的方法對public型靜態成員有：

方法1：類名::靜態成員名

方法2：對象名.靜態成員名

方法3：對象指針。靜態成員名

例：#include"iostream.h"

classA_C{

public:staticintx;voidprint(){cout?x?n,n;}

);

intA_C::x=100;//靜態成員的初始化

voidmain(){A_Ca,b;.print();b.print();A_C::x=200;a.print();b.print();

)

運行結果為：100,100,200,200

在Java中靜態成員初始化方法是在類中進行，格式為：

存取控制修飾符static數據內型名靜態數據成員名=表達式。

用靜態靜態構造器進行初始化，格式為：

static{

靜態數據成員名=表達式；

)

在Java中訪問靜態成員的方法

方法1：類名.靜態成員名(這種方法在對象定義之前或之后均可使用。)

方法2：對象名.靜態成員名(這種方法只能在對象定義之后使用。)

例：importtio.*;

publicclassA_C

{publicstaticintx;

static{x=100}〃靜態構造器進行初始化

publicvoidprint(){System.out.println(x);}

);

publicclassA_CTest

{

publicstaticvoidmain(string[]args)

(

{A_Ca=newA_C();A_Cb=newA_C();

a.print();b.print();

)

運行結果為：100,100在c#中靜態成員初始化方法是在類中進行，格式為：

static存取控制修飾符數據內型名靜態數據成員名=表達式。

用靜態構造函數進行，格式為：

static類名()

第54頁

第四章繼承

靜態數據成員名=表達式；

)

在C#中訪問靜態成員的方法

對public型靜態成員有：類名.靜態成員名

例：usingSystem

publicclassA_C

{publicstaticintx;

staticA_C(){x=100}〃靜態構造函數進行初始化

publicvoidprint(){Console.WriteLine(x);}

);

publicclassA_CTest

{

publicstaticvoidMain()

(

A_Ca=newA_C();A_Cb=newA_C();

a.print();b.print();}

)

運行結果為：100,100

小結

在C++中可以通過類名，對象名和對象指針進行訪問。在java中可

一通過類名和對象名進行訪問。和C++,java不同C#只能用類名來訪問

靜態數據成員。在java中可以過靜態構造器進行初始化也可以直接進行

初始化。在C#中可以通過靜態構造函數進行初始化也可以直接進行初始

化。和C#,java不同C++只能通過類名引用靜態數據成員名進行初始化。

2.4類中的成員函數

2.4.1普通成員函數

C++:成員函數的一般定義格式:class類名

{[private:[protected:Ipublic:]

返回值類型函數名(形參說明表)；〃成員函數說明};

第54頁

第四章繼承

返回值類型類名::函數名（形參列表）〃成員函數定義內聯成員函數（1）

隱式聲明：將函數體直接放在類定義體內。

class類名

{［private:lprotected:lpublic:］

返回值類型內聯函數名（形參列表）

{函數體};

（2）顯示聲明：類定義體中只有函數說明，無函數體，函數的定義放在

類主體之外，且前面加上inline關鍵字。

class類名

{［private:lprotected:lpublic:］

返回值類型內聯函數名（形參表說明）；

）；

inline返回值類型類名::內聯函數名（……）

（函數體

）；

java的成員函數又稱為方法，在類中定義的一般格式如下：

［修飾符］返回值類型方法名稱（［參數表］）

{……〃程序語句}

注意：用方括號括住的項表可選。修飾符用與定義此方法可被其他類的方

法調用的控制權等級。

C#的成員函數也稱為方法，在類中定義的一般格式如下：

［屬性］［修飾符］返回值類型方法名稱（［參數表］）

{……〃程序語句}

注意：用方括號括住的項表可選。修飾符用與定義此方法可被其他類的方

法調用的控制權等級。

下面分別用和C++、Java和C#定義一個復數類

程序Complex.cpp

classComplex

{private:

doublere,im;

public:

voidSetRe（doublex）{re=x;}

voidSetlm（doubley）{im=y;}

doubleGetRe（）{returnre;}

doubleGetlm（）{returnim;}

voidinput（）;

voidprint（）;

第54頁

第四章繼承

inlinevoidComplex::input(){cin?re?im;}

voidComplex::print()

{if(im>0)cout?re?u+,,?im?<T,;

elsecoutvvrev<imvv"i"；

)

下面用Java重新編寫這個復數類程序Complex.java

classComplex

{private:intre;privateintim;

publicvoidSetRe(doublex){re=x;}

publicvoidSetlm(doubley){im=y;}

publicintGetRe(){returnre;}

publicintGetlm(){returnim;}

publicvoidinput();

{Bufferedreaderbr=newBufferedreader(newinputStreameder(Syste,.out))

Stringsl=br.readLine()

intre=lnteger.parselnt(s1)

Strings2=br.readLine()

intim=lnteger.parselnt(s2)

)一

publicvoidprint()

{if(im>0)System.out.print(re+"+''+im+"i");

elseSystem.out.print(re+im+'T9);};

)

下面用C#重新編寫這個復數類

程序Complex.es

classComplex

{private:doublere;

privatedoubleim;

publicstringdatal,data2;

publicvoidSetRe(doublex){re=x;}

publicvoidSetlm(doubley){im=y;}

publicdoubleGetRe(){returnre;}

publicdoubleGetlm(){returnim;}

publicvoidinput();

data1=Console.ReadLine();

re=double.parselnt(datal)

data2=Console.ReadLine();

第54頁

第四章繼承

im=double.parselnt(data2)

publicvoidprint()

if(im>0)Console.WriteLine(re+"+”+im+"i'');

elseConsole.WriteLine(re+im+"i’')；

小結

通過前面三個不同版本的復數類。C++不同與Java和C#,它接受文

件作用域方法-C++程序沒有封裝在類中。C++中的方法，或稱函數，

既可以在類內部又可在類外部通過“類名：：”的形式定義。定義。Java

和C#中的方法始終包含在類中。如果某個方法需要被多個類調用可以在

其他類中定義同樣的方法，然后調用這個新類的方法。和C++不同在C#

和java中依靠標準庫來提供輸入和輸出。

2.4.2靜態成員函數為了在不生成類對象的情況下，直接訪問靜態數

據成員，C++定義了靜態成員函數。

定義靜態成員函數的格式如下：

static返回值類型成員函數名(形參列表)；

靜態成員函數屬于整個類，由同一個類的所有對象共同維護。

point#include<iostream.h>

classpoint

{

point(intxx=0,intyy=O){X=xx;Y=yy;countp++;}

staticvoidGetC(){cout?64objectid=,,?count?endl;}

intpoint::countp=0

voidmain()

{pointA(4,5)

A.GetC()

PointB(5,6)

point::GetC()

}

該程序的結果是

注意：

第54頁

第四章繼承

(1)靜態成員函數可以直接訪問的數據有：該類中的靜態數據成員與靜

態函數成員、全局變量和常量；

(2)訪問類中的非靜態數據和函數成員，只能通過參數傳遞方式得到對

象名，然后通過對象名來訪問。

例如：classA

{public:staticvoidf(Aa)

private:intx;

)；

voidA::f(Aa)

(cout?x;〃對的引用是錯誤的cout?a.x〃正確}

由此可見，通過靜態成員函數訪問非靜態成員是相當麻煩的，我們一

般用靜態成員函數來訪問全局變量或同一個類中的靜態數據成員，特別是

和后者一起作用，達到對同一個類中對象之間共享的數據進行維護的目

的。

public型靜態成員函數有三種調用方法：(1)類名::靜態成員函數名(［實

參表］)(2)對象名.靜態成員函數名(［實參表］)

(3)對象指針-＞靜態成員函數名(［實參表］)

在java中的定義靜態成員函數的格式如下：

static返回值類型方法名(形參列表)；

在java中類外使用靜態方法的格式是：

類名?方法名(參數)

用java來重新編寫上面的程序.

classpoint

{static{count=0;}

point(intxx,intyy){X=xx;Y=yy;countp++;}

publicclasspointtest{

publicstaticvoidmain(Stringargs［］)

{pointA=newpoint(4,5)

point.GetC()

pointB=newpoint(5,6)

point.GetC()

)

從上述格式可以看出，調用靜態方法可以不需要對象，通過類名即可以調

用。不可以通過對象進行調用，所以靜態方法內部只能出現靜態變量和靜

態方法。在C#中的定義靜態成員函數的格式如下：

方法修飾符static返回值類型方法名(形參列表)；

在C#中類外使用靜態方法的格式是：

第54頁

第四章繼承

類名.方法名(參數)

對象名?方法名(參數)

用C#來重新編寫上面的程序.

classpoint

{

point(intxx=0,intyy=0){X=xx;Y=yy;countp++;}

static{count=0;}

staticvoidGetC(){

publicclasspointtest{

publicstaticvoidMain(Stringargs[])

{pointA=newpoint(4,5)

A.GetC()

pointB=newpoint(5,6)

point.GetC()

小結

在C++和c#中可以通過類名和對象名訪問靜態成員函數。并且靜態

成員函數可以訪問非靜態數據成員。而在java中只能通過類名訪問靜態

成員。靜態方法不能訪問非訪問靜態成員。

2.4.3構造函數構造函數在對象被創建的時候由系統自動調用，它的

作用就是在對象被創建時利用特定的值構造對象，將對象初始化為一個特

定的狀態。

構造函數的特點：

a.構造函數名必須和類名相同

b.構造函數沒有返回值（也不允許用void）

c.構造函數由系統自動調用，任何函數都無法再調用它。

d.通常構造函數被定義在公有部分。

e.如果程序員沒有定義構造函數，系統會自動生成一個缺省的構造函數。

f.構造函數具有普通成員函數的特征，并且可以重載。

在C++中構造函數定義格式如下：

public類名稱（參數表）

程序語句

第54頁

第四章繼承

例：classMyClass

{private:

intx;inty;A*pa;public:

MyClass(inta,intb){x=a;y=b;}

MyClass(inta);

MyClassO{}

};

MyClass::MyClass(inta){x=a;pa=newA;}

成員變量賦初值可以采用初始化成員列表方法

例如：#include例stream.h"

classPoint

{doublex,y

constdoublepi;

public:

Point(doublexx,doubleyy);

Point():x(0),y(0),pi(3.14){);

voidprint();

);

voidPoint::print(){coutvv"(”vvxvv","vvyvv")"；}

Point::Point(doublexx,doubleyy):pi(3.14),x(xx),y(yy){}

voidmain()

{Pointa(1.5,2.82);Pointb;

a.print();b.print();cout?endl;

)

在C++中存在拷貝構造函數。他是一種特殊的構造函數，其形參是

本類的對象的引用，其作用是使用一個已經存在的對象(由拷貝構造函數

的參數指定的對象)去初始化一個新的同類的對象。如果程序員沒有定義

類的拷貝構造函數，系統就會自動生成一個默認的拷貝構造函數。這個默

認拷貝構造函數的功能是把初始值對象的每個數據成員的值都復制到新

建立的對象中。

拷貝構造函數的定義方法Class類名

{public:

類名(形參表)；〃構造函數類名(類名&對象名)；〃拷貝構造函數};

類名::類名(類名&對象名)

(函數體

下面給出一個拷貝構造函數的例子。

第54頁

第四章繼承

classPoint

{private:intx,y;public:

Point(intxx=0,intyy=0){x=xx;y=yy;}

Point(Point&p);

intGetX(){returnx;}

intGetY(){returny;}

);

Point::Point(Point&p)〃拷貝構造函數{x=p.x;y=p.y;

}

在java中構造函數定義格式如下：

修飾符類名稱(參數表)

(

程序語句

)

在C#中構造函數定義格式如下

［屬性］修飾符類名稱(參數表)

(

程序語句

)

在java和C#中存在指代構造函數。在類的內部，-個構造函數可以

調用另外一個構造函數，這是一種好的程序設計風格，因為這使類的創建

更具有合理性。在構造函數內部使用this,它用與指代另外一個構造函數

java中指代構造函數：

classpoint{

intx,y;

point(){this(0,0)〃調用帶兩個整型參數的構造函數}

point(inta,intb){x=a;y=b;}

)

C#中指代構造函數：

classpoint{

intx,y;

point():this(0,0){}〃調用帶兩個整型參數的構造函數}

point(inta,intb){x=a;y=b;}

)

point類中的第一個構造函數通過this調用了第二個構造函數完成了

對象的初始化。

第54頁

第四章繼承

小結

C++、java和C#中都可以通過構造函數給對象賦初值。如果沒有為

類規定任何構造函數的情況下，C++和java都會為系統提供默認的構造

函數。但C#不會提供默認的構造函數。在C++中不具備指代構造函數，

在java中不具備拷貝構造函數。C#和C++都具有拷貝構造函數。但在

C#中系統不會自動提供默認的拷貝構造函數。C#和C++都具指代構造函

數，但它們在語法的定義上還是有差別。C++中的構造函數可以在類的外

部通過“類名：：”的形式定義。Java和C#中的構造函數始終包含在類

中。

2.5對象的撤銷

在C++和c#語言中析構函數用來完成對象被刪除前的一些清理工

作，也就是專門的掃尾工作。析構函數是在對象的生存期即將結束的時刻

由系統自動調用的。它的調用完成后，對象也就消失了，相應的內存空間

也被釋放。

析構函數的定義方法

~類名()舉例說明如下：

classStrTp

{private:

char*s;

public:

StrTp(){s=newchar[81];}

-StrTp();

);

StrTp::~StrTp(){delete[]s;}

析構函數的特點a.析構函數名由~即類名組成

b.析構函數沒有返回值

c.析構函數沒有任何參數

d.通常析構函數由系統自動調用

e.析構函數被定義在public部分

f.如果程序員沒有定義析構函數系統會自動生成一個缺省的析構函數。

在Java語言中有這樣一個專門的函數(方法)，即finalize。方法,它提供

了用于進行撤消對象是的掃尾工作，在對一個對象進行垃圾收集前，Java

語言運行系統會自動調用該對象的finalize。方法來釋放系統資源，在Java

第54頁

第四章繼承

語言中由于引入了自動垃圾收集機制，不會出現C++語言中那樣的存儲器

泄漏等問題，所以finalize。方法的作用不像C++語言中的析構函數那樣重

要.如果不定義finalize。方法，Java語言將調用它提供的默認進行掃尾工

作.

finalize。方法定義形式如下：

聲名finalize。方法格式：

voidfinalize(){.......};

舉例說明如下：

classmyClass{

intDataMemberl;

intDataMember2;

publicmyClass(){DataMember1=1;DataMember2=2;}

voidfinalize(){DataMemberl=null;DataMember2=null;}

小結

C++中，程序員有時必須提供析構函數.由于從堆分配的內存不回自

動回收.所以正卻編寫析構函數非常關鍵.C#可以象C++一樣編寫析構函

數，也可以象java一樣通過自動垃圾回收由系統自動完成。在java和C#

這兩種語言中，與C++不同都可以通過自動垃圾回收由系統自動完成。

對象不在被引用