java對象繼承

㈠ java中繼承的好處是什麼,在組合和繼承中該如何取捨

1，繼承提高了代碼的重復利用性；

2，繼承是面向對象的，一類事物可以獨立存在，解藕了類與類之間的斗聯系。
3，繼承更利於程序的設計。
5，在組合中，一定要把同一類事物放在一起，和現實生活中一樣，每一類事物都是有自己的共性和自己的特性，按毛主席的矛盾論說是：矛盾的普遍性與特殊性，普遍性就是繼承來的。
6，在寫代碼之前，分析和設計是關鍵的一步，這一步解決的就是哪些類是同類的，哪些東西是公共的。

㈡ java中為什麼要使用繼承

繼承： 1，提高了代碼的復用性。 2，類與類之間產生了關系，關系的出現，就是多態的由來。
java只支持單繼承，不支持不多繼承。 原因：當出現多個類中有相同方法時，子類不確定調用的是哪一個。 其實就是父類中的方法有方法體。 但是java支持多層繼承。在多層繼承中，父類定義都是共性成員。 所體現的內容： 1，父類是不斷向上抽取而來的。 2，既然父類體現的共性內容，那麼在使用一個繼承體系時， 只需要查閱最頂層父類即可了解該體系的基本功能。(查閱API技巧之一) 3，只要建立最子類的對象即可對該繼承體系進行應用。
子父類的出現，子類因為持有一個父類引用super，可以獲取到父類中非私有的成員。 如同子類中也有一個份一樣。
覆蓋（復寫）override. 對於成員函數，當子父類中出現了一模一樣的函數時，會出現一個覆蓋操作。 在運行時，會運行子類中的方法。 覆蓋注意： 1，子類覆蓋父類方法，必須許可權大於等於父類。 2，靜態覆蓋靜態。 3，覆蓋只發生在函數上。
什麼時候使用覆蓋呢？ 可以通過覆蓋的形式對父類的功能進行重新定義。 比如：對功能進行修改或者對功能進行升級。 注意：不要在子類中定義新功能。還要以父類中的聲明為主。
class Demo {
void show() {
System.out.println("Demo show");
}
}
main()
{ //Demo d = new Demo();
SubDemo d = new SubDemo();
d.show();
}
二年後。 為了提高可維護性。 建立一個子類繼承Demo，復寫其中的某些需要修改的功能即可。
class SubDemo extends Demo {
void show() {
System.out.println("subdemo show");
}
}
super關鍵字:代表的父類應用。super的應用和this的使用完全一樣。
子類的實例化過程： 子類中所有的構造函數回去訪問父類中的空參數構造函數。 那是因為：每一個子類構造函數中的第一行都有一個句隱式super()語句。 原理：子類繼承父類，獲取獲取到了父類中的成員，所以子類必須要先明確父類是如何對這些成員進行初始化的。
如何父類中沒有了空參數構造函數，需要在子類的構造函數通過super,或者this語句指定要訪問的構造函數。
什麼時候使用繼承呢？ 當類與類之間出現所屬(is a)關系時，就使用繼承。 類中的所有成員是否可以被另一個類所以擁有. 如果是繼承. 如果不是,看是否具備向上抽取的可能. class A {
void method(){}
void function(){}
}
有了一個B類，B中也需要一個method()方法。 這時，是否可以用B繼承A來獲取這個方法呢？因為這樣不是可以提高復用性嗎？
那麼判斷，B和A之間有所屬關系嗎？不會判斷。 這時，可以通過另一個方式，B是否應用具備A中所有功能？ 不是。B只需一個method()方法即可。不需要function()。這樣就不需要繼承。 但是B中就會重復定義method()方法。 那麼A和B出現了共性的內容，就具備了向上抽取的內容。這時A和B就又出現一個父類C。
class B {
void method(){}
void show(){}
}
所以最終設計： class C {
void method(){}
}
class A extends C {
void function(){}
}
class B extends C {
void show(){}
}
----------------------------------------------
final 關鍵字 1，final可以修飾類，方法，變數。 2，final修飾類不可以被繼承，但是可以繼承其他類。 3，final修飾的方法不可以被覆蓋，但可以覆蓋父類方法。 4，final修飾的變數包括成員變數，類變數，局部變數，這些變數只能賦值一次。 5，內部類在局部時，只可以訪問被final修飾的局部變數。 通常規范中，被final修飾的變數是一個常量，常量名稱所有字母大寫。
-----------------------------------------------
抽象類： 分析事物時，發現了共性內容，就出現向上抽取。 會有這樣一種特殊情況，就是功能聲明相同，但功能主體不同。 那麼這時也可以抽取，但只抽取方法聲明，不抽取方法主體。 那麼該方法就是一個抽象方法。 抽象方法的表現形式：abstract 返回值類型 函數名稱(參數列表); 抽象方法一定要存放在抽象類中。
特點： 抽象類不能用new進行實例化。 想要創建對象，必須通過子類復寫父類中所有的抽象方法後，該子類才可以創建對象。
抽象類定義時，和一般類一樣，都是在描述事物，只不過抽象類可以存放抽象方法，不可以建立對象。
抽象方法的出現可以強迫子類去做某些事。
例：學員類的例子。 學員類的出現其實分析了現實生活中的學生而來的。 張三：躺著睡覺，學習(總結式) 李四：躺著睡覺，學習(機械式)
abstract class 學員 {
void 睡覺(){
躺著睡覺;
}
abstract void 學習();
}
-------------------------------------------- 介面： 簡單的理解成抽象類的特殊表現形式，當抽象類的方法全都是抽象的，那麼這時就用介面來表示。
特點： -- 介面是對外暴露的規則。 -- 介面是功能的擴展。 -- 介面的出現降低了耦合性。 -- 在java中，多繼承的機制被java通過另一種形式來體現，就是多現實。 -- 在java中，一類可以繼承一個類的同時，實現多個介面。 例子：主板的pci介面。插座。筆記本電腦的usb介面。
interface 抽煙 {
抽煙方法；
}
class 張三 extends 學員 implements 抽煙 {
void 睡覺(){
躺著睡覺;
}
void 學習(){}
抽煙方法{}
}
介面中通常的定義的內容： 1，全局常量。public static final 2，公有的抽象方法。 public abstract
類與類之間是繼承關系。
類與介面之間是實現關系。
介面與介面之間是繼承關系，而且，介面之間存在多繼承

