繼承壹個類，只要用extends 關鍵字把壹個類的定義合並到另壹個中就可以了。為了理解怎樣繼承，讓我們從簡短的程序開始。下面的例子創建了壹個超類A和壹個名為B的子類。註意怎樣用關鍵字extends 來創建A的壹個子類。
// A simple example of inheritance.
// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}
該程序的輸出如下：
Contents of superOb:
i and j: 10 20
Contents of subOb:
i and j: 7 8
k: 9
Sum of i, j and k in subOb:
i+j+k: 24
像妳所看到的，子類B包括它的超類A中的所有成員。這是為什麽subOb 可以獲取i和j 以及調用showij( ) 方法的原因。同樣，sum( ) 內部，i和j可以被直接引用，就像它們是B的壹部分。
盡管A是B的超類，它也是壹個完全獨立的類。作為壹個子類的超類並不意味著超類不能被自己使用。而且，壹個子類可以是另壹個類的超類。聲明壹個繼承超類的類的通常形式如下：
class subclass-name extends superclass-name {
// body of class
}
妳只能給妳所創建的每個子類定義壹個超類。Java 不支持多超類的繼承（這與C++ 不同，在C++中，妳可以繼承多個基礎類）。妳可以按照規定創建壹個繼承的層次。該層次中，壹個子類成為另壹個子類的超類。然而，沒有類可以成為它自己的超類。
成員的訪問和繼承
盡管子類包括超類的所有成員，它不能訪問超類中被聲明成private 的成員。例如，考慮下面簡單的類層次結構：
/* In a class hierarchy, private members remain private to their class.
This program contains an error and will not compile.
*/
// Create a superclass.
class A {
int i;
private int j; // private to A
void setij(int x, int y) {
i = x; j = y;
}
}
// A"s j is not accessible here.
class B extends A {
int total; void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
public static void main(String args[]) {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}
該程序不會編譯，因為B中sum( ) 方法內部對j的引用是不合法的。既然j被聲明成private，它只能被它自己類中的其他成員訪問。子類沒權訪問它。
註意：壹個被定義成private 的類成員為此類私有，它不能被該類外的所有代碼訪問，包括子類。
更實際的例子
讓我們看壹個更實際的例子，該例子有助於闡述繼承的作用。新的類將包含壹個盒子的寬度、高度、深度。
// This program uses inheritance to extend Box.
class Box {
double width; double height; double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume double
volume() {
return width * height * depth;
}
}
BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
double vol;
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox1 is " + mybox1.weight);
System.out.println();
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
System.out.println("Weight of mybox2 is " + mybox2.weight);
}
}
該程序的輸出顯示如下：
Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3
Volume of mybox2 is 24.0
Weight of mybox2 is 0.076
BoxWeight 繼承了Box 的所有特征並為自己增添了壹個weight 成員。沒有必要讓BoxWeight 重新創建Box 中的所有特征。為滿足需要我們只要擴展Box就可以了。
繼承的壹個主要優勢在於壹旦妳已經創建了壹個超類，而該超類定義了適用於壹組對象的屬性，它可用來創建任何數量的說明更多細節的子類。每壹個子類能夠正好制作它自己的分類。例如，下面的類繼承了Box並增加了壹個顏色屬性：
// Here, Box is extended to include color.
class ColorBox extends Box {
int color; // color of box
ColorBox(double w, double h, double d, int c) {
width = w;
height = h;
depth = d;
color = c;
}
}
記住，壹旦妳已經創建了壹個定義了對象壹般屬性的超類，該超類可以被繼承以生成特殊用途的類。每壹個子類只增添它自己獨特的屬性。這是繼承的本質。
超類變量可以引用子類對象
超類的壹個引用變量可以被任何從該超類派生的子類的引用賦值。妳將發現繼承的這個方面在很多條件下是很有用的。例如，考慮下面的程序：
class RefDemo {
public static void main(String args[]) {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box(); double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
System.out.println();
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox does not define a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}
這裏，weightbox 是BoxWeight 對象的壹個引用，plainbox 是Box對象的壹個引用。既然BoxWeight 是Box的壹個子類，允許用壹個weightbox 對象的引用給plainbox 賦值。
當壹個子類對象的引用被賦給壹個超類引用變量時，妳只能訪問超類定義的對象的那壹部分。這是為什麽plainbox 不能訪問weight 的原因，甚至是它引用了壹個BoxWeight 對象也不行。仔細想壹想，這是有道理的，因為超類不知道子類增加的屬性。這就是本程序中的最後壹行被註釋掉的原因。Box的引用訪問weight 域是不可能的，因為它沒有定義。