JAVA教程 第三講 Java語言中的面向對象特性(1)

3．1 面向對象技術基礎

3．1．1 面向對象的基本概念

　　面向對象的基本思想
　　面向對象是一種新興的程序設計方法,或者是一種新的程序設計規范(paradigm),其基本思想是使用對象、類、繼承、封裝、消息等基本概念來進行程序設計。從現實世界中客觀存在的事物（即對象）出發來構造軟件系統，并且在系統構造中盡可能運用人類的自然思維方式。開發一個軟件是為了解決某些問題，這些問題所涉及的業務范圍稱作該軟件的問題域。其應用領域不僅僅是軟件，還有計算機體系結構和人工智能等。
1． 對象的基本概念

　　對象是系統中用來描述客觀事物的一個實體，它是構成系統的一個基本單位。一個對象由一組屬性和對這組屬性進行操作的一組服務組成。從更抽象的角度來說，對象是問題域或實現域中某些事物的一個抽象，它反映該事物在系統中需要保存的信息和發揮的作用；它是一組屬性和有權對這些屬性進行操作的一組服務的封裝體�？陀^世界是由對象和對象之間的聯系組成的。

　　主動對象是一組屬性和一組服務的封裝體，其中至少有一個服務不需要接收消息就能主動執行（稱作主動服務）。
　　
　2． 類的基本概念

　　把眾多的事物歸納、劃分成一些類是人類在認識客觀世界時經常采用的思維方法。分類的原則是抽象。類是具有相同屬性和服務的一組對象的集合，它為屬于該類的所有對象提供了統一的抽象描述，其內部包括屬性和服務兩個主要部分。在面向對象的編程語言中，類是一個獨立的程序單位，它應該有一個類名并包括屬性說明和服務說明兩個主要部分。類與對象的關系就如模具和鑄件的關系，類的實例化結果就是對象，而對一類對象的抽象就是類。
　　

　3． 消息

　　消息就是向對象發出的服務請求，它應該包含下述信息：提供服務的對象標識、服務標識、輸入信息和回答信息。服務通常被稱為方法或函數。
3．1．2 面向對象的基本特征
　1．封裝性

　　封裝性就是把對象的屬性和服務結合成一個獨立的相同單位，并盡可能隱蔽對象的內部細節，包含兩個含義：
　　◇ 把對象的全部屬性和全部服務結合在一起，形成一個不可分割的獨立單位（即對象）。
　　◇ 信息隱蔽，即盡可能隱蔽對象的內部細節，對外形成一個邊界〔或者說形成一道屏障〕，只保留有限的對外接口使之與外部發生聯系。
　　封裝的原則在軟件上的反映是：要求使對象以外的部分不能隨意存取對象的內部數據（屬性），從而有效的避免了外部錯誤對它的"交叉感染"，使軟件錯誤能夠局部化，大大減少查錯和排錯的難度。
　　

　2．繼承性

　　特殊類的對象擁有其一般類的全部屬性與服務，稱作特殊類對一般類的繼承。例如，輪船、客輪；人、大人。一個類可以是多個一般類的特殊類，它從多個一般類中繼承了屬性與服務，這稱為多繼承。例如，客輪是輪船和客運工具的特殊類。在java語言中，通常我們稱一般類為父類（superclass,超類），特殊類為子類(subclass)。

　3．多態性

　　對象的多態性是指在一般類中定義的屬性或服務被特殊類繼承之后，可以具有不同的數據類型或表現出不同的行為。這使得同一個屬性或服務在一般類及其各個特殊類中具有不同的語義。例如："幾何圖形"的"繪圖"方法，"橢圓"和"多邊形"都是"幾何圖"的子類，其"繪圖"方法功能不同。
3．1．3 面向對象程序設計方法
OOA－Object Oriented Analysis 　　　　面向對象的分析
　　
　　OOD－Object Oriented Design 　　　　　面向對象的設計
　　
　　OOI－Object Oriented Implementation 　面向對象的實現

