對(duì)于Java中重載和覆蓋的概念，很多人到現(xiàn)在都是搞不清楚，下面小編舉例給大家講講這兩者的區(qū)別。

　　一、覆蓋

　　1 override可以翻譯為覆蓋，從字面就可以知道，它是覆蓋了一個(gè)方法并且對(duì)其重寫，以求達(dá)到不同的作用。對(duì)我們來說最熟悉的覆蓋就是對(duì)接口方法的實(shí)現(xiàn)，在接口中一般只是對(duì)方法進(jìn)行了聲明，而我們?cè)趯?shí)現(xiàn)時(shí)，就需要實(shí)現(xiàn)接口聲明的所有方法。

　　除了這個(gè)典型的用法以外，我們?cè)诶^承中也可能會(huì)在子類覆蓋父類中的方法。在覆蓋要注意以下的幾點(diǎn)：

　　1、覆蓋的方法的標(biāo)志必須要和被覆蓋的方法的標(biāo)志完全匹配，才能達(dá)到覆蓋的效果;

　　2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致;

　　3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類;

　　4、被覆蓋的方法不能為private，否則在其子類中只是新定義了一個(gè)方法，并沒有對(duì)其進(jìn)行覆蓋。

　　二、重載

　　overload對(duì)我們來說可能比較熟悉，可以翻譯為重載，它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入?yún)?shù)來區(qū)分這些方法，然后再調(diào)用時(shí)，VM就會(huì)根據(jù)不同的參數(shù)樣式，來選擇合適的方法執(zhí)行。

　　在使用重載要注意以下的幾點(diǎn)：

　　1、在使用重載時(shí)只能通過不同的參數(shù)樣式。例如，不同的參數(shù)類型，不同的參數(shù)個(gè)數(shù)，不同的參數(shù)順序(當(dāng)然，同一方法內(nèi)的幾個(gè)參數(shù)類型必須不一樣，例如可以是fun(int, float)， 但是不能為fun(int, int));

　　2、不能通過訪問權(quán)限、返回類型、拋出的異常進(jìn)行重載;

　　3、方法的異常類型和數(shù)目不會(huì)對(duì)重載造成影響;

　　三、覆蓋和重載的區(qū)別

　　下面是對(duì)override和overload的測(cè)試程序，其中注釋中的內(nèi)容都是會(huì)產(chǎn)生編譯錯(cuò)誤的代碼，我們將注釋去掉，看看在編譯時(shí)會(huì)產(chǎn)生什么效果。

　　// 對(duì)overload測(cè)試的文件：OverloadTest.java

