class teacher{             //聲明一個teacher類為父類
    String name;             //定義父類的成員變量name、age   
    int age;
    void show(){           //定義父類成員方法，將成員變量輸出
        System.out.println(name);       
        System.out.println(age); 
    }
}
class Student extends teacher {     //聲明一個Student類為子類并繼承父類
}
public class myfirst {
    public static void main(String[] args) {
    System.out.println("學生");
    Student student=new Student();     //聲明一個Student類的實例對象student
    student.name="Tom";                //子類調(diào)用父類的成員變量name并賦值
    student.age=19;                    //子類調(diào)用父類的成員變量age并賦值
    student.show();                    //子類調(diào)用父類的成員方法show
    }
}

運行結果為：

學生
Tom
19

注意：

子類不能選擇性繼承父類；
Java不支持多重繼承，但一個類可以實現(xiàn)多個接口，從而克服單繼承的缺點；
構造方法不會被子類繼承，但可以從子類中調(diào)用父類的構造方法。

繼承的優(yōu)點

繼承過來的字段和方法，可以像任何其他字段和方法一樣被直接使用；
在子類中可以聲明一個與父類中同名的新字段或靜態(tài)方法，從而“隱藏”父類中的字段或方法；
可以在子類中聲明一個在父類中沒有的新字段和方法；
可以在子類中編寫一個父類當中具有相同名的新實例方法，這稱為“方法重寫”或“方法覆蓋”；
可以在子類中編寫一個調(diào)用父類構造方法的子類構造方法，既可以隱式地實現(xiàn)，也可以通過使用關鍵字super來實現(xiàn)。

重寫和隱藏父類方法

子類繼承了父類中的所有成員及方法，但在某種情況下，子類中該方法所表示的行為與其父類中該方法所表示的行為不完全相同，例如，在父類語言中定義了說話這個方法，而在子類中說話的方法是不同的：外國人說英文，中國人說中文，這時我們就需要重寫或隱藏父類的該方法。

重寫父類中的方法

當一個子類中一個實例方法具有與其父類中的一個實例方法相同的簽名（指名稱、參數(shù)個數(shù)和類型）和返回值時，稱子類中的方法“重寫”了父類的方法。例如：

class A{
    public void sayHello() {                      //輸出英文歡迎
        System.out.println("Hello,Welcome to Java!!!");
    }
    public void sayBye() {
        System.out.println("GoodBye,everyone");
    }
}
class B extends A {           
    public void sayHello() {                      //輸出中文歡迎  
        System.out.println("大家好，歡迎學習Java?。?！");
    }
}
public class myfirst {
    public static void main(String[] args) {
    B b=new B();                                //創(chuàng)建子類B的一個實例對象，使用默認構造方法
    b.sayHello();                               //調(diào)用子類中重寫的方法
    b.sayBye();                                 //調(diào)用父類中的方法
    }
}

運行結果為：

大家好，歡迎學習Java?。?！
GoodBye,everyone

注意：重寫的方法具有與其所重寫的方法相同的名稱、參數(shù)數(shù)量、類型和返回值。

隱藏父類中的方法

如果一個子類定義了一個靜態(tài)類方法，而這個類方法與其父類的一個類方法具有相同的簽名（指名稱、參數(shù)格式和類型）和返回值，則稱在子類中的這個類方法“隱藏”了父類中的該類方法。

當調(diào)用被重寫的方法時，調(diào)用的版本是子類的方法；
當調(diào)用被隱藏的方法時，調(diào)用的版本取決于是從父類中調(diào)用還是從子類中調(diào)用。

class A{
    public static void sayHello() {             //靜態(tài)類方法
        System.out.println("大家好，這是A的靜態(tài)類方法");
    }
    public void sayHello2() {                   //實例方法
        System.out.println("大家好，這是A中的實例方法");
    }
}
class B extends A {    
    public static void sayHello() {             //靜態(tài)類方法
        System.out.println("大家好，這是B的靜態(tài)類方法");
    }
    public void sayHello2() {                   //實例方法
        System.out.println("大家好，這是B的實例方法");
    }
}
public class myfirst {
    public static void main(String[] args) {
        B b=new B();                           //創(chuàng)建B類的實例對象b
        A a=b;                                 //隱式對象類型轉換
        A.sayHello();                          //調(diào)用A類的靜態(tài)類方法
        a.sayHello();                          //調(diào)用a對象的靜態(tài)類方法
        B.sayHello();                          //調(diào)用B類的靜態(tài)方法
        a.sayHello2();                         //調(diào)用a對象的實例方法
        b.sayHello2();                         //調(diào)用b對象的的實例方法
        A a2=new A();                          //創(chuàng)建A類的實例對象a2
        a2.sayHello2();                        //調(diào)用a2對象的實現(xiàn)方法
    }
}

運行結果為：

大家好，這是A的靜態(tài)類方法
大家好，這是A的靜態(tài)類方法
大家好，這是B的靜態(tài)類方法
大家好，這是B的實例方法
大家好，這是B的實例方法
大家好，這是A中的實例方法

可以看出，得到調(diào)用的隱藏方法是父類中的方法，而得到調(diào)用的重寫方法是子類中的方法。