3．2 Java語言的面向對象特性
3．2．1 類

　　類是java中的一種重要的復合數據類型，是組成java程序的基本要素。它封裝了一類對象的狀態和方法，是這一類對象的原形。一個類的實現包括兩個部分：類聲明和類體。
　1．類聲明：

　　[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]
　　{……}

　　其中，修飾符public,abstract,final 說明了類的屬性，className為類名，superclassName為類的父類的名字，interfaceNameList為類所實現的接口列表。

　2．類體

　　類體定義如下：
　　class className
　　{[public | protected | private ] [static] 
　　[final] [transient] [volatile] type
　　variableName;　　　　　　　　　　　　　　　　　//成員變量
　　[public | protected | private ] [static]
　　[final | abstract] [native] [synchronized]
　　returnType methodName([paramList]) [throws exceptionList]
　　　{statements} 　　　　　　　　　　　　　　　 //成員方法
　　}

　3．成員變量

　　成員變量的聲明方式如下：
　　[public | protected | private ] [static] 
　　[final] [transient] [volatile] type
　　variableName; 　　　　　　　　　　　　　　　　//成員變量
　　其中，
　　static: 靜態變量（類變量）；相對于實例變量
　　final: 常量
　　transient: 暫時性變量，用于對象存檔
　　volatile: 貢獻變量，用于并發線程的共享

　4．成員方法

　　方法的實現包括兩部分內容：方法聲明和方法體。
　　[public | protected | private ] [static]
　　[final　| abstract] [native] [synchronized]
　　returnType methodName([paramList])
　　[throws exceptionList] 　　　　　　　　　　　//方法聲明
　　　{statements} 　　　　　　　　　　　　　　　//方法體

　　方法聲明中的限定詞的含義：
　　static: 類方法，可通過類名直接調用
　　abstract: 抽象方法，沒有方法體
　　final: 方法不能被重寫
　　native: 集成其它語言的代碼
　　synchronized: 控制多個并發線程的訪問

　　◇ 方法聲明
　　方法聲明包括方法名、返回類型和外部參數。其中參數的類型可以是簡單數據類型，也可以是復合數據類型（又稱引用數據類型）。

　　對于簡單數據類型來說，java實現的是值傳遞，方法接收參數的值，但不能改變這些參數的值。如果要改變參數的值，則用引用數據類型，因為引用數據類型傳遞給方法的是數據在內存中的地址，方法中對數據的操作可以改變數據的值。

　　例3-1說明了簡單數據類型與引用數據的區別。

【例3-1】
　　import java.io.*;
　　public class PassTest{
　　float ptValue;
　　public static void main(String args[]) {
　　int val;
　　PassTest pt=new PassTest();
　　val=11;
　　System.out.println("Original Int Value is:"+val); 
　　pt.changeInt(val); 　　　　　　　　　　　　　　　　　　//值參數
　　System.out.println("Int Value after Change is:" +val); /*值參數
　　　　　　　　　　　　　　　　　　　 值的修改，沒有影響值參數的值*/
　　pt.ptValue=101f;
　　System.out.println("Original ptValue is:"+pt.ptValue);
　　pt.changeObjValue(pt); //引用類型的參數
　　System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用參數值的修改，改變了引用參數的值*/ 
　　}
　　public void changeInt(int value){
　　value=55; 　　　　　　　　　　　//在方法內部對值參數進行了修改
　　}
　　public void changeObjValue(PassTest ref){
　　ref.ptValue=99f; 　　　　　　 //在方法內部對引用參數進行了修改
　　　　}
　　}

　　　運行結果 
c:\%26gt;java PassTest
Original Int Value is : 11
Int Value after Change is: 11
Original ptValue is: 101.0
ptValue after Change is : 99.0

　　◇ 方法體
　　方法體是對方法的實現，它包括局部變量的聲明以及所有合法的Java指令。方法體中聲明的局部變量的作用域在該方法內部。若局部變量與類的成員變量同名，則類的成員變量被隱藏。

