JAVA 面向?qū)ο蠡A(chǔ)

面向?qū)ο?/h1>

封裝的原則

要求使對(duì)象之外的部分不能隨意存取對(duì)象的內(nèi)部數(shù)據(jù)，從而有效避免了錯(cuò)誤對(duì)它的“交叉感染”，使軟件錯(cuò)誤能局部化，降低排錯(cuò)難度

繼承

所有的類都繼承自 java.lang.Object，一些常用的方法：

equals():比較兩個(gè)對(duì)象引用時(shí)否相同。

getClass():返回對(duì)象運(yùn)行時(shí)所對(duì)應(yīng)的類的表示，從而得到相應(yīng)的信息

toString():返回對(duì)象字符串表示

finalize():用于在垃圾收集前清除對(duì)象

notify(), notifyall(), wait(): 用于多線程處理中的同步

子類（subclass）對(duì)父類（superclass，超類）的繼承

子類不能繼承父類中訪問權(quán)限為 private 的成員變量和方法。

子類可以重寫父類的方法，及命名與父類同名的成員變量。

Java 不支持多重繼承

創(chuàng)建子類

　　　　class SubClass extends SuperClass {

　　　　　　...

　　　　}

成員的隱藏和方法的重寫

子類通過隱藏父類的成員變量和重寫父類的方法，可以把父類的狀態(tài)和行為變?yōu)樽陨淼臓顟B(tài)和行為。

多態(tài)性

子類繼承父類后，同一個(gè)方法有不同的表現(xiàn)

體現(xiàn)在兩個(gè)方面：方法重載實(shí)現(xiàn)的靜態(tài)多態(tài)性（編譯時(shí)多態(tài)），方法重寫實(shí)現(xiàn)的動(dòng)態(tài)多態(tài)性（運(yùn)行時(shí)多態(tài)）

重寫方法的調(diào)用原則：子類重寫父類的方法，調(diào)用子類方法；反之，調(diào)用父類的方法

一個(gè)對(duì)象可以引用子類的實(shí)例來調(diào)用子類的方法

eg: B 繼承 A，A 的對(duì)象 a 引用 B 的實(shí)例，調(diào)用 B 的方法 callme()

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(); // 引用子類的實(shí)例
        a.callme(); 
    }
}

http://wiki.jikexueyuan.com/project/java-special-topic/images/25.png" alt="" />

類的實(shí)現(xiàn)

類聲明

　　　　[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {}
　　　　　　修飾符public, abstract, final說明類的屬性
　　　　　　className為類的屬性
　　　　　　superclassName為父類的名字
　　　　　　interfaceNameList為類所實(shí)現(xiàn)的接口列表

類體

　　　　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}; //成員方法
　　　　}

成員變量

　　　　[public | protected | private] [static] [final] [transient] [volatile] type variableName; // 成員變量
　　　　　　static: 靜態(tài)變量（類變量）
　　　　　　final: 常量
　　　　　　transient：暫時(shí)性變量，用于對(duì)象存檔
　　　　　　volatile：共享變量，用于并發(fā)線程的共享

成員方法

　　　　[public | protected | private] [static] [final | abstract] [native] [synchronized] returnType methodName(
　　　　[paramList]) [throws exceptionList] {statements}; //成員方法
　　　　　　static: 類方法，可通過類名直接調(diào)用
　　　　　　abstract: 抽象方法，沒有方法體
　　　　　　final：方法不能被重寫
　　　　　　native：集成其他語言的代碼
　　　　　　synchronized：控制多個(gè)并發(fā)線程的訪問

Java 類中的限定詞：

private：類中限定為 private 的成員，只能被這個(gè)類本身訪問。如果構(gòu)造方法為 private，則其他類不能實(shí)例化該類。

default：不加任何訪問權(quán)限，可以被這個(gè)類本身和同一個(gè)包中的類訪問。

protected：類中限定為 protected 的成員，可以被這個(gè)類本身、它的子類和同一個(gè)包中的其他類訪問。

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

final 關(guān)鍵字可以修飾類、類的成員變量和成員方法，但作用不同

