Java 面向對象三大特徵之繼承

補充內容：代碼塊

一、什麼叫作代碼塊：大括號括起來的一段代碼

二、分類：局部代碼塊、構造代碼塊、靜態代碼塊、同步代碼塊

三、局部代碼塊：定義在方法中的代碼塊，在局部代碼塊中聲明的變量，只在代碼塊中使用，一旦出了代碼塊，

　　　　　　　　變量就不能繼續使用了。若是在局部代碼塊中修改了代碼塊以外定義的變量，出了代碼塊後不會消除修改。

class Test {
    public static void main(String[] args) {
        int i = 10;
        {
            System.out.println(i);
            i = 20;
            int j = 100;
            System.out.println(j);
        }

        System.out.println(i);//20，局部代碼塊只對其中聲明的變量有效果，對於變量的使用仍是和之前同樣
        //System.out.println(j);不能訪問局部代碼塊中聲明的變量
    }
}

局部代碼塊

四、構造代碼塊：定義在類中方法外的代碼塊，用於給成員變量初始化賦值

　　構造代碼塊的執行說明：

  　　1、在建立對象的時候執行，由jvm默認調用

  　　2、在構造方法執行以前，執行

  　　3、任意一個構造方法執行以前，都會執行一次構造代碼塊的內容

  　　4、若是每一個構造方法都會執行的內容，提取到構造代碼塊中

 

public class Test3 {

    public static void main(String[] args) {
        Person1 p = new Person1();
        p.show();

    }

}
class Person1{
    private String name;
    {
        name = "qq";
    }
    public void show() {
        System.out.println(name);
    }
}

構造代碼塊

 

五、靜態代碼塊：定義在類中方法外有static修飾符的代碼塊，用於給靜態的成員變量賦初始值，

　　　　用於執行一些只執行一次的代碼，隨着類的加載而執行，且只執行一次

public class Test3 {
    static {
        System.out.println("測試類的靜態代碼塊執行了");//1
    }
    public static void main(String[] args) {
        Person1 p = new Person1();
        Person1 p1 = new Person1(1);

    }

}
class Person1{
    static {
        System.out.println("Person1的靜態代碼塊執行了");//3
    }

    {
        System.out.println("Person1的構造代碼塊執行了");//4,6
    }

    public Person1() {
        System.out.println("Person1的空參構造執行了");//5
    }

    public Person1(int i) {
        System.out.println("Person1的有參構造執行了");//7
    }
}

各個代碼塊的執行狀況

繼承

一、類與類之間的關係，子父類關係，子類必定比父類強

二、關鍵字 extends

三、父類：被繼承的類 基類，超類   子類：繼承的類 派生類

四、繼承優勢：提升了代碼的複用性、提升了代碼的可維護性、是多態的前提

　　　　缺點：提升了代碼的耦合性（相互依賴的程度）

　　開發原則：高內聚、低耦合

五、注意：父類的私有成員不能直接在子類中使用，子類繼承了但不能直接訪問

　　　　構造方法不能繼承 由於子類父類的類名不一樣，子類的成員數量可能大於父類的成員數量，

　　　在構造方法中賦值時不同

　　　　建立子類時先執行父類構造方法，而後執行子類構造方法

　　　**不要爲了部分功能而設計繼承

六、繼承中成員變量的關係

　　在子父類中定義了不一樣的成員變量，則既能夠訪問子類的成員變量也能夠訪問父類的成員變量

　　在子父類中定義的同名的成員變量，則根據就近原則來訪問：

　　　　在子類的方法中，若是訪問了某個變量名稱，優先在當前方法中，尋找該變量的定義，若是找到了

　　　就使用方法中的局部變量；若是沒有找到，就到子類的成員位置尋找該變量的定義，若是找到了就使用

　　　子類的成員變量；若是沒有找到，就到父類的成員位置尋找該變量的定義....一直往上找，

　　　一直到Object類中，若是尚未找到，就編譯報錯。

public class Test4 {

    public static void main(String[] args) {
        A_1 a = new A_1();
        a.show();
        a.show1();
        a.show2();
    }

}
class A{
    int age=10;
    int date = 11;
}
class A_1 extends A{
    int age=5;
    public void show() {
        int age =2;
        System.out.println(age);
    }
    public void show1() {
        System.out.println(age);
    }
    public void show2() {
        System.out.println(date);
    }
    
}

成員變量的繼承特色

七、this 和supper關鍵字

