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

　注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的參數表和相同的返回類型，只是函數體不同。
◇ super
　　java中通過super來實現對父類成員的訪問，super用來引用當前對象的父類。Super 的使用有三種情況：

　　1）訪問父類被隱藏的成員變量，如：
　　　　super.variable; 

　　2）調用父類中被重寫的方法，如：
　　　　super.Method([paramlist]);

　　3）調用父類的構造函數，如：
　　　　super([paramlist]);

【例3-5】
　　import java.io.*;
　　class SuperClass{
　　　　int x;
　　　　SuperClass( ) {
　　　　　x=3;
　　　　　System.out.println("in SuperClass : x=" +x);
　　　　}
　　　　　void doSomething( ) {
　　　　　System.out.println("in SuperClass.doSomething()");
　　　　}
　　}
　　class SubClass extends SuperClass {
　　　　int x;
　　　　SubClass( ) {
　　　　　super( ); 　　　//調用父類的構造方法
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句
　　　　　System.out.println("in SubClass :x="+x);
　　　　}
　　　　　void doSomething( ) {
　　　　　super.doSomething( ); //調用父類的方法
　　　　　System.out.println("in SubClass.doSomething()");
　　　　　System.out.println("super.x="+super.x+" sub.x="+x);
　　　　}
　　}
　　public class Inheritance {
　　　　　public static void main(String args[]) {
　　　　　SubClass subC=new SubClass();
　　　　　subC.doSomething();
　　　　}
　　}

　　　　運行結果
c:\%26gt; java Inheritance
in SuperClass: x=3
in SubClass: x=5
in SuperClass.doSomething()
in SubClass.doSomething()
super.x=3 sub.x=5


　3． 多態性

　　在java語言中，多態性體現在兩個方面：由方法重載實現的靜態多態性（編譯時多態）和方法重寫實現的動態多態性（運行時多態）。

　　1） 編譯時多態
　　在編譯階段，具體調用哪個被重載的方法，編譯器會根據參數的不同來靜態確定調用相應的方法。

　　2） 運行時多態
　　由于子類繼承了父類所有的屬性（私有的除外），所以子類對象可以作為父類對象使用。程序中凡是使用父類對象的地方，都可以用子類對象來代替。一個對象可以通過引用子類的實例來調用子類的方法。

　　◇ 重寫方法的調用原則：java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法；如果子類繼承了父類的方法（未重寫），則運行時系統調用父類的方法。

　　在例3-6中，父類對象a引用的是子類的實例，所以，java運行時調用子類B的callme方法。

【例3-6】
　　import java.io.*;
　　class A{
　　　　　void callme( ) {
　　　　　　System.out.println("Inside A’s callme()method"); 
　　　　　} 
　　}
　　class B extends A{
　　　　　void callme( ) {
　　　　　　System.out.println("Inside B’s callme() Method"); 
　　　　　}
　　}
　　public class Dispatch{
　　　　　public static void main(String args[]) {
　　　　　　A a=new B();
　　　　　　a.callme( );
　　　　　}
　　}

　　　　運行結果
c:\%26gt; java Dispatch
Inside B’s callme() method

　　◇ 方法重寫時應遵循的原則：
　　1）改寫后的方法不能比被重寫的方法有更嚴格的訪問權限（可以相同）。
　　2）改寫后的方法不能比重寫的方法產生更多的例外。



　4． 其它

　　◇ final 關鍵字
　　final 關鍵字可以修飾類、類的成員變量和成員方法，但final 的作用不同。
　　
　　1） final 修飾成員變量：
　　final修飾變量,則成為常量，例如
　　final type variableName;
　　修飾成員變量時，定義時同時給出初始值，而修飾局部變量時不做要求。

　　2） final 修飾成員方法：
　　final修飾方法，則該方法不能被子類重寫
　　final returnType methodName(paramList){
　　…
　　}
　　3） final 類： 
　　final修飾類，則類不能被繼承
　　final class finalClassName{
　　…
　　}

