JAVA重載和重寫、內部類機制

#1、重載和重寫 **重載 **

一、必須具備不一樣的參數列表；

二、能夠有不責罵的返回類型，只要參數列表不一樣就能夠了；

三、能夠有不一樣的訪問修飾符；

四、能夠拋出不一樣的異常；

**重寫 **

一、參數列表必須徹底與被重寫的方法相同，不然不能稱其爲重寫而是重載。

二、返回的類型必須一直與被重寫的方法的返回類型相同，不然不能稱其爲重寫而是重載。

三、訪問修飾符的限制必定要大於被重寫方法的訪問修飾符（public>protected>default>private）

四、重寫方法必定不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的檢查型異常。例如：父類的一個方法申明瞭一個檢查異常IOException，在重寫這個方法是就不能拋出Exception,只能拋出IOException的子類異常，能夠拋出非檢查異常。

重載——有不一樣的參數列表（靜態多態性）
重寫——相同參數，不一樣實現（動態多態性）

#2、內部類機制 ##常規內部類

一、常規內部類沒有用static修飾且定義在在外部類類體中

二、常規內部類中的方法能夠直接使用外部類的實例變量和實例方法

三、在常規內部類中能夠直接用內部類建立對象

public class MyOuter {
 private int x = 100;
 // 建立內部類
 class MyInner {
  private String y = "Hello!";
  public void innerMethod() {
   System.out.println("內部類中 String =" + y);
   System.out.println("外部類中的x =" + x);// 直接訪問外部類中的實例變量x
   outerMethod();
   System.out.println("x is" + MyOuter.this.x);
  }
 }
 public void outerMethod() {
  x++;
 }
 public void makeInner() {
//在外部類方法中建立內部類實例
  MyInner in = new MyInner();
 }
 /**
  * @param args
  */
 public static void main(String[] args) {
  MyOuter mo = new MyOuter();
  // 使用外部類構造方法建立mo對象
  MyOuter.MyInner inner = mo.new MyInner();//常規內部類須要經過外部類的實例才能建立對象，與實例變量須要經過對象來訪問類似
  // 建立inner對象
  inner.innerMethod();
  // TODO Auto-generated method stub
 }
}

//輸出結果
內部類中 String =Hello!  
外部類中的x =100  
x is101

##靜態內部類

一、與類的其餘成員類似，用static修飾內部類；

二、靜態內部類與靜態內部方法類似，只能訪問外部類的static成員，不能直接訪問外部類的實例變量，與實例方法，只有經過對象引用才能訪問。

三、因爲static內部類不具備任何對外部類實例的引用，所以static內部類中不能使用this關鍵字來訪問外部類中的實例成員，可是能夠訪問外部類中的static成員。

package com.m.ou;
public class MyOuter {
 public static int x=100;
 public static class MyInner{
  private String y="Hello!";
  public void innerMethod(){
   System.out.println("x="+x);
   System.out.println("y="+y);
  }  
 }
 /**
  * @param args
  */
 public static void main(String[] args) {
  MyOuter.MyInner si=new MyOuter.MyInner();//靜態內部類不經過外部實例就能夠建立對象；與類變量能夠經過類名訪問類似
  si.innerMethod();
  // TODO Auto-generated method stub
 }
}

//輸出結果
x=100  
y=Hello!

##局部內部類

一、在方法體或語句塊（包括方法、構造方法、局部塊或靜態初始化塊）內部定義的類；

二、局部內部類不能加任何訪問修飾符，由於它只對局部塊有效；

三、局部內部類只在方法體中有效，和定義的局部變量同樣，在定義的方法體外不能建立局部內部類的對象；

四、在方法內部定義類時，應注意如下問題：
1）方法定義局部內部類同方法定義局部變量同樣，不能使用private、protected、public等訪問修飾說明符修飾，也不能使用static修飾，但能夠使用final和 abstract修飾；
2）方法中的內部類能夠訪問外部類成員。對於方法的參數和局部變量，必須有final修飾才能夠訪問。
3）static方法中定義的內部類能夠訪問外部類定義的static成員。

public class Jubu {
 private int size=5,y=7;
 public Object makeInner(int localVar){
  final int finalLocalVar=localVar;
  //建立內部類，該類只在makeInner（）方法有效，就像局部變量同樣。在方法體外部不能建立MyInner類的對象
  class MyInner{
   int y=4;
   public String toString(){
    return "OuterSize:"+size+
        "\nfinalLocalVar"+" "+"this.y="+this.y;
   }   
  }
  return new MyInner();
 }
}
class Main{ /**
  * @param args
  */
 public static void main(String[] args) {
  
  Object obj=new Jubu().makeInner(47);//建立Jubu對象obj，並調用它的makeInner（）方法，該方法返回一個
  //該方法返回一個MyInner類型的的對象obj，而後調用其同toString方法。
  System.out.println(obj.toString());
  // TODO Auto-generated method stub
 }
} 
//輸出結果
OuterSize:5  
finalLocalVar this.y=4

##匿名內部類

定義類的最終目的是建立一個類的實例，可是若是某個類的實例只是用一次，則能夠將類的定義與類的建立，放到與一塊兒完成，或者說在定義類的同時就建立一個類。 以這種方法定義的沒有名字的類成爲匿名內部類；

一、匿名內部類能夠繼承一個類或實現一個接口，這裏的ClassOrInterfaceName是匿名內部類所繼承的類名或實現的接口名。但匿名內部類不能同時實現一個接口和繼承一個類，也不能實現多個接口。若是實現了一個接口，該類是Object類的直接子類，匿名類繼承一個類或實現一個接口，不須要extends和implements關鍵字。

二、因爲匿名內部類沒有名稱，因此類體中不能定義構造方法，因爲不知道類名也不能使用關鍵字來建立該類的實例。實際上匿名內部類的定義、構造、和第一次使用都發生在一樣一個地方。此外，上式是一個表達式，返回的是一個對象的引用，因此能夠直接使用或將其複製給一個對象變量。

//定義格式
new ClassOrInterfaceName(){
/*類體*/
 }

TypeName obj=new Name（）{
/*此處爲類體*/
}

//也能夠將構造的對象做爲調用的參數
someMethod(new Name(){
   /*此處爲類體*/  });

//測試
 public class NiMing {
 private int size=5;
 public Object makeInner(int localVar){
  final int finalLocalVar=localVar;
  return new Object(){
   //使用匿名內部類
   public String toString(){
    return "OuterSize="+size+"\nfinalLocalVar="+finalLocalVar;
   }
  };
 }
 /**
  * @param args
  */
public static void main(String args[])
 {
 Object obj=new NiMing().makeInner(47);
 System.out.println(obj.toString());
 }
}

//返回結果
OuterSize=5  
finalLocalVar=47

參考文獻：
http://blog.csdn.net/qq435757399/article/details/7037007