　　public class OverloadTest {

　　// 下面幾個(gè)方法用來驗(yàn)證可以通過定義不同的參數(shù)類型和參數(shù)的數(shù)目進(jìn)行方法重載。

　　public void fun(){

　　System.out.println("method fun in OverloadTest, no parameter");

　　}

　　public void fun(float f) {

　　System.out.println("method fun in OverloadTest, parameter type: float");

　　}

　　public void fun(int i){

　　System.out.println("method fun in OverloadTest, parameter type: int");

　　}

　　public void fun(int i1, int i2) {

　　System.out.println("method fun in OverloadTest, parameter type: int, int");

　　}

　　// 下面的兩個(gè)方法用來驗(yàn)證可以通過定義不同的參數(shù)順序進(jìn)行方法重載。

　　// 需要注意：這里的參數(shù)肯定不是相同的類型，否則的順序的先后就毫無意義。

　　public void fun1(int i, float f) {

　　System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");

　　}

　　public void fun1(float f, int i) {

　　System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");

　　}

　　// 下面的兩個(gè)方法用來驗(yàn)證方法拋出的異常對(duì)于重載的影響.

　　// 無論是異常的類型還是異常的個(gè)數(shù)都不會(huì)對(duì)重載造成任何的影響。

　　public void fun2() throws TestException {

　　System.out.println("fun2 in OverloadTest, exception: TestException");

　　}

　　public void fun2(int i) throws TestException, TestException1 {

　　System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");

　　}

　　public void fun2(float f) throws Exception {

　　System.out.println("fun2 in OverloadTest, exception: Exception");

　　}

　　// 不能通過拋出的異常類型來重載fun方法。

　　//public void fun(int i) throws Exception {

　　// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");

　　//}

　　// ? 不能通過返回值重載fun方法。

　　//public boolean fun(int i) throws Exception {

　　// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");

　　// return true;

　　//}

　　private void fun3() { }

　　// 不能通過不同的訪問權(quán)限進(jìn)行重載

　　public void fun3() { }

　　public static void main(String[] args) {

　　// 這里只是定義了OverloadTest的實(shí)例，所以test不會(huì)調(diào)用

　　// OverloadTest1中的方法。

　　OverloadTest test = new OverloadTest1();

　　// 這里定義了OverloadTest1的實(shí)例，因?yàn)镺verloadTest1是OverloadTest

　　// 的子類，所以test1會(huì)調(diào)用OverloadTest中的方法。

　　OverloadTest1 test1 = new OverloadTest1();

　　try {

　　int i = 1, j = 2, m = 3;

　　// 這里不會(huì)調(diào)用OverloadTest1的fun方法

　　// test.fun(i, m, j);

　　test1.fun(i, j, m);

　　test1.fun();

　　// 這個(gè)調(diào)用不會(huì)執(zhí)行，因?yàn)閒un3()在OverloadTest中訪問權(quán)限是priavte

　　//test1.fun3();

　　test1.fun3(i);

　　} catch(Exception e) { }

　　}

　　}

　　class OverloadTest1 extends OverloadTest{

　　// 在子類中重載fun

　　public void fun(int i, int m, int n) {

　　System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");

　　}

　　// 這個(gè)不是對(duì)父類中方法的重載，只是一個(gè)新的方法。

　　public void fun3(int i) {

　　System.out.println("fun2 in OverloadTest1");

　　}

　　}

　　// 對(duì)override測(cè)試的文件：OverrideTest.java

　　public class OverrideTest {

　　public void fun() throws TestException {

　　System.out.println("method fun in OverrideTest");

　　}

　　private void fun1() {

　　System.out.println("method fun1 in OverrideTest");

　　}

　　public static void main(String[] args) {

　　OverrideTest test = new OverrideTest1();

　　try {

　　test.fun();

　　test.fun1();

　　} catch(Exception e) { }

　　}

　　}

　　class OverrideTest1 extends OverrideTest{

　　// 以下正常Override

　　public void fun() throws TestException2 {

　　System.out.println("fun in OverrideTest1");

　　}

　　// 不能Override父類中的方法，因?yàn)樗x了不同的異常類型和

　　// 返回值。

　　//public int fun() throws TestException1 {

　　// System.out.println("method fun in Test");

　　// return 1;

　　//}

　　// 不能Override父類中的方法，因?yàn)樗鼟伋隽吮雀割愔蟹欠ǚ秶?/p>

　　// 更大的異常。

　　//public void fun() throws Exception {

　　// System.out.println("fun in OverrideTest1");

　　//}

　　// 這個(gè)方法并沒有Override父類中的fun1方法，因?yàn)檫@個(gè)方法在

　　// 父類是private類型，所以這里只是相當(dāng)于定義了一個(gè)新方法。

　　public void fun1() {

　　System.out.println("method fun1 in Test");

　　}

　　}

　　class TestException extends Exception{

　　public TestException(String msg) {

　　super(msg);

　　}

　　}

　　class TestException1 extends TestException {

　　public TestException1(String msg) {

　　super(msg);

　　}

　　}

　　class TestException2 extends TestException {

　　public TestException2(String msg) {

　　super(msg);

　　}

　　}