修飾成員變量：稱為常量，須給出初始值

修飾成員方法：該方法不能被子類重寫

修飾類：類不能被繼承

super: 訪問父類的成員　

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

調(diào)用父類中被重寫的方法，如 super.Method([paramlist]);

調(diào)用父類的構(gòu)造函數(shù)，如 super([paramlist]);

eg:

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;
        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 Inhereritance {

    public static void main(String chars[]) {
        SubClass sc = new SubClass();
        sc.doSomething();
    }
}

http://wiki.jikexueyuan.com/project/java-special-topic/images/26.png" alt="" />

簡單數(shù)據(jù)：值類型

復(fù)合數(shù)據(jù)：引用類型

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.changeObjectValue(pt); // 引用類型的參數(shù)
        System.out.println("ptValue after change is:"+pt.ptValue);

    }

    public void changeInt(int value) {
        value = 55;
    }

    public void changeObjectValue(PassTest ref) {
        ref.ptValue = 99f;
    }
}

http://wiki.jikexueyuan.com/project/java-special-topic/images/27.png" alt="" />

簡單數(shù)據(jù)類型作為參數(shù)傳遞時(shí)，為值傳遞；復(fù)合數(shù)據(jù)類型作為參數(shù)傳遞時(shí)，為地址傳遞

方法體 方法的實(shí)現(xiàn)。方法體中局部變量若與成員變量同名，局部變量將屏蔽成員變量。

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);
    }
}

http://wiki.jikexueyuan.com/project/java-special-topic/images/28.png" alt="" />

方法重載

指多個(gè)方法享有相同的名字。這些方法的參數(shù)必須不同。且參數(shù)類型區(qū)分度要足夠：如不能使同一簡單類型的數(shù)據(jù)：int 與 long

import java.io.*;

class MethodOverloading {
    void receive(int i) {
        System.out.println("Receive in data");
        System.out.println("i = " + i);
    }

    void receive(int x, int y) {
        System.out.println("Receive two in 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);
    }
}

http://wiki.jikexueyuan.com/project/java-special-topic/images/29.png" alt="" />

構(gòu)造方法

一個(gè)特殊的方法。每個(gè)類都有構(gòu)造方法，用來初始化該類的一個(gè)對(duì)象。

構(gòu)造方法具有和類名相同的名稱，不返回任何數(shù)據(jù)類型。

重載經(jīng)常用于構(gòu)造方法。

構(gòu)造方法只能由 new 運(yùn)算符調(diào)用

抽象類和抽象方法：

用 abstract 關(guān)鍵字修飾類:抽象類

用 abstract 關(guān)鍵字修飾方法：抽象方法

抽象類必須被繼承，抽象方法必須被重寫

抽象方法只需聲明，無需實(shí)現(xiàn)

抽象類不能被實(shí)例化，抽象類不一定要包含抽象方法

若類中包含抽象方法，給類必須被定義為抽象類

接口

接口是抽象類的一種，只包含常量和方法的定義，沒有變量和方法的實(shí)現(xiàn)，且其方法都是抽象方法。

用處體現(xiàn)在：

通過接口，實(shí)現(xiàn)不相關(guān)類的相同行為

通過接口，指明多個(gè)類需要實(shí)現(xiàn)的方法

通過接口，了解對(duì)象的交互界面，無需了解對(duì)象所對(duì)應(yīng)的類

接口的定義：

接口聲明：

[public] interface interfaceName[extends listOfSuperInterface] {...}

方法體定義：

returnType methodName([paramlist]);

接口的實(shí)現(xiàn)：

在類的聲明中用 implements 子句來表示一個(gè)類使用某個(gè)接口

類體中可以使用接口中定義的常量，必須實(shí)現(xiàn)接口中定義的所有方法

一個(gè)類可以實(shí)現(xiàn)多個(gè)接口，在 implements 中用逗號(hào)隔開

接口類型的使用：

接口作為一種引用類型來使用

任何實(shí)現(xiàn)該接口的類的實(shí)例，都可以存儲(chǔ)在該接口類型的變量中，通過這些實(shí)例，訪問該類接口中的方法。