Java基礎_07

1：繼承與構造方法

 

Child c = new Child();

 

要想建立子類，則必須先建立父類。

當建立子類的實例時，會先調用父類的構造方法，將這個類的字節碼加載到內存中。

 

package cn.demo;

import org.junit.Test;

 

public class Demo01 {

    @Test

    public void test1(){

        Grandpa g = new Child();   //父類的變量指向子類的實例  回首先調用父類的構造方法

//在此處是child—father-grandpa

 

    }

}

class Grandpa {

    public Grandpa() {

        System.err.println("Grandpa..."+this);//this永遠是指new的對象內存地址值，即引用

    }

}

 

class Father extends Grandpa {

    public Father() {

        System.err.println("Father.."+this);

    }

}

 

class Child extends Father {

    public Child() {

        System.err.println("Child.."+this);

    }

}

輸出：

Grandpa...cn.demo.Child@514713

Father..cn.demo.Child@514713

Child..cn.demo.Child@514713

 

說明：

   1：實例化子類時，會先調用父類的默認的構造方法。即先會加載父類。

   2：此時在任意的位置(非靜態的方法)中使用的this表示的是new的那個對象。

2：Super關鍵字 – 與this同樣只能用於非靜態的方法中

用法1：

   調用被隱藏的成員變量。

   調用被重寫的成員方法。

class Grandpa {

    public String name = "Grandpa";

    public void say(){

        System.err.println("name is:"+name);

    }

}

 

class Father extends Grandpa {

    public String name = "Father";//若是子類的成員變量與父類的成員量重名，此時父類的成員變量叫被隱藏了    //重寫

    @Override

    public void say() {

        System.err.println("father name is:"+name);//Father name is : Father

        //若是但願訪問父類的成員變量則能夠在非靜態的方法裏面使用super關鍵字

        System.err.println("grandpa is :"+super.name);//Grandpa is Grandpa

        //固然也能夠調用父類被重寫的方法

        super.say();//name is grandpa

    }

}

輸出：

father name is:Father

grandpa is :Grandpa

name is:Grandpa

 

用法2：

  在子類的構造方法的第一句調用父類的某個構造。

class One {

    public One(String name) {

    }

}

 

/**

 * 當父類沒有默認構造時 若是實例化子類，子類又要調用父類的默認的構造 由於父類又沒有默認的構造，因此子類出錯

 * 此時，子類必需要手工的添加一個任意的構造，且在構造方法的第一句 顯式調用父類的某個有參數的構造

 */

class Two extends One {

    public Two() {//在子類的構造中，必需要調用父類的某個構造

        super("Jack");//

    }

    public Two(String nnm){

        super("Mary");

    }

}

3：final關鍵字

修飾的對象	功能	示例：
能夠修飾局部變量     當修飾局部變量 若是局部變量是數組則整個的數組不能再指向新的地址，可是裏面的值是能夠修改的：	這個變量不能再指向新的地址
能夠修飾成員方法   當修飾非靜態的方法時，說明這個方法子類不能重寫。		public class Demo03 {     @Test     public void test1(){         ATwo t = new ATwo();         t.say();//只能調用父類的     } }   class AOne{     //此方法是最後的，不能被子類重寫     public final void say(){         System.err.println("ddddd");     } } class ATwo extends AOne{ }
Final能夠修飾類    表示這個類不能有子類

Fnal能夠修飾：

  成員變量

  局部變量

  類

  成員方法。

[

         其餘的所修飾符號，能不修改局部變量，只有final能夠修飾局部變量。

}

4：final與private

Final修飾的類不能有子類,可是能夠被實例化。

 

用private修飾的構造，不能擁有子類，也不能夠被實例化.

5：抽象類

 

抽象關鍵字是： abstract 。

 

  被abstract修飾類叫抽象類。

   特色：

      1：抽象類不能被new實例化。

                            /**

 * 聲明一個抽象類

 */

abstract class Animal{

   

}

如下是錯誤的;
    new Animal();

 

 

      2：抽象類能夠擁有抽象方法

            [抽象方法，是使用了abstract修飾的方法]

            抽象方法不能有方法體：方法後面加上{}即被視爲有方法體

               Public abstract void say();

      3:抽象類能夠有抽象方法。也能夠沒有抽象方法。

 

abstract class Animal{

    //此方法是非抽象的

    public void say(){

       

    }

    //抽象

    public abstract void run();

}

    

     4：抽象方法必需要在抽象類裏面。   

 

 

     5:當一個類繼承抽象類時，必需要實現（重寫）全部父類中的抽象方法

 abstract class Animal{

    //此方法是非抽象的

    public void say(){

       

    }

    //抽象

    public abstract void run();

    public abstract void hi();

}

 

class Dog extends Animal{  

    @Override

    public void run() {

    }

 

    @Override

    public void hi() {

    }

}

   5：抽象類能夠擁有構造方法。

  

 

說明：

  抽象類，就是用於讓子類繼承的。

  要求子類必需要實現某些方法，【定義的些規範】

 

 

限制：

   Abstract關鍵字：不能修飾成員變量。只能修飾成員方法與類。

   Abstract不能與private共同使用。不能與static共同使用。不能與final共同 。

 

小結：

  抽象類就是被abstact修飾的類。此類不能被實例化。

  被abstract修飾的方法，就抽象方法，不能有方法體系，必需要在抽象類裏面。

6：接口

接口是被

   Interface聲明的類。

interface IOne{

   

}

 

2：也不能被實例化。

   New Ione();錯誤的。

 

3：接口中的全部方法，默認都是：

     Public abstract的

 

interface IOne{

    public abstract void say();

}

 

4:裏面的全部成員變量默認都是

   Public static final的 – 靜態常量 ，必需要聲明時或在static代碼塊中設置值

interface IOne{

    public static final int AGE=34;

    void say();

}

 

5：在接口中不能有任何的實現

即

{

   …能夠被執行的代碼

}

 

6：接口位於類層次的最上層

用於讓子實現實現

interface IOne{

    public static final int AGE=34;

    void say();

    void hi();

}

//一個類實現一個接口，也能夠實現多個接口

class One1 implements IOne{

    public void say() {

    }

    public void hi() {

    }

}

 

7：一個具體類能夠實現多個接口

 interface IOne{

    public static final int AGE=34;

    void say();

    void hi();

}

interface ITwo{

    public void run();

}

//class SomeClass extends 親爹 implements 叔叔1，姑姑,....

//一個類實現一個接口，也能夠實現多個接口

class One1 implements IOne,ITwo{

    public void say() {

    }

    public void hi() {

    }

    @Override

    public void run() {

    }

}

   8：接口不能有構造 – 由於不能有任意的實例體因此不能有構造