　　例3-2 說明了局部變量z和類成員變量z的作用域是不同的。
【例3-2】
　　import java.io.*;
　　class Variable{
　　int x=0,y=0,z=0; 　　　　 　　　　　　 　//類的成員變量
　　void init(int x,int y) {
　　this.x=x; this.y=y; 
　　int z=
　 5; 　　　　　　　　　　　　　　　 //局部變量
　　System.out.println("** in init**");
　　System.out.println("x="+x+" y="+y+" z="+z);
　　　　} 
　　}
　　public class VariableTest{
　　public static void main(String args[]){
　　Variable v=new Variable();
　　System.out.println("**before init**");
　　System.out.println("x="+v.x+" y="+ v.y+" z="+v.z);
　　v.init(20,30);
　　System.out.println("**after init**");
　　System.out.println("x="+v.x+ " y="+ v.y+" z="+v.z);
　　　　}
　　}

　　　運行結果 
c:\%26gt;java VariableTest
**before init**
x=0 y=0 z=0
** in init **
x=20 y=30 z=5
**after init**
x=20 y=30 z=0


　　上例中我們用到了this，這是因為init()方法的參數名與類的成員變量x,y的名字相同，而參數名會隱藏成員變量，所以在方法中，為了區別參數和類的成員變量，我們必須使用this。this-----用在一個方法中引用當前對象，它的值是調用該方法的對象。返回值須與返回類型一致，或者完全相同，或是其子類。當返回類型是接口時，返回值必須實現該接口。

　5．方法重載
　
　　方法重載是指多個方法享有相同的名字，但是這些方法的參數必須不同，或者是參數的個數不同，或者是參數類型不同。返回類型不能用來區分重載的方法。

　　參數類型的區分度一定要足夠，例如不能是同一簡單類型的參數，如int與long。

【例3-3】
　　import java.io.*;
　　class MethodOverloading{
　　void receive(int i) {
　　System.out.println("Receive one int data");
　　System.out.println("i="+i);
　　}
　　void receive(int x, int y) {
　　System.out.println("Receive two int datas");
　　System.out.println("x="+x+" y="+y);
　　　　}　
　　}
　　public class MethodOverloadingTest{
　　public static void main(String args[]) {
　　MethodOverloading mo=new MethodOverloading();
　　mo.receive(1);
　　mo.receive(2,3);

　　　　}　
　　}

　　運行結果(編譯器會根據參數的個數和類型來決定當前所使用的方法) 
c:\%26gt;java MethodOverloadingTest
Receive one int data
i=1
Receive two int datas
x=2 y=3

　6． 構造方法

　　◇ 構造方法是一個特殊的方法。Java 中的每個類都有構造方法，用來初始化該類的一個對象。
　　◇ 構造方法具有和類名相同的名稱，而且不返回任何數據類型。
　　◇ 重載經常用于構造方法。
　　◇ 構造方法只能由new運算符調用

【例3-4】
　　class Point{
　　int x,y;
　　Point(){
　　x=0; y=0;
　　}
　　Point(int x, int y){
　　this.x=x; 
　　this.y=y;
　　　　}
　　}

3．2．2 對象

　　類實例化可生成對象，對象通過消息傳遞來進行交互。消息傳遞即激活指定的某個對象的方法以改變其狀態或讓它產生一定的行為。一個對象的生命周期包括三個階段：生成、使用和消除。
　1. 對象的生成

　　對象的生成包括聲明、實例化和初始化。
　　格式為：
　　type objectName=new type([paramlist]);

　　◇ 聲明：type objectName 
　　聲明并不為對象分配內存空間，而只是分配一個引用空間；對象的引用類似于指針，是32位的地址空間，它的值指向一個中間的數據結構，它存儲有關數據類型的信息以及當前對象所在的堆的地址，而對于對象所在的實際的內存地址是不可操作的，這就保證了安全性。
　　
　　◇ 實例化：運算符new為對象分配內存空間，它調用對象的構造方法，返回引用；一個類的不同對象分別占據不同的內存空間。

