JAVA:編寫一個動物的繼承關系代碼.

下面是一個簡單的 Java 程序示例，用于實現(xiàn)山羊和狼的繼承關系，并在測試類中進行驗證：

創(chuàng)新互聯(lián)專注于鄉(xiāng)寧企業(yè)網(wǎng)站建設,響應式網(wǎng)站建設,商城網(wǎng)站制作。鄉(xiāng)寧網(wǎng)站建設公司,為鄉(xiāng)寧等地區(qū)提供建站服務。全流程按需制作，專業(yè)設計，全程項目跟蹤，創(chuàng)新互聯(lián)專業(yè)和態(tài)度為您提供的服務

Animal.java:

```java

public abstract class Animal {

public void walk() {

System.out.println("走路");

}

public abstract void eat();

}

```

Goat.java:

```java

public class Goat extends Animal {

@Override

public void eat() {

System.out.println("吃草");

}

}

```

Wolf.java:

```java

public class Wolf extends Animal {

@Override

public void eat() {

System.out.println("吃肉");

}

}

```

AnimalTest.java:

```java

public class AnimalTest {

public static void main(String[] args) {

Goat goat = new Goat();

wolf wolf = new wolf();

goat.eat(); // 輸出：吃草

wolf.eat(); // 輸出：吃肉

goat.walk(); // 輸出：走路

wolf.walk(); // 輸出：走路

}

}

```

在此程序中，我們定義了一個 `Animal` 類作為基類，包含了所有動物都會有的行為（例如走路），并使用抽象方法 `eat()` 表示不同動物的飲食習慣。然后通過繼承實現(xiàn) `Goat` 和 `Wolf` 兩個子類，并分別重寫 `eat()` 方法。

在測試類中，我們分別創(chuàng)建了一個 `Goat` 和一個 `Wolf` 對象，并分別調用其 `eat()` 和 `walk()` 方法進行驗證?？梢钥吹?，不同的動物具備不同的飲食習慣，但它們的走路行為是一致的。

JAVA繼承問題 求代碼

第一個:

public?class?Yaojing?{

protected?String?name;

protected?int?age;

protected?String?gender;

public?void?showBasicInfo()?{

System.out.println(toString());

}

public?void?eatTangSeng()?{

System.out.println("吃飽了");

}

@Override

public?String?toString()?{

return?"Yaojing?[name="?+?name?+?",?age="?+?age?+?",?gender="?+?gender?+?"]";

}

}

第二個類

public?class?Zhizhujing?extends?Yaojing?{

public?void?buildNet(){

System.out.println("蜘蛛在織網(wǎng)");

}

}

第三個類

public?class?Baigujing?extends?Yaojing?{

public?void?beBeauty(){

System.out.println("白骨精");

}

}

JAVA繼承實例

繼承是面向對象編程技術的一塊基石，因為它允許創(chuàng)建分等級層次的類。運用繼承，你能夠創(chuàng)建一個通用類，它定義了一系列相關項目的一般特性。該類可以被更具體的類繼承，每個具體的類都增加一些自己特有的東西。在Java 術語學中，被繼承的類叫超類（superclass ），繼承超類的類叫子類（subclass ）。因此，子類是超類的一個專門用途的版本，它繼承了超類定義的所有實例變量和方法，并且為它自己增添了獨特的元素。

繼承一個類，只要用extends 關鍵字把一個類的定義合并到另一個中就可以了。為了理解怎樣繼承，讓我們從簡短的程序開始。下面的例子創(chuàng)建了一個超類A和一個名為B的子類。注意怎樣用關鍵字extends 來創(chuàng)建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

}

你只能給你所創(chuàng)建的每個子類定義一個超類。Java 不支持多超類的繼承（這與C++ 不同，在C++中，你可以繼承多個基礎類）。你可以按照規(guī)定創(chuàng)建一個繼承的層次。該層次中，一個子類成為另一個子類的超類。然而，沒有類可以成為它自己的超類。

成員的訪問和繼承

盡管子類包括超類的所有成員，它不能訪問超類中被聲明成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 重新創(chuàng)建Box 中的所有特征。為滿足需要我們只要擴展Box就可以了。

繼承的一個主要優(yōu)勢在于一旦你已經(jīng)創(chuàng)建了一個超類，而該超類定義了適用于一組對象的屬性，它可用來創(chuàng)建任何數(shù)量的說明更多細節(jié)的子類。每一個子類能夠正好制作它自己的分類。例如，下面的類繼承了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;

}

}

記住，一旦你已經(jīng)創(chuàng)建了一個定義了對象一般屬性的超類，該超類可以被繼承以生成特殊用途的類。每一個子類只增添它自己獨特的屬性。這是繼承的本質。

超類變量可以引用子類對象

超類的一個引用變量可以被任何從該超類派生的子類的引用賦值。你將發(fā)現(xiàn)繼承的這個方面在很多條件下是很有用的。例如，考慮下面的程序：

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 域是不可能的，因為它沒有定義。

文章標題：java類的繼承代碼舉例 java中的繼承怎么寫
當前鏈接：http://jinyejixie.com/article34/dopscpe.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供小程序開發(fā)、網(wǎng)站制作、網(wǎng)站營銷、ChatGPT、標簽優(yōu)化、電子商務

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)