訪問權限控制

一.成員訪問權限

1. public–公有
   成員變量，成員方法，類—-可以被任何類訪問（不管是不是在同一個包中）；

2. protected–保護
   成員變量，成員方法—-只能被同包，同目錄下，該類自身，子類訪問；

3. 無限定詞–包可訪問類型
   成員變量，成員方法，類—-只能被類自身以及同一個包或目錄下的類訪問；

4. private–私有
   成員變量，成員方法—-只能被類自身訪問；

權限總結
一個類自身可訪問該類的任何成員方法和成員變量；
同一個包類僅不能訪問private修飾的私有成員；
不同包的非子類只能訪問該類的public成員；
子類可擁有父類所有的非私有成員方法和成員變量；

使用總結
一個對象所有的成員變量如有可能應當是私有的，至少應是保護類型的；
類的構造方法至少應該是公有的，或包可訪問的；

二，靜態(tài)成員變量和靜態(tài)成員方法

1. static修飾符
   與public，private，protected等一起做修飾作用；

2. 類變量和類方法
   static修飾成員變量叫做類變量，也叫靜態(tài)成員變量；
   類變量可被該類所有的實例對象共享；
   一個非私有的靜態(tài)變量可以直接通過類名訪問，也可以通過實例對象名訪問；
   沒有static限定的是實例變量，每個對象都有自己的實例變量的拷貝，但不管多少對象被實例化，一個靜態(tài)成員變量僅存在一個版本；

3. 類方法
   static修飾的成員方法叫做類方法或者靜態(tài)成員方法；
   靜態(tài)成員方法在所有實例對象間是共享的，不需要實例化對象就可以調用，即可以直接使用類名訪問；
   靜態(tài)成員方法只能訪問靜態(tài)成員變量，輸入的參數，以及該類中的其他靜態(tài)成員方法；

4. static使用總結
   運行過程中僅依賴于輸入參數的方法應標記為靜態(tài)成員方法；
   類變量通常是定義常數，即使用限定語public static final，這樣該類變量就是安全的，因為改變量一旦經過初始化就不能改變，如PI；

復用類

7.1 組合語法

1. 對于非基本類型的對象,必須將其引用置于新的類中,但可以直接定義基本類型數據.

package cn.itcast.zhuofai728.demo1;
class WaterSource{
    private String s;
    WaterSource(){
        System.out.println("WaterSource");
        s = "Constructed";
    }
    public String toString(){return s;}
}
public class SprinklerSystem {
    private String ;
    private WaterSource source = new WaterSource();
    public String toString(){
        return "source = " + source;//注意此段代碼如果直接用return source;是錯誤的只有前面用""+source此時默認使用""+source.toString();也就是剛剛重寫toString方法
    }

    public static void main(String[] args) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
    }
}

1. 初始化引用的四種方式
   1. 在定義對象的地方.
   2. 在類的構造器中.
   3. 就在正要使用這些對象之前,對這種方式稱為惰性初始化.
   4. 使用實例初始化.

7.2 繼承語法

1. Java用super關鍵字表示超類的意思,當前類就是從超類繼承來的.
2. 如果沒有默認的基類構造器,或者想調用一個帶參數的基類構造器,就必須用關鍵字super顯示的編寫調用基類構造器的語句,并且配以適當的參數列表.
3. 調用構造器必須是你在導出類構造器中要做的第一件事.

7.3 代理

//太空船需要一個控制板
public class SpaceShipControls {
    void up(int velocity){}
    void down(int velocity){}
    void left(int velocity){}
    void right(int velocity){}
    void forward(int velocity){}
    void back(int velocity){}
    void turboBoost(){}
}
//構造太空船的一種方式是使用繼承
public class SpaceShip extends SpaceShipControls {
    private String name;
    public SpaceShip(String name){this.name = name;}
    public String toString(){return name;}
    public static void main(String[] args){
        SpaceShip protector = new SpaceShip("NSEA Protector");
        protector.forward(100);
    }
}
//可以看到下面的方法是如何傳遞給了底層的controls對象,而其接口由此也就與使用繼承得到的接口相同了.但是我們使用代理時可以擁有更多的控制力.
//因為我們可以選擇只提供在成員對象中的方法的某個子集即提供特定的幾個方法而不是全部
public class SpaceShipDelgation {
    private String name;
    private SpaceShipControls controls =
            new SpaceShipControls();
    public SpaceShipDelgation(String name){
        this.name = name;
    }
    //Delegated methods:
    public void back(int velocity){
        controls.down(velocity);
    }
    public void forward(int velocity){
        controls.forward(velocity);
    }
    public void left(int velocity){
        controls.left(velocity);
    }
    public void right(int velocity){
        controls.right(velocity);
    }
    public void turboBoost(){
        controls.turboBoost();
    }
    public void up(int velocity){
        controls.up(velocity);
    }

    public static void main(String[] args) {
        SpaceShipDelgation protector = new SpaceShipDelgation("NSEA Protector");
        protector.forward(100);
    }
}

7.4結合使用組合和繼承

1. java中沒有C++析構函數的概念.析構函數是一中在對象被銷毀時可以被自動調用的函數.其原因可能是因為在Java中,我們的習慣只是忘掉而不是銷毀對象,并且讓垃圾回收器在必要時釋放其內存.
2. 可以將清理動作置于finally子句之中,以預防異常的出現.
3. 首先,執(zhí)行類的所有特定的清理動作,其順序同生成<b>順序相反</b>(<em><b>通常這就要求基類元素仍舊存活</b></em>)
4. 如果需要進行清理,最好是編寫自己的清理方法,不要使用finalize();
5. 可以重載基類方法但是不要覆寫.

class Homer{
    char doh(char c){
        print("doh(char)");
        return 'd';
    }
    float doh(float f){
        print("doh(float)");
        return 1.0f;
    }
}
class Milhouse{}
class Bart extends Homer{
    // void doh(Milhouse m){
    //     print("doh(Milhouse)");
    // }//這是原本對的程序
    void doh(char m){

    }//這樣會產生如下錯誤Error:demo7_4.Bart中的doh(char)無法覆蓋demo7_4.Homer中的doh(char)返回類型void與char不兼容

}

1. "is-a"(是一個)的關系使用繼承來表達的,而"has-a"(有一個)的關系則是用組合來表達的.

//感覺自己還是不會組合關系所以把代碼又拷貝下來了.
class Engine{//引擎走向
    public void start(){}
    public void rev(){}
    public void stop(){}
    public void service(){}
}
class Wheel{//輪子
    public void inflate(int psi){}
}
class Window{//窗戶
    public void rollup(){}
    public void rolldown(){}
}
class Door{//門
    public Window window = new Window();
    public void open(){}
    public void close(){}
}
public class Car {//它們共同組成一個車子
    //所以就創(chuàng)建了一個engine對象四個輪子對象還有兩個門對象left和right
    //把這幾個組成car的class當作基本類型來聲明定義直接用
    public Engine engine  = new Engine();
    public Wheel [] wheel = new Wheel[4];
    public Door
    left = new Door(),
    right = new Door();//2-door
    public Car(){
        for (int i = 0; i < 4; i++) {
            wheel[i]  = new Wheel();
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.left.window.rollup();
        car.wheel[0].inflate(72);
        car.engine.service();
    }
}