　　this:當前對象的引用
　　super:表示本類當前對象的父類的引用。
　1.this.成員變量 super.成員變量
　2.super和this訪問成員方法
　　　super只能訪問父類的成員方法，不能訪問private修飾的成員方法
　　　super.方法名()
　　　this不只能夠訪問父類的成員方法，同時也能夠訪問子類中定義的方法
　　　this.方法名（）
　3.super和this均可以訪問構造方法：this語句和super語句
　　　this():訪問本類的其它的構造方法
　　　super():訪問父類的構造方法

class Test4 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.test(1000);
    }
}

class Fu {
    int i = 10;
    int j = 20;
}

class Zi extends Fu {
    int i = 100;
    int k = 200;

    public void test(int i) {
        System.out.println(i);//1000
        System.out.println(this.i);//100
        System.out.println(super.i);//10

        System.out.println(j);//20
        System.out.println(this.j);//20
        System.out.println(super.j);//20

        System.out.println(k);//200
        System.out.println(this.k);//200
        //System.out.println(super.k);//編譯報錯
    }
}

this和supper的使用

　4.總結

　　一、含義：

 　　   this關鍵字表示本類當前對象的引用

   　　 哪一個對象在調用this所在的方法，this就表示哪一個對象

 　　   super關鍵字表示本類當前對象的父類的引用

  　　  哪一個對象在調用super所在的方法，super就表示哪一個對象中的父類部分的數據

　　二、super和this均可以訪問成員變量

  　　　super只能訪問父類中定義的成員變量

  　　　super.成員變量名

 　　 　this既能夠訪問子類中定義的成員變量，也能夠訪問父類中定義的成員變量

   　  　 his.成員變量名

　　三、super和this均可以訪問成員方法

  　　　super只能訪問父類中定義的成員方法

  　   　 super.成員方法名()

 　　     this不只能夠訪問子類中定義的成員方法，也能夠訪問父類中定義的成員方法

   　       this.成員方法名()

　　四、super和this均可以訪問構造方法：this語句和super語句

  　　    this()：訪問本類的其餘構造方法

  　　　super()：訪問父類的構造方法

八、繼承中構造方法的關係

　　一、在初始化子類數據以前，必須先完成對父類數據的初始化（由於在初始化子類數據的時候，

　　　　可能會使用到父類中的數據，因此必須先把父類數據準備好）

　　二、若是在子類的構造方法中，沒有顯式的調用任何其餘構造方法（本類、父類），在構造方法的第一句，

　　　　系統默認給你加上super()，默認要訪問父類的空參構造

　　三、若是在子類的構造方法中，手動增長了訪問父類的構造方法，那麼系統將不給你增長任何構造方法的訪問

　　四、若是在子類的構造方法中，手動增長了訪問本類的其餘構造方法，那麼系統將不給你增長任何構造方法的訪問

　　五、構造方法不能遞歸調用

  　　　　構造方法不能本身直接訪問本身，也不能本身間接的訪問本身

　　六、總結：

  　　　　一、【目標】子類的構造方法，必定要先訪問父類的構造方法

  　　　　二、特色：

    　　　　【this語句】和【super語句】必須在構造方法的第一行

     　　　　 super語句在第一句是爲了保證父類的構造方法必須先執行

     　　　　 this語句在第一句是由於間接的訪問了super，super必須先執行

    　　　　 在構造方法中，【this語句】和【super語句】不能共存

     　　　　 this語句和super語句都要在構造方法的第一行

    　　　　【this語句】和【super語句】不能出如今其餘非構造方法的非靜態成員方法中

      　　其餘方法都是在對象建立以後，才能調用的方法，若是能調用this語句，就至關於間接的使用對象，調用構造方法

 

public class Test5 {

    public static void main(String[] args) {
        Cat c = new Cat("black");
        c.show();
        System.out.println("====================");
        Cat c1 = new Cat("white",10);
        c1.show();
    }

}

class Animal {
    private String color;

    public Animal() {
        System.out.println("Animal的空參構造被調用了");
    }

    public Animal(String color) {
        this.color = color;
    }

    public void show() {
        System.out.println(color);
    }
}

class Cat extends Animal {
    public Cat() {
        //此處默認增長了一個super()
        System.out.println("Cat的空參構造被調用了");
    }

    public Cat(String color) {
        super(color);
        System.out.println("Cat的有參構造被調用了");
    }

    public Cat(String color,int age) {
        this();
        System.out.println("Cat的有參構造被調用了");
    }

}

構造方法和this supper的使用