簡述JAVA中繼承實現代碼復用

看看下面這個例子，就會明白了：JAVA中繼承可以實現代碼復用，

創新互聯建站2013年開創至今，是專業互聯網技術服務公司，擁有項目成都網站建設、成都網站制作網站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元前郭做網站,已為上家服務,為前郭各地企業和個人服務,聯系電話:18980820575

由于在父類中已經定義的方法，被子類繼承以后，就可以使用，實現了代碼的復用

class Father{

private int moneyDollar=300;

int moneyHK=200;

int add(int x,int y){

return x+y;

}

}

class Son extends Father{

int moneyRMB=800;

public void changMoneyHK(int x){

moneyHK=x;

}

public void changMoneyRMB(int x){

moneyRMB=x;

}

int subs(int x,int y){

return x-y;

}

}

class GrandSon extends Son{

int multi(int x,int y){

return x*y;

}

}

public class Example5_1{

public static void main(String args[]){

int a=5,b=3;

Son son=new Son();

GrandSon sunzi=new GrandSon();

son.changMoneyHK(666);

son.changMoneyRMB(5000);

System.out.println("兒子的港幣是繼承的屬性,當前的值是:"+son.moneyHK);

System.out.println("兒子的人民幣是新增的屬性,當前的值是:"+son.moneyRMB);

System.out.printf("減法是兒子新增的功能,%d-%d等于%d\n",a,b,son.subs(a,b));

System.out.printf("加法是兒子繼承的功能,%d+%d等于%d\n",a,b,son.add(a,b));

System.out.println("孫子的港幣和人民幣都是繼承的屬性,,當前的值是:");

System.out.println("港幣:"+sunzi.moneyHK+" 人民幣:"+sunzi.moneyRMB);

System.out.printf("乘法是孫子新增的功能,%d*%d等于%d\n",a,b,sunzi.multi(a,b));

System.out.printf("加法是孫子繼承的功能,%d+%d等于%d\n",a,b,sunzi.add(a,b));

System.out.printf("減法是孫子繼承的功能,%d-%d等于%d\n",a,b,sunzi.subs(a,b));

}

}

Java僅僅有一個參數不一致,如何提高代碼復用性

如果你用的是eclipse可以用快捷鍵來抽取方法的，就是選中重復的代碼，然后按alt+shift+m，就解決你的代碼重復問題。

java在如下情況怎么實現代碼的復用

去掉泛型直接復用就行了。代碼貌似有問題

public Kmodel execute(){

ListKmodellist = gethandle();

return list;

}

方法返回的是一個list返回的類型 不是Kmodel或Qmodel

應該是這樣吧

public ListKmodel execute(){

ListKmodel list = gethandle();

return list;

}

想復用的話就 去掉泛型應該就能用了。不過取list的元素時需要強制轉換類型。

public List execute(){

List list = gethandle();

return list;

}

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 為什么要實現 function？

java是一個面向對象的編程語言，類包括屬性和行為，其中的行為就是有function實現的，所以對象需要實現行為才能算是健壯的對象，非常重要，下面學習的一些內容，希望能幫到你。

數據的連接首先需要加載一個代碼塊。如果 chunk 是一個字符串，代碼塊指這個字符串。如果 chunk 是一個函數， load 不斷地調用它獲取代碼塊的片段。 每次對 chunk 的調用都必須返回一個字符串緊緊連接在上次調用的返回串之后。 當返回空串、nil、或是不返回值時，都表示代碼塊結束。

1.如果沒有語法錯誤， 則以函數形式返回編譯好的代碼塊；?否則，返回 nil 加上錯誤消息。

如果結果函數有上值， env 被設為第一個上值。 若不提供此參數，將全局環境替代它。 所有其它上值初始化為 nil。 （當你加載主代碼塊時候，結果函數一定有且僅有一個上值 _ENV ））。 然而，如果你加載一個用函數（參見 string.dump， 結果函數可以有任意數量的上值） 創建出來的二進制代碼塊時，所有的上值都是新創建出來的。 也就是說它們不會和別的任何函數共享。

2.接下來就是根據以上信息進行下面的操作，chunkname 在錯誤消息和調試消息中，用于代碼塊的名字。 如果不提供此參數，它默認為字符串chunk 。 chunk 不是字符串時，則為 "=(load)" 。

字符串 mode 用于控制代碼塊是文本還是二進制（即預編譯代碼塊）。 它可以是字符串 "b" （只能是二進制代碼塊）， "t" （只能是文本代碼塊）， 或 "bt" （可以是二進制也可以是文本）。 默認值為 "bt"。

3.Lua 不會對二進制代碼塊做健壯性檢查。 惡意構造一個二進制塊有可能把解釋器弄崩潰。

運行程序來遍歷表中的所有域。 第一個參數是要遍歷的表，第二個參數是表中的某個鍵。 next 返回該鍵的下一個鍵及其關聯的值。 如果用 nil 作為第二個參數調用 next 將返回初始鍵及其關聯值。 當以最后一個鍵去調用，或是以 nil 調用一張空表時， next 返回 nil。 如果不提供第二個參數，將認為它就是 nil。 特別指出，你可以用 next(t) 來判斷一張表是否是空的。

索引在遍歷過程中的次序無定義， 即使是數字索引也是這樣。 （如果想按數字次序遍歷表，可以使用數字形式的 for 。）

4.當在遍歷過程中你給表中并不存在的域賦值， next 的行為是未定義的。?然而你可以去修改那些已存在的域。 特別指出，你可以清除一些已存在的域。

如果 t 有元方法 __pairs， 以 t 為參數調用它，并返回其返回的前三個值。

否則，返回三個值：next 函數， 表 t，以及 nil。 因此以下代碼

能迭代表 t 中的所有鍵值對。

參見函數 next 中關于迭代過程中修改表的風險。

pcall (f [, arg1, ···])

5.傳入參數，以 保護模式 調用函數 f 。 這意味著 f 中的任何錯誤不會拋出；?取而代之的是，pcall 會將錯誤捕獲到，并返回一個狀態碼。 第一個返回值是狀態碼（一個布爾量）， 當沒有錯誤時，其為真。 此時，pcall 同樣會在狀態碼后返回所有調用的結果。 在有錯誤時，pcall 返回 false 加錯誤消息。

希望能幫到你，謝謝！