java 繼承的基本實現

繼承的基本實作類別的繼承格式

在java中使用extends關鍵字完成類的繼承關係，操作格式如下：

class 父類{}
class 子類 extends 父類{}

繼承父類的功能，擴充子類的所有功能。

class Person{    private String name;    private int age;    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }}class student extends Person{    //此處不添加任何代碼}public class ExtDemo02{    public static void main(String args[]){    Student stu = new Student();    stu.setName("張三");    set.setAge(30);    System.out.println(stu.getName()+stu.getAge());    }}

子類有時候也稱之為衍生類別。

繼承的進一步研究

子類對象的執行個體化過程

執行個體化子類對象：
1.先調用父類的構造->調用父類構造
2.再調用子類構造->調用子類構造

執行個體：

InstanceDemo.java

class Person{    private String name;    private int age;    public Person(){    System.out.println("父類Person中的構造方法");    }    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }}class Student extends Person{    private String school;    public Student(){    System.out.println("子類student中構造");    }}public class InstanceDemo{    public static void main(String args[]){    Student stu = new Student();        }}

//輸出：父類Person中的構造
    子類Student中的構造

實際上此時隱含在Student的構造方法的第一行有以下代碼：
    super();    //調用父類的建構函式
即代碼相當於：

class Person{    private String name;    private int age;    public Person(){    System.out.println("父類Person中的構造方法");    }    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }}class Student extends Person{    private String school;    public Student(){    super();    System.out.println("子類student中構造");    }}public class InstanceDemo{    public static void main(String args[]){    Student stu = new Student();        }}

注意點：在方法覆寫時必須考慮到許可權問題,即：被子類覆寫的方法不能擁有比父類方法更加嚴格的存取權限。
存取權限一共有四種，現在只講三種：
●private:只能被類內訪問，許可權最第
●default:相當於什麼都不聲明
●public:最大的存取權限
●大小關係：private<default<public

如果降低了存取權限時如Person使用public而Student使用default時，會產生以下錯誤：
print() in Student cannot override print() in Person; attempting to assign weaker access privileges; was public void print()
//表示錯誤的，降低了許可權

子類會自動調用覆寫的方法，但此時如果非要調用父類中的方法的話，使用super()關鍵字。
如:Student構造方法調用父類的方法可以進行以下修改：

class Person{    private String name;    private int age;    public Person(){    System.out.println("父類Person中的構造方法");    }    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }    public void print(){    System.out.println("just a moment!");    }}class Student extends Person{    private String school;    public Student(){    super.print();    System.out.println("子類student中構造");    }}public class InstanceDemo{    public static void main(String args[]){    Student stu = new Student();        }}

---------------------------------------------------------
問題：如果現在在父類中使用private 關鍵字聲明了一個方法，那麼在子類中使用default許可權算是覆寫嗎？
答  ：不是覆寫.
------------------------------------------------------

class Person{    private String name;    private int age;    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }    private void print(){    System.out.println("Person------>void print()");    }}class Student extends Person{    private String school;    void print(){    System.out.println("Student-------->void print()");    }}public class InstanceDemo{    public static void main(String args[]){    Student stu = new Student();    stu.print();    }}

輸出：Student---------->void print()

此時，方法沒有被覆寫，而是相當於在子類中又重新定義了一個新的方法出來。

3.3 屬性的覆寫

在子類中聲明了父類同名的屬性。

class Person{    public String name;    private int age;    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }    private void print(){    System.out.println("Person------>void print()");    }}class Student extends Person{    public String name;    void print(){    System.out.println("父類中的屬性："+super.info);    System.out.println("子類中的屬性："+this.info);    }}public class OverrideDemo{    public static void main(String args[]){    Student stu = new Student();    stu.print();    }}

3.4方法的覆寫與的方法的重載

overloading                    overrideing
方法名稱相同參數的類型或個數不同        方法名稱參數的類型傳回值類型全部相同
對許可權沒有要求                    被覆寫的方法不能擁有更嚴格的許可權
發生在一個類中                    發生在繼承類中

3.5    super關鍵字
表示從子類調用父類中的指定操作，例如調用屬性，方法，構造等。因為在子類執行個體化的時候會預設調用父類中的無參構造，如果現在希望調用有參構造方法，可以使用super方法傳遞參數。

class Person{    private String name;    private int age;    public Person(String name,int age){        this.name = name;        this.age = age;        System.out.println("父雷Person中的構造方法");    }    public void setName(String name){    this.name = name;        }    public void setInt(int age){    this.age = age;        }    public String getName(){    return this.name;        }    public int getAge(){    return this.age;    }  }class Student extends Person{    private String school;    public Student(String name,int age,String school){        super(name,age);        this.school = school;        System.out.println("子類student中的構造方法");    }}public class OverrideDemo{    public static void main(String args[]){    Student stu = new Student("張三",30,"山東大學");    }}

當子類調用無參構造方法時，父雷中不存在無參構造方法，此時就會報錯。因為子類會在無參構造方法第一行隱含調用super方法，解決方案為：父類定義一個無參構造方法，或使用super調用父類存在參數的方法。

不管任何時候，子類執行個體化時候先去調用父類中的構造方法，預設調用無參構造。

總結：
使用 super 調用無參方法
1.建立含無參構造的類。
2.建立含無參構造子類，繼承父類。
3.子類中構造第一行添加或不添加super

使用 super 調用含參數的方法
1.建立含參構造的類。
2.建立含參子類（覆寫建構函式），繼承父類。
3.子類中構造第一行添加super(內部參數同父類構造方法)

this與super的區別

this                                    super
屬性訪問：訪問本類中的屬性，如果本類沒有這些屬性則從父類中尋找。    屬性訪問：訪問父類中的屬性
方法：訪問本類中的方法，如果本類沒有則從父類中尋找。            方法：直接存取父類中的方法
調用構造：調用本類構造，必須放在構造方法首行。                調用構造：調用父類構造，必須放在子類構造方法的首行。
特殊：表示當前對象。                            特殊：無此概念

對於this和super本身都可以調用構造方法，而且調用的時候都必須放在構造方法首行，所以兩個關鍵字不能同時出現。

疑問：如果在構造方法中（子類）使用了this，那麼是不是就不調用父類中的構造方法？

  答：子類中不可能同時都調用this()方法，所以預設仍會調用父類的構造方法。