　　◇ 生成：執行構造方法，進行初始化；根據參數不同調用相應的構造方法。

　2. 對象的使用

　　通過運算符"."可以實現對變量的訪問和方法的調用。變量和方法可以通過設定訪問權限來限制其它對象對它的訪問。

　　◇調用對象的變量
　　格式：objectReference.variable
　　objectReference是一個已生成的對象，也可以是能生成對象的表達式
　　例：　p.x= 10;
　　　　　tx=new Point( ).x;

　　◇調用對象的方法
　　格式：objectReference.methodName([paramlist]);
　　例如：p.move(30,20);
　　　　　new Point( ).move(30,20);

　3. 對象的清除

　　當不存在對一個對象的引用時，該對象成為一個無用對象。Java的垃圾收集器自動掃描對象的動態內存區，把沒有引用的對象作為垃圾收集起來并釋放。
　　System.gc( );　　
　　當系統內存用盡或調用System.gc( )要求垃圾回收時，垃圾回收線程與系統同步運行。
3．2．3 面向對象特性

　　java語言中有三個典型的面向對象的特性：封裝性、繼承性和多態性，下面將詳細闡述。
　1． 封裝性

　　java語言中，對象就是對一組變量和相關方法的封裝，其中變量表明了對象的狀態，方法表明了對象具有的行為。通過對象的封裝，實現了模塊化和信息隱藏。通過對類的成員施以一定的訪問權限，實現了類中成員的信息隱藏。

　　◇ 類體定義的一般格式：
　　class className
　　{ 　　[public | protected | private ] [static] 
　　　　　[final] [transient] [volatile] type
　　　　　variableName; 　　　　　　　　　　　//成員變量
　　　　　[public | protected | private ] [static]
　　　　　[final | abstract] [native] [synchronized]
　　　　　returnType methodName([paramList])
　　　　　[throws exceptionList]
　　　　　{statements} //成員方法
　　}

　　◇ java類中的限定詞
　　java語言中有四種不同的限定詞，提供了四種不同的訪問權限。

　　1） private 
　　類中限定為private的成員，只能被這個類本身訪問。
　　如果一個類的構造方法聲明為private,則其它類不能生成該類的一個實例。

　　2） default
　　類中不加任何訪問權限限定的成員屬于缺省的（default）訪問狀態，可以被這個類本身和同一個包中的類所訪問。

　　3） protected
　　類中限定為protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。

　　4） public
　　類中限定為public的成員，可以被所有的類訪問。

　　表3-1列出了這些限定詞的作用范圍。

【表3-1】　java中類的限定詞的作用范圍比較
   同一個類    同一個包    不同包的子類    不同包非子類
private    *            
default    *    *        
protected    *    *    *    
public    *    *    *    *

　　2． 繼承性

　　通過繼承實現代碼復用。Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。繼承而得到的類稱為子類，被繼承的類稱為父類。子類不能繼承父類中訪問權限為private的成員變量和方法。子類可以重寫父類的方法，及命名與父類同名的成員變量。但Java不支持多重繼承，即一個類從多個超類派生的能力。

　　◇ 創建子類
　　格式：
　　class SubClass extends SuperClass {
　　…
　　}

　　◇ 成員變量的隱藏和方法的重寫
　　子類通過隱藏父類的成員變量和重寫父類的方法，可以把父類的狀態和行為改變為自身的狀態和行為。

　　例如：
　　class SuperClass{
　　　　int x; …
　　　　void setX( ){ x=0; } …
　　}
　　class SubClass extends SuperClass{
　　　　int x; 　　//隱藏了父類的變量x
　　　　…
　　　　void setX( ) { //重寫了父類的方法 setX()
　　　　x=5; } ….
　　}