方法重寫和隱藏后的修飾符

在子類中被重寫的方法，其訪問權限允許大于但不允許小于被其重寫的方法，例如：父類中一個受保護的實例方法(protected)在子類中可以是公共的(public)的，但不可以是私有的(private)。如果一個方法在父類中是static方法，那么在子類也必須是static方法；如果一個方法在父類中是實例方法，那么在子類中也必須是實例方法。

子類訪問父類私有成員

子類繼承其父類的所有public和protected成員，但不能繼承其父類的private成員。那么如何在子類中訪問到父類中的字段呢，我們可以在父類中提供用來訪問其私有字段的public或protected方法，子類使用這些方法來訪問相應的字段。例如：

class A{                     //父類A
    private int value=10;    //聲明一個私有變量value并賦值為10
    public int getvalue() {  //聲明一個公有成員方法getvalue，返回value
        return value;
    }
}
class B extends A{           //A的子類B
}
public class myfirst {    
    public static void main(String[] args) {
      B b=new B();           //創(chuàng)建子類B的一個實例對象
      System.out.println("子類通過父類提供的公共接口訪問A中的私有字段value:"+b.getvalue());
    }
}

運行結果為：

子類通過父類提供的公共接口訪問A中的私有字段value:10

使用super關鍵字

使用super調(diào)用父類中重寫的方法、訪問父類中被隱藏的字段
子類重寫了父類中的某一個方法，隱藏父類中的字段，假如想在子類中訪問到父類中被重寫的方法和隱藏父類的字段，可以在子類中通過使用關鍵字super來調(diào)用父類中被重寫的方法和訪問父類中被隱藏的字段。例如：

package first;
class A{
    public String name="張飛";         //添加成員變量
    public void say() {                //添加成員方法say
        System.out.println("我是父類A成員方法say");
    }
}
class B extends A{
    public String name="關羽";         //與父類中同名的字段，隱藏父類
    public void say(){                 //重寫方法say
        super.say();                   //使用super關鍵字調(diào)用父類中的方法
        System.out.println("我是子類B成員方法say");
        System.out.println("父類的name名字："+super.name); //使用super關鍵字訪問父類中的變量
    }
}
public class myfirst {
    public static void main(String[] args) {
      B b=new B();                     //創(chuàng)建子類的一個實例對象
      b.say();                         //調(diào)用子類中重寫的方法
      System.out.println("子類的name名字："+b.name);   //調(diào)用子類中的name
    }
}

運行結果為：

我是父類A成員方法say
我是子類B成員方法say
父類的name名字：張飛
子類的name名字：關羽

使用super調(diào)用父類的無參數(shù)構造方法/有參數(shù)構造方法

子類不繼承其父類的構造方法。

當使用無參數(shù)的super()時，父類的無參數(shù)構造方法就會被調(diào)用；
當使用帶有參數(shù)的super()方法時，父類的有參數(shù)構造方法就會被調(diào)用。

例如：

class SuperClass {              //創(chuàng)建父類SuperClass
      private int n;            //聲明一個私有變量n
      SuperClass(){             //父類無參數(shù)構造方法
        System.out.println("這是父類SuperClass無參數(shù)構造方法");
      }
      SuperClass(int n) {       //父類有參數(shù)構造方法
        System.out.println("這是父類SuperClass有參數(shù)構造方法");
        this.n = n;
      }
    }
    class SubClass extends SuperClass{     // SubClass類繼承SuperClass類
      private int n;                       //聲明一個私有變量n
      SubClass(){                          // 自動調(diào)用父類的無參數(shù)構造器
        System.out.println("這是子類無參數(shù)構造方法");
      }  
      
      public SubClass(int n){              //子類有參數(shù)構造方法
        super(300);                        //調(diào)用父類中帶有參數(shù)的構造器
        System.out.println("這是子類有參數(shù)構造方法"+n);
        this.n = n;
      }
    }
public class myfirst {
    public static void main(String[] args) {
            SubClass sc1 = new SubClass();      //創(chuàng)建子類SubClass實例對象，調(diào)用其無參數(shù)構造方法
            SubClass sc2 = new SubClass(100);   //創(chuàng)建子類SubClass實例對象，調(diào)用其有參數(shù)構造方法
    }
}

運行結果為：

這是父類SuperClass無參數(shù)構造方法
這是子類無參數(shù)構造方法
這是父類SuperClass有參數(shù)構造方法
這是子類有參數(shù)構造方法100

注意

如果要初始化父類中的字段，可以在子類的構造方法中通過關鍵字super調(diào)用父類的構造方法；
對父類的構造放的調(diào)用必須放在子類構造方法的第一行；
如果父類構造器沒有參數(shù)，則在子類的構造器中不需要使用 super 關鍵字調(diào)用父類構造器，系統(tǒng)會自動調(diào)用父類的無參構造器；
如果父類的構造器帶有參數(shù)，則必須在子類的構造器中顯式地通過 super 關鍵字調(diào)用父類的構造器并配以適當?shù)膮?shù)列表；
子類是不繼承父類的構造器（構造方法或者構造函數(shù)）的，它只是調(diào)用（隱式或顯式）。