java繼承,object,final基本使用；

繼承繼承的概念

根據已有類派生出新類的技術。還能夠有本身的獨特屬性。

爲何要使用繼承？（優點）

• 代碼重用
• 便於維護（高耦合，代碼之間緊密聯繫）

注意：java類只支持單一繼承，不容許多繼承：即意味着一個父類能夠有多個子類，可是子類只能有多個父類

語法：

編寫父類

編寫子類：在子類加上 extends 父類名稱

使用

一：繼承父類：子類繼承父類的 「全部」成員，就像在本身類中使用

二：子類不能繼承父類的：
1. 父類中private修飾的成員
2. 子類和父類不在同一程序包下，使用默認修飾符的成員
3. 構造器。

別稱：

父類，超類，基類

子類，派生類

程序設計原則：里氏替換原則

子類是父類，子類徹底替換父類不會出現問題

方法重寫

子類中的方法名字，參數，返回值類型與父類中的同樣

重寫場合

• 子類和父類中的方法的功能不一樣
• 子類修改了父類中的功能

重寫要注意：
1. .必須 子類
2. 必須是實例成員方法
3. 方法名必須以有
4. 參數同樣 或父類擦除後和子類相同
5. 返回值類型和父類相同 或 子類能夠是父類的子類型（引用）
6. 子類方法的訪問修飾符 不能比父類更嚴格（低）
7. 異常處理，子類不能比父類異常範圍更大

重載和重寫的區別

區別點

重載

重寫

位置

在同一個類中

在有繼承關係的子類中

方法

方法名相同，參數列表不一樣，與返回值無關

方法名，參數，返回值類型與父親一致

做用

方便記憶

修改父親的功能

英文

overloading

overriding

super

父類的範圍

能夠調用父類的成員（成員變量，方法）

位置：

子類構造器的第一行代碼處

做用

• 區分 子類和 父類同名的成員
• 調用父類構造器，super（）；

super使用注意：子類構造器中沒有顯示調用父類構造或本類構造，那麼系統會自動分配一個super（）調用父類的==無參==構造器

父類中沒有無參構造器，只有帶參數的構造器，解決辦法：
1. 在父類中定義一個無參構造器
2. 顯示調用帶參構造器，而且傳參

this和super的區別和相同點

區別：

一、super()主要是對父類構造函數的調用，this()是對重載構造函數的調用
二、super()主要是在繼承了父類的子類的構造函數中使用，是在不一樣類中的使用；this()主要是在同一類的不一樣構造函數中的使用

相同點：

一、super()和this()都必須在構造函數的第一行進行調用，不然就是錯誤的

繼承的傳遞：

子類能夠繼承直接父類的成員，也能夠繼承間接父類的成員

objectfinalize（）

垃圾回收以前調用

強制垃圾回收：System.gc();

//垃圾回收

package day16_1;

class Student{

    @Override

    protected void finalize() throws Throwable {

        System.out.println("this----->"+this);

        super.finalize();

    }

}

public class TestStudent {

    public static void main(String[] args) {

        Student guojing = new Student();

        System.out.println(guojing);

        //斷開

        guojing = null;

        //強制垃圾回收

        System.gc();

        System.out.println(guojing);

    }

}

toString

對象的字符串描述信息

注意：在使用print（）或者println（）輸出對象名字時，會自動調用toString

System.out.println(guojing);

System.out.println(guojing.toString());

//重寫toString，調用tostring時，輸出的是「我愛學習」

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return "我愛學習";

    }

equals

//重寫equals

    @Override

    public boolean equals(Object obj) {

        // 全部的屬性值都相同就是同一個對象

        Student stu = (Student)obj;//父類類型強制轉換爲子類類型

        return this.name.equals(stu.name) &&this.age ==stu.age;

    }

    public class TestStudent {

    public static void main(String[] args) {

        Student guojing = new Student("郭靖",22);

        Student yangkang = new Student("郭靖",22);

        System.out.println(guojing);

        System.out.println(yangkang);

        System.out.println(guojing.equals(yangkang));//object類的equals

        String s = "abc";

        System.out.println(s.equals("def"));//String類下也有equals類，而且是重寫的object的

    }

}

final

修飾符：

1. 類，不能被子類繼承

- 爲了類的安全性，不容許子類修改

- 類之間的方法有複雜的調用關係

- 此類是最終版本的類，不想再擴展了

2. 方法，不能被子類重寫

- 不但願子類更改，全部子類使用的是父類同一版本的方法

3. 變量，值不能更改，這是也就是一個常量

- 對於基本數據類型值不能修改，

- 對於引用類型，不能換對象，對象裏的值能夠變

Final B b = new B();

b = new B（）；//出錯，不能改對象

b.value = 45;//對象的值能夠更改

1

2

3

常量的命名規則：全部字母大寫，單詞之間用下劃線鏈接

常量的好處

（1）安全性，不容許隨意更改

（2）好維護，一個常量值更改了，全部應用的地方都改了

（3）加強可讀性

什麼狀況下會派生新類

子類 會增長屬性

子類 增長了方法

設計類的繼承關係注意

繼承關係不要超過三層

能夠被子類繼承的類

寫詳細的文檔說明

儘可能封裝，private；對全部用戶都開放，用public；只對子類開放，protected；對全部用戶都開放，又不想被子類更改，用final

優勢 ：

1.代碼重用

2.便於維護

缺點：

1.高耦合

2.破壞封裝

組合

總體和局部的關係

//發動機

class Engine{

    public void start(){

        System.out.println("啓動");

    }

    public void stop(){

        System.out.println("中止");

    }

}

//輪子

class Wheel{

    public void inflate(int r){

        System.out.println("重氣"+ r);

    }

}

//車窗戶

class Window{

    public void roolUp(){

        System.out.println("升");

    }

    public void roolDown(){

        System.out.println("降");

    }

}

//車門

class Door{

    Window win = new Window();

    public void open(){

        System.out.println("車開門");

    }

    public void close(){

        System.out.println("車關門");

    }

}

//構造器

class Car{

    Engine e = null;//

    Wheel [] w =null;//

    Door[] d = null;//new Door();

    Car(){

        e = new Engine();

        w =new Wheel[4];

        for(int i = 0;i <w.length;i++){

            w_= new Wheel();_

        }

        d = new Door[2];

        for(int i = 0;i <d.length;i++){

            d= new Door();__

        }

    }

}

public class TestCar {

    public static void main(String[] args) {

        Car car = new Car();

        car.e.start();

        car.e.stop();

        for(int i = 0; i < car.w.length;i++){

            car.w_.inflate(100);_

        }

        car.d[0].open();

        car.d[1].close();

        car.d[2].win.roolDown();

        car.d[3].win.roolUp();

    }

}