　　◇ 實例成員和類成員
　　用static 關鍵字可以聲明類變量和類方法，其格式如下：
　　static type classVar;
　　static returnType classMethod({paramlist}) {
　　…
　　}
　
　　如果在聲明時不用static 關鍵字修飾，則聲明為實例變量和實例方法。
　　1） 實例變量和類變量
　　每個對象的實例變量都分配內存，通過該對象來訪問這些實例變量，不同的實例變量是不同的。
　　類變量僅在生成第一個對象時分配內存，所有實例對象共享同一個類變量，每個實例對象對類變量的改變都會影響到其它的實例對象。類變量可通過類名直接訪問，無需先生成一個實例對象，也可以通過實例對象訪問類變量。

　　2） 實例方法和類方法
　　實例方法可以對當前對象的實例變量進行操作，也可以對類變量進行操作，實例方法由實例對象調用。
　　但類方法不能訪問實例變量，只能訪問類變量。類方法可以由類名直接調用，也可由實例對象進行調用。類方法中不能使用this或super關鍵字。

　　例3-7 是關于實例成員和類成員的例子。

【例3-7】
　　class Member {
　　　　static int classVar;
　　　　int instanceVar;
　　　　static void setClassVar(int i) {
　　　　　classVar=i;
　　　　　// instanceVar=i; // 類方法不能訪問實例變量
　　　　}
　　　　static int getClassVar()
　　　　　{ return classVar; }
　　　　void setInstanceVar(int i)
　　　　　{ classVar=i; //實例方法不但可以訪問類變量，也可以實例變量
　　　　　instanceVar=i; }
　　　　　int getInstanceVar( ) 
　　　　　{ return instanceVar; }
　　　　}
　　　　public class MemberTest{
　　　　　public static void main(String args[]) {
　　　　　　　　 Member m1=new member();
　　　　　　　　 Member m2=new member();
　　　　　　　　 m1.setClassVar(1);
　　　　　　　　 m2.setClassVar(2); 
　　　　　　　　 System.out.println("m1.classVar="+m1.getClassVar()+" 
　　　　　　　　 　　　　　　　　　　m2.ClassVar="+m2.getClassVar());
　　　　　　　　 m1.setInstanceVar(11); 
　　　　　　　　 m2.setInstanceVar(22);
　　　　　　　　 System.out.println("m1.InstanceVar="+m1.getInstanceVar
　　　　　　　　　　　　　　()+" m2.InstanceVar="+m2.getInstanceVar());
　　　　　}
　　　　}

　　　　運行結果
c:\%26gt; java MemberTest
m1.classVar=2 m2.classVar=2
m1.InstanceVar=11 m2.InstanceVar=22


　　◇ 類java.lang.Object
　　類java.lang.Object處于java開發環境的類層次的根部，其它所有的類都是直接或間接地繼承了此類。該類定義了一些最基本的狀態和行為。下面，我們介紹一些常用的方法。

　　equals() ：比較兩個對象(引用)是否相同。
　　getClass()：返回對象運行時所對應的類的表示，從而可得到相應的信息。
　　toString()：用來返回對象的字符串表示。
　　finalize()：用于在垃圾收集前清除對象。
　　notify(),notifyAll(),wait()：用于多線程處理中的同步。

3．2．4抽象類和接口
　1． 抽象類

　　java語言中，用abstract 關鍵字來修飾一個類時，這個類叫做抽象類，用abstract 關鍵字來修飾一個方法時，這個方法叫做抽象方法。格式如下：
　　abstract class abstractClass{ …} //抽象類
　　abstract returnType abstractMethod([paramlist]) //抽象方法

　　抽象類必須被繼承，抽象方法必須被重寫。抽象方法只需聲明，無需實現；抽象類不能被實例化，抽象類不一定要包含抽象方法。若類中包含了抽象方法，則該類必須被定義為抽象類。

　2． 接口

　　接口是抽象類的一種，只包含常量和方法的定義，而沒有變量和方法的實現，且其方法都是抽象方法。它的用處體現在下面幾個方面：
　　◇ 通過接口實現不相關類的相同行為,而無需考慮這些類之間的關系。


◇ 通過接口指明多個類需要實現的方法。
　　◇ 通過接口了解對象的交互界面,而無需了解對象所對應的類。

　　1）接口的定義
　　接口的定義包括接口聲明和接口體。
　　接口聲明的格式如下：
　　[public] interface interfaceName[extends listOfSuperInterface] { … }
　　 extends 子句與類聲明的extends子句基本相同，不同的是一個接口可有多個父接口，用逗號隔開，而一個類只能有一個父類。

　　接口體包括常量定義和方法定義
　　常量定義格式為：type NAME=value; 該常量被實現該接口的多個類共享; 具有public ,final, static的屬性。
　　方法體定義格式為：(具有 public和abstract屬性)
　　returnType methodName([paramlist])；

　　2）接口的實現
　　在類的聲明中用implements子句來表示一個類使用某個接口，在類體中可以使用接口中定義的常量，而且必須實現接口中定義的所有方法。一個類可以實現多個接口,在implements子句中用逗號分開。

　　3） 接口類型的使用
　　接口作為一種引用類型來使用。任何實現該接口的類的實例都可以存儲在該接口類型的變量中，通過這些變量可以訪問類所實現的接口中的方法。
3．2．5 內部類
　1． 內部類的定義和使用：

　　內部類是在一個類的內部嵌套定義的類，它可以是其它類的成員，也可以在一個語句塊的內部定義，還可以在表達式內部匿名定義。
　　內部類有如下特性
同。

　　◇ super
　　java中通過super來實現對父類成員的訪問，super用來引用當前對象的父類。Super 的使用有三種情況：

　　1）訪問父類被隱藏的成員變量，如：
　　　　super.variable; 

　　2）調用父類中被重寫的方法，如：
　　　　super.Method([paramlist]);

　　3）調用父類的構造函數，如：
　　　　super([paramlist]);

【例3-5】
　　import java.io.*;
　　class SuperClass{
　　　　int x;
　　　　SuperClass( ) {
　　　　　x=3;
　　　　　System.out.println("in SuperClass : x=" +x);
　　　　}
　　　　　void doSomething( ) {
　　　　　System.out.println("in SuperClass.doSomething()");
　　　　}
　　}
　　class SubClass extends SuperClass {
　　　　int x;
　　　　SubClass( ) {
　　　　　super( ); 　　　//調用父類的構造方法
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句
　　　　　System.out.println("in SubClass :x="+x);
　　　　}
　　　　　void doSomething( ) {
　　　　　super.doSomething( ); //調用父類的方法
　　　　　System.out.println("in SubClass.doSomething()");
　　　　　System.out.println("super.x="+super.x+" sub.x="+x);
　　　　}
　　}
　　public class Inheritance {
　　　　　public static void main(String args[]) {
　　　　　SubClass subC=new SubClass();
　　　　　subC.doSomething();
　　　　}
　　}

　　　　運行結果 
c:\%26gt; java Inheritance
in SuperClass: x=3
in SubClass: x=5
in SuperClass.doSomething()
in SubClass.doSomething()
super.x=3 sub.x=5


　3． 多態性

　　在java語言中，多態性體現在兩個方面：由方法重載實現的靜態多態性（編譯時多態）和方法重寫實現的動態多態性（運行時多態）。

　　1） 編譯時多態
　　在編譯階段，具體調用哪個被重載的方法，編譯器會根據參數的不同來靜態確定調用相應的方法。

　　2） 運行時多態
　　由于子類繼承了父類所有的屬性（私有的除外），所以子類對象可以作為父類對象使用。程序中凡是使用父類對象的地方，都可以用子類對象來代替。一個對象可以通過引用子類的實例來調用子類的方法。

　　◇ 重寫方法的調用原則：java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法；如果子類繼承了父類的方法（未重寫），則運行時系統調用父類的方法。

　　在例3-6中，父類對象a引用的是子類的實例，所以，java運行時調用子類B的callme方法。

【例3-6】
　　import java.io.*;
　　class A{
　　　　　void callme( ) {
　　　　　　System.out.println("Inside A’s callme()method"); 
　　　　　} 
　　}
　　class B extends A{
　　　　　void callme( ) {
　　　　　　System.out.println("Inside B’s callme() Method"); 
　　　　　}
　　}
　　public class Dispatch{
　　　　　public static void main(String args[]) {
　　　　　　A a=new B();
　　　　　　a.callme( );
　　　　　}
　　}

　　　　運行結果
c:\%26gt; java Dispatch
Inside B’s callme() method

　　◇ 方法重寫時應遵循的原則：
　　1）改寫后的方法不能比被重寫的方法有更嚴格的訪問權限（可以相同）。
　　2）改寫后的方法不能比重寫的方法產生更多的例外。



　4． 其它

　　◇ final 關鍵字
　　final 關鍵字可以修飾類、類的成員變量和成員方法，但final 的作用不同。
　　
　　1） final 修飾成員變量：
　　final修飾變量,則成為常量，例如
　　final type variableName;
　　修飾成員變量時，定義時同時給出初始值，而修飾局部變量時不做要求。

　　2） final 修飾成員方法：
　　final修飾方法，則該方法不能被子類重寫
　　final returnType methodName(paramList){
　　…
　　}
　　3） final 類： 
　　final修飾類，則類不能被繼承
　　final class finalClassName{
　　…
　　}

　　◇ 實例成員和類成員
　　用static 關鍵字可以聲明類變量和類方法，其格式如下：
　　static type classVar;
　　static returnType classMethod({paramlist}) {
　　…
　　}
　
　　如果在聲明時不用static 關鍵字修飾，則聲明為實例變量和實例方法。
　　1） 實例變量和類變量
　　每個對象的實例變量都分配內存，通過該對象來訪問這些實例變量，不同的實例變量是不同的。
　　類變量僅在生成第一個對象時分配內存，所有實例對象共享同一個類變量，每個實例對象對類變量的改變都會影響到其它的實例對象。類變量可通過類名直接訪問，無需先生成一個實例對象，也可以通過實例對象訪問類變量。

　　2） 實例方法和類方法
　　實例方法可以對當前對象的實例變量進行操作，也可以對類變量進行操作，實例方法由實例對象調用。
　　但類方法不能訪問實例變量，只能訪問類變量。類方法可以由類名直接調用，也可由實例對象進行調用。類方法中不能使用this或super關鍵字。

　　例3-7 是關于實例成員和類成員的例子。

【例3-7】
　　class Member {
　　　　static int classVar;
　　　　int instanceVar;
　　　　static void setClassVar(int i) {
　　　　　classVar=i;
　　　　　// instanceVar=i; // 類方法不能訪問實例變量
　　　　}
　　　　static int getClassVar()
　　　　　{ return classVar; }
　　　　void setInstanceVar(int i)
　　　　　{ classVar=i; //實例方法不但可以訪問類變量，也可以實例變量
　　　　　instanceVar=i; }
　　　　　int getInstanceVar( ) 
　　　　　{ return instanceVar; }
　　　　}
　　　　public class MemberTest{
　　　　　public static void main(String args[]) {
　　　　　　　　 Member m1=new member();
　　　　　　　　 Member m2=new member();
　　　　　　　　 m1.setClassVar(1);
　　　　　　　　 m2.setClassVar(2); 
　　　　　　　　 System.out.println("m1.classVar="+m1.getClassVar()+" 
　　　　　　　　 　　　　　　　　　　m2.ClassVar="+m2.getClassVar());
　　　　　　　　 m1.setInstanceVar(11); 
　　　　　　　　 m2.setInstanceVar(22);
　　　　　　　　 System.out.println("m1.InstanceVar="+m1.getInstanceVar
　　　　　　　　　　　　　　()+" m2.InstanceVar="+m2.getInstanceVar());
　　　　　}
　　　　}

　　　　運行結果
c:\%26gt; java MemberTest
m1.classVar=2 m2.classVar=2
m1.InstanceVar=11 m2.InstanceVar=22