繼承注意實現所有的抽象州跡類 私有或靜態成員 構造函數 不能繼承 繼承實現或重寫父類方法不能 縮小父類空李訪問符 沖寫方法注意參數 函數 返回值不能錯 等等 還有其他注冊虧並意的地方 得自己練習
❷ java 繼承,重寫,重載
我來為樓主解答一下：
【繼承】
【內容闡述】
繼承是使用extends關鍵字使用繼承關系，繼承有兩點好握返處，一是促進代碼的重用，二是使用多態性訪問，繼承關系的判斷
可以使用instanceof運算符來測試，樓主繼承中知道以上就可以了。
【測試1】
Given:
1.
class
Plant{
2.
String
getName(){return
"plant";}
3.
Plant
getType(){return
this;}
4.
}
5.
class
Flower
extends
Plant{
6.
//insert
code
here
7.
}
8.
class
Tulip
extends
Flower{}
在第六行插入以下那段代碼能夠通過編譯，答案不唯一：
A
Flower
getType(){return
this;}
B
String
getType(){return
"ok";}
C
Plant
getType(){return
this;}
D
Tulip
getType(){return
new
Tulip();}//答案在後面
============================================================
【方法的重寫】
【闡述】
子類繼承父類碧塵時，子類就有機會重寫父類提供的方法（final方法除外），重寫要注意：
1、參數表必須和被重寫方法的參數列表完全一致；
2、返回類型段慧飢要和被重寫方法的返回類型或者其子類型一致；
3、訪問級別限制符不能比被重寫的方法強，可以比他弱；
4、重寫方法不能拋出新的檢查異常或者比被重寫方法聲明的檢查異常更廣泛的異常；
5、不能重寫final,static的方法
6、重寫就是正在實現一個繼承的方法
【測試2】
Given:
public
class
Animal{
protected
void
eat(){}
}
以下為Animal的eat()方法的重寫，請指出錯誤的重寫方式並說出理由：
A
private
void
eat(){}
B
public
void
eat()throws
IOException{}
C
public
void
eat(){}
D
public
void
eat(String
str){}
E
public
String
eat(){}
=================================================================
【方法重載】
【闡述】
重載方法允許在類中重新使用相同的方法名稱，但具有不同的參數，注意以下幾點：
1、被重載的方法必須改變參數列表；
2、被重載的方法可以改變返回類型；
3、被重載的方法可以改變訪問修飾符；
4、被重載的方法可以聲明新的或更廣泛的異常；
5；方法能夠在同一個類中或者在子類中被重載；
【測試3】
Given:
1.
class
Programmer{
2.
Programmer
debug(){return
this;}
3.
}
4.
class
MyProgrammer
extends
Programmer{
5.
//insert
code
here
6.
}
以下哪段代碼插入第五行可以通過編譯：
A
Programmer
debug(){return
this;}
B
MyProgrammer
debug(){return
this;}
C
Object
debug(){return
this;}
D
int
debug(){return
1;}
E
int
debug(int
x){return
1;}
F
Object
debug(int
x){return
this;}
===================================================================
【轉型】
【闡述】
轉型的過程是編譯器通過繼承樹來判斷的，向下轉型是轉型至更加具體的類，即把父類強制轉換成子類的類型，那麼這個時
候編譯可以通過，但是運行時會出現一個java.lang.ClassCastException的異常，而向上轉型是將子類類型轉換為父類類型
，這樣一點問題都沒有，就像這么一句話：向下轉型是「車是寶馬」，向上轉型是「寶馬是車」，明顯看出對於錯。
【測試4】
Given:
1.
class
X{void
do1(){}}
2.
class
Y
extends
X{void
do2(){}}
3.
4.
class
Chrome{
5.
public
static
void
main(String[]
args){
6.
X
x1
=
new
X();
7.
X
x2
=
new
Y();
8.
Y
y1
=
new
Y();
9.
//insert
code
here
10.
}
11.
}
以下哪些插入第九行是正確的：
A
x2.do2();
B
(Y)x2.do2();
C
((Y)x2).do2();
D
None;
=============================================================================
【答案】
1、ACD
2、ABDE
3、ABEF
4、C
希望我的回答對樓主有所幫助！
❸ 方法的重載與重寫
1.必須在同一個類中
2.方法名稱必須相同，參數列表必須不同(參數的類型，個數，順序)
3.方法返回值與訪問修飾符任意
4.與方法的參數名稱無關
1.在有繼承關系大握的子類中
2.方法名稱與參數列表(參數類型，個判咐數，順序)必須相同，返回值必須相同（補：也可以時父類中的子類）
3.訪問修飾符，訪問范圍要大於等於父類的訪問范圍
4.與方法的參數名稱無關
重寫掘仿純的概念只適用於方法上面，但是在子類中可定義與父類中重名的屬性
❹ java中 關於方法的覆蓋 重載 重寫
覆蓋又叫重寫，因此重寫和覆蓋是一個概念。它是覆蓋了一個方法並且對其重寫，以求達到不同的作用。形式有：對介面方法的實現，在繼承中也可能會在子類覆蓋父類中的方法。
重載：它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然後再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。
舉例：
publicclassParent{//定一個類
publicvoidread(){
}
publicvoidshow(){//重載了show方法
}
publicvoidshow(inta){//重載了show方法，比第一個方法多了一個參數
}
}
publicclassSonextendsParent{//son類繼承父類parent
publicvoidread(){//覆蓋了父類的read方法。
}
}
❺ 方法的重載和重寫問題
方法重載是讓類以統一的方式處理不同類型數據的一種手段。Java的方法重載，就旅飢是在類中可以創建多個方法，它們具有相同的名字，但具有不同的參數和不同的定義。調用方法弊派時通過傳遞給它們的不同個數和類型的參數來決定具體使用哪個方法。
簡單的說
方法重載就是方法名稱重復，載入參數不同。
一.方法名一定要相同。
二.方法的參數表必須不同，包括參數的類型或個數，以此區分不同的方法體。
1.如果參數個數不同，就不管它的參數類型了！
2.如果參數個數相同，那麼參數的類型或者參數的順序必須不同。
在java中方法的返回類型不做為方法重載的標識：
在java核心技術中：
public String m1 () {
// 邏輯1
return 「1」; // 隨便返回一個值，沒有意義，只是展示
}
public void m1 () {
// 邏拆卜返輯2
return 0; // 隨便返回一個值，沒有意義，只是展示
}
上面2個方法「重載」，只是返回值不同
當執行： m1();
JVM是不知道執行那個方法的，因此返回值不做為重載的標志
方法重寫(overiding method)
在Java中，子類可繼承父類中的方法，而不需要重新編寫相同的方法。但有時子類並不想原封不動地繼承父類的方法，而是想作一定的修改，這就需要採用方法的重寫。方法重寫又稱方法覆蓋。
若子類中的方法與父類中的某一方法具有相同的方法名、返回類型和參數表，則新方法將覆蓋原有的方法。
如需父類中原有的方法，可使用super關鍵字，該關鍵字引用了當前類的父類。
方法重寫的特性
1.發生方法重寫的兩個方法返回值、方法名、參數列表必須完全一致(子類重寫父類的方法)
2.子類拋出的異常下不能超過父類相應方法拋出的異常(子類異常不能大於父類異常)
3.子類方法的訪問級別不能低於父類相應方法的訪問級別(子類訪問級別不能低於父類訪問級別)
根據2，3條是不是能確定第一條，子類方法的返回值必須是父類方法返回值的子類。
❻ extend繼承、override重寫、overload重載總結
多態是面向對象語言的一個重要特性
多態的優點：
1. 消除褲隱類型之間的耦合關系
2. 可替換性
3. 可擴充性
4. 介面性
5. 靈活性
6. 簡化性
多態存在的三個必要條件
繼承
重寫（重寫只針對於成員方法，不能重寫變數和靜態方法）
父類引用指向子類對象（向上轉型，父類引用只能調用父類中定義過的方法（如果子類重寫了，則調用子類的，動態鏈接)和變數)。
1、extend繼承
父類和子類同包，子類可以繼承父類的所有非private修飾類型
父類和子類不同包，子類只可以繼承父類public、protected修飾（不能被其它類訪問）
2、override重寫
有繼承才能有重寫
子類重寫父類方法需要注意：
1、訪問許可權不能比父類更低。
2、粗知父類的方法簽名沒有拋出異常，子類重寫時也不能拋出異常。父類方法簽名有拋出異常，子類重寫不能拋出父類簽名異常的范圍更寬（如父類拋出IOException,子類不能拋出Exception）。
3、方法名、返回值、形參類型個數不能改變。
3、overload重載
方法名相同，形參個岩純消數不同或者類型不同構成方法重載。
注意：訪問許可權不同，返回值不同並不能構成重載。
❼ java語言中的重寫、重載、繼承
重寫重載發生在函數上,繼承發生在類上!
重寫在繼承的基礎之上;
重載與重寫都是函數的特性,
重載只看參數列表,重寫要看函數所有:(許可權,返回值類型,函數名必須一樣,參數類型與個數必須一樣);
我給你通俗點打比方,可能不是很恰當,只希望明白就好!
//先說重載!
class小明
{
/*小明會射擊至於哪種類型的武器代表參數*/
//方法1
塵橘void射擊(int弓)
{
}
//方法2
void射擊(String槍)
{
}
//方法3
void射擊(String槍,int弓)
{
}
/*方法名都一樣,只是參數列表不一樣*/
}
/*----------------------說說繼承!-----------------------------------*/
class小明爹
{
//方法1
void射擊(int弓洞如)
{
}
}
class小明extends小明爹
{
納兄啟//這里什麼都沒定義!
//什麼都沒有的情況下,小明就有他爹的射擊這個方法了!
}
/*--------------------------重寫-----------------------------*/
class小明爹
{
//方法1
void射擊(int弓)
{
蛙泳式;
}
}
class小明extends小明爹
{
//小明覺得他爹的射擊姿勢很不給力,他決定覆蓋他爹的方法,也稱為重寫!
void射擊(int弓)
{
狗刨式;
}
}
//如果實例化小明以後,調用這個射擊的動作就是小明自己的了,明白嗎?
//當然其實也能調用他爹的,這個需要他爹內部對外提供一個方法即可!
//默認實例化完以後,在調用射擊這個方法,就是小明的狗刨式了!
比喻不是很恰當,只希望你能明白!和你一樣,我也是初學者!基礎部分很關鍵!
❽ 求JAVA代碼和對繼承、方法的重載和重寫的理解
繼承，從字面上就可以得知其意思。也是代碼重用的一個思想。意思就說，繼承了父類以後，子類就和父類有相同的結構，從而保證可以向上轉型，也就是多態。說白了，就是子類有父類的全部行為，但是父類不一定有子類的全部行為。
方法的重寫也就是對父類的方法拓展。例如父類有一個A方法，子類繼承父類之後也有一個A方法，子類對這個A方法感到不桐弊滿意，或者想要添加幾句代碼，就可以通過重寫來拓展父類的方法。
-------------------------
立方體類：有長、寬、高三個基本屬性，構成了橡歲一個立方體。然後在寫幾個方法，用來計算局如族體積，面積等就可以了。
---------------------
面向對象最大的好處莫過於對現實事物中的抽象和描述了。
解答完畢。
❾ java語言中的重寫、重載、繼承
重寫，英文名是override，是指在繼承情況下，子類中定義了與仔亂其基類中方法具有相同型構的新方法，就叫做子團改類把基類的方法重寫了。這是實現多態念或檔必須的步驟。
重載，英文名是overload，是指在同一個類中定義了一個以上具有相同名稱，但是型構不同的方法。在同一個類中，是不允許定義多於一個的具有相同型構的方法的。
❿ 繼承，多態，重載和重寫的區別
重載，繼承，重寫，多態的區別
繼承：當多個類具有相同的特徵（屬性）和行為（方法），為了實現代碼復用，需要子類繼承父類的特徵和行為。使得子類具有父類的各種屬性和方法，除了具擾首有父類的特徵和行為，還具有一些自己特殊的特徵和行為。
多態：當一個類需要表現出多種形態，具有多種實現方式。避免了在父類里大量重載引起代碼臃腫且難於維護，增強程序的可擴展性及可維護性，使代碼更加簡潔。子類重寫父類的方法。使子類具有不同的方法實現。
可以簡單理解為：繼承是模襪子類使用父類的方法，而多態則是父類使用子類的方法。
重寫：如果在子類中定義的一個方法，其名稱、返回類型及參數列表正好與父類中某個方法的名稱、返回類型及參數列表相匹配，那麼可以說，子類的方法重寫了父類的方法。
重載：多個同名而不同參數的方法之間，互相稱之為重載方法。
介面：介面把方法的特徵和實現分割開來緩碼數。它本身沒有任何實現，不涉及表象，只描述public行為，所以介面比抽象類更抽象化。但是介面不是類，所以不能被實例化。
下列測試代碼：
package cn.lufice.test02;
public class Instrument {
public void play(int i){
System.out.println("Instrument"+i);
}
//重載
public void play( int i,String str){
System.out.println("Brass "+i+" "+str);
}
}
public class Brass extends Instrument {
public void play( int i,String str){
System.out.println("Brass "+i+" "+str);
}
}
public class Wind extends Instrument{
//重寫
public void play(int i){
System.out.println("Wind "+i);
}
public static void main(String[] args) {
Instrument instrument = new Wind();//多態
Brass brass = new Brass();//繼承
instrument.play(10);
brass.play(20,"barss");
}
}
/*Output：
Wind 10
Brass 20 barss
*/