㈢ java繼承和創建對象的區別

繼承，是子類繼承父類。針對LZ的提問，如果你繼承的話，那麼相當於又寫一個類，干有這個類還是不能調用方法啊。那不還得用子類...

㈣ java中的繼承是什麼

Java繼承是面向對象的最顯著的一個特徵。繼承是從已有的類中派生出新的類，新的類能吸收已有類的數據屬性和行為，並能擴展新的能力。[1]
Java繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。這種技術使得復用以前的代碼非常容易，能夠大大縮短開發周期，降低開發費用。比如可以分隔符先定義一個類叫車，車有以下屬性：車體大小，顏色，方向盤，輪胎，而又由車這個類派生出轎車和卡車兩個類，為轎車添加一個小後備箱，而為卡車添加一個大貨箱。
類和類之間的繼承關系可以用UML符號表示，其中父類又叫超類或基類，子類又叫派生類。父類是子類的一般化，子類是父類的特化（具體化)。
JAVA不支持多繼承，單繼承使JAVA的繼承關系很簡單，一個類只能有一個父類，易於管理程序，同時一個類可以實現多個介面，從而克服單繼承的缺點。
在面向對象程序設計中運用繼承原則，就是在每個由一般類和特殊類形成的一般——特殊結構中，把一般類的對象實例和所有特殊類的對象實例都共同具有的屬性和操作一次性地在一般類中進行顯式的定義，在特殊類中不再重復地定義一般類中已經定義的東西，但是在語義上，特殊類卻自動地、隱含地擁有它的一般類(以及所有更上層的一般類)中定義的屬性和操作。特殊類的對象擁有其一般類的全部或部分屬性與方法，稱作特殊類對一般類的繼承。
繼承所表達的就是一種對象類之間的相交關系，它使得某類對象可以繼承另外一類對象的數據成員和成員方法。若類B繼承類A，則屬於B的對象便具有類A的全部或部分性質(數據屬性)和功能(操作)，我們稱被繼承的類A為基類、父類或超類，而稱繼承類B為A的派生類或子類。
繼承避免了對一般類和特殊類之間共同特徵進行的重復描述。同時，通過繼承可以清晰地表達每一項共同特徵所適應的概念范圍——在一般類中定義的屬性和操作適應於這個類本身以及它以下的每一層特殊類的全部對象。運用繼承原則使得系統模型比較簡練也比較清晰。

㈤ java繼承調用

1、首先創建一個父類

//A.java
publicclassA{
privateinti;
protectedintj;

publicvoidfunc(){

}
}

2、子類則可以使用父類的方法

//B.java
publicclassBextendsA{

}

詳情JDK8教程可參考java基礎技術網站52diandi.com

㈥ java面向對象關於繼承的問題

Base base=new Child();
這個分為兩部分。。Base base這是定義。。base=new Child();這是賦值。。
因為你把base定義為 Base類型。。所以編譯器把他當做Base類型。。至於實際類型。。運行的時候才能確定。。所以不能訪問Child的屬性和方法。。

Child child=new Child();
Base child=new Child();
這個的不同應該明白了撒。。就是你寫代碼的時候。。編譯器把他們看成的類型是不一樣的。。

㈦ 使用java繼承機制編程有什麼好處談談你的實踐體會

更安全。
繼承簡化了人們對事物的認識和描述，能清晰體現相關類間的層次結構關系。繼承提供了軟體復用功能。這種做法能減小代碼和數據的冗餘度，大大增加程序的重用性。提供多重繼承機制。出於安全性和可靠性的考慮，僅支持單重繼承，而通過使用介面機制來實現多重繼承。
Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。

㈧ JAVA繼承實例

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

繼承一個類，只要用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 域是不可能的，因為它沒有定義。