內部類是指在一個外部類的內部再定義一個類。類名不須要和文件夾相同。
*內部類能夠是靜態static的,也可用public,default,protected和private修飾。(而外部頂級類即類名和文件名相同的只能使用public和default)。
注意:內部類是一個編譯時的概念,一旦編譯成功,就會成爲徹底不一樣的兩類。對於一個名爲outer的外部類和其內部定義的名爲inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
因此內部類的成員變量/方法名能夠和外部類的相同。
1. 成員內部類
成員內部類,就是做爲外部類的成員,能夠直接使用外部類的全部成員和方法,即便是private的。同時外部類要訪問內部類的全部成員變量/方法,則須要經過內部類的對象來獲取。
要注意的是,成員內部類不能含有static的變量和方法。
由於成員內部類須要先建立了外部類,才能建立它本身的,瞭解這一點,就能夠明白更多事情,在此省略更多的細節了。
在成員內部類要引用外部類對象時,使用outer.this來表示外部類對象;
而須要建立內部類對象,可使用outer.inner obj = outerobj.new inner();
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Outer.Inner inner = outer.new Inner();
- inner.print("Outer.new");
-
- inner = outer.getInner();
- inner.print("Outer.get");
- }
-
-
- public Inner getInner() {
- return new Inner();
- }
-
- public class Inner {
- public void print(String str) {
- System.out.println(str);
- }
- }
- }
2. 局部內部類
局部內部類,是指內部類定義在方法和做用域內。Thinking in Java給了這麼兩個例子:
定義在方法內:
- public class Parcel4 {
- public Destination destination(String s) {
- class PDestination implements Destination {
- private String label;
-
- private PDestination(String whereTo) {
- label = whereTo;
- }
-
- public String readLabel() {
- return label;
- }
- }
- return new PDestination(s);
- }
-
- public static void main(String[] args) {
- Parcel4 p = new Parcel4();
- Destination d = p.destination("Tasmania");
- }
- }
定義在做用域裏:
- public class Parcel5 {
- private void internalTracking(boolean b) {
- if (b) {
- class TrackingSlip {
- private String id;
- TrackingSlip(String s) {
- id = s;
- }
- String getSlip() {
- return id;
- }
- }
- TrackingSlip ts = new TrackingSlip("slip");
- String s = ts.getSlip();
- }
- }
-
- public void track() {
- internalTracking(true);
- }
-
- public static void main(String[] args) {
- Parcel5 p = new Parcel5();
- p.track();
- }
- }
局部內部類也像別的類同樣進行編譯,但只是做用域不一樣而已,只在該方法或條件的做用域內才能使用,退出這些做用域後沒法引用的。
3. 嵌套內部類
嵌套內部類,就是修飾爲static的內部類。聲明爲static的內部類,不須要內部類對象和外部類對象之間的聯繫,就是說咱們能夠直接引用outer.inner,即不須要建立外部類,也不須要建立內部類。
嵌套類和普通的內部類還有一個區別:普通內部類不能有static數據和static屬性,也不能包含嵌套類,但嵌套類能夠。而嵌套類不能聲明爲private,通常聲明爲public,方便調用。
4. 匿名內部類
有時候我爲了免去給內部類命名,便傾向於使用匿名內部類,由於它沒有名字。例如:
- ((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {
- @Override
- public void onClick(View v) {
- new Thread() {
-
- @Override
- public void run() {
-
- }
-
- }.start();
- }
- });
匿名內部類是不能加訪問修飾符的。
要注意的是,new 匿名類,這個類是要先定義的,看下面例子:
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- }
-
- public Inner getInner(final String name, String city) {
- return new Inner() {
- private String nameStr = name;
-
- public String getName() {
- return nameStr;
- }
- };
- }
- }
-
-
-
-
-
同時在這個例子,留意外部類的方法的形參,
當所在的方法的形參須要被內部類裏面使用時,該形參必須爲final。這裏能夠看到形參name已經定義爲final了,而形參city 沒有被使用則不用定義爲final。爲何要定義爲final呢?在網上找到本人比較如同的解釋:
「這是一個編譯器設計的問題,若是你瞭解java的編譯原理的話很容易理解。
首先,內部類被編譯的時候會生成一個單獨的內部類的.class文件,這個文件並不與外部類在同一class文件中。
當外部類傳的參數被內部類調用時,從java程序的角度來看是直接的調用例如:
public void dosome(final String a,final int b){
class Dosome{public void dosome(){System.out.println(a+b)}};
Dosome some=new Dosome();
some.dosome();
}
從代碼來看好像是那個內部類直接調用的a參數和b參數,可是實際上不是,在java編譯器編譯之後實際的操做代碼是
class Outer$Dosome{
public Dosome(final String a,final int b){
this.Dosome$a=a;
this.Dosome$b=b;
}
public void dosome(){
System.out.println(this.Dosome$a+this.Dosome$b);
}
}}
從以上代碼看來,內部類並非直接調用方法傳進來的參數,而是內部類將傳進來的參數經過本身的構造器備份到了本身的內部,本身內部的方法調用的實際是本身的屬性而不是外部類方法的參數。
這樣理解就很容易得出爲何要用final了,由於二者從外表看起來是同一個東西,實際上卻不是這樣,若是內部類改掉了這些參數的值也不可能影響到原參數,然而這樣卻失去了參數的一致性,由於從編程人員的角度來看他們是同一個東西,若是編程人員在程序設計的時候在內部類中改掉參數的值,可是外部調用的時候又發現值其實沒有被改掉,這就讓人很是的難以理解和接受,爲了不這種尷尬的問題存在,因此編譯器設計人員把內部類可以使用的參數設定爲必須是final來規避這種莫名其妙錯誤的存在。」
(簡單理解就是,拷貝引用,爲了不引用值發生改變,例如被外部類的方法修改等,而致使內部類獲得的值不一致,因而用final來讓該引用不可改變)
由於匿名內部類,沒名字,是用默認的構造函數的,無參數的,那若是須要參數呢?則須要該類有帶參數的構造函數:
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- }
-
- public Inner getInner(final String name, String city) {
- return new Inner(name, city) {
- private String nameStr = name;
-
- public String getName() {
- return nameStr;
- }
- };
- }
- }
-
- abstract class Inner {
- Inner(String name, String city) {
- System.out.println(city);
- }
-
- abstract String getName();
- }
注意這裏的形參city,因爲它沒有被匿名內部類直接使用,而是被抽象類Inner的構造函數所使用,因此沒必要定義爲final。
而匿名內部類經過實例初始化,能夠達到相似構造器的效果:
- public class Outer {
- public static void main(String[] args) {
- Outer outer = new Outer();
- Inner inner = outer.getInner("Inner", "gz");
- System.out.println(inner.getName());
- System.out.println(inner.getProvince());
- }
-
- public Inner getInner(final String name, final String city) {
- return new Inner() {
- private String nameStr = name;
- private String province;
-
-
- {
- if (city.equals("gz")) {
- province = "gd";
- }else {
- province = "";
- }
- }
-
- public String getName() {
- return nameStr;
- }
-
- public String getProvince() {
- return province;
- }
- };
- }
- }
-
- interface Inner {
- String getName();
- String getProvince();
- }
5.內部類的繼承
內部類的繼承,是指內部類被繼承,普通類 extents 內部類。而這時候代碼上要有點特別處理,具體看如下例子:
- public class InheritInner extends WithInner.Inner {
-
-
- InheritInner(WithInner wi) {
- wi.super();
- }
-
- public static void main(String[] args) {
- WithInner wi = new WithInner();
- InheritInner obj = new InheritInner(wi);
- }
- }
-
- class WithInner {
- class Inner {
-
- }
- }
能夠看到子類的構造函數裏面要使用
父類的外部類對象.super();而這個對象須要從外面建立並傳給形參。
至於內部類的重載,感受Thinking in Java的例子很複雜,在日常應用中應該不多,由於有點難懂,不清晰。而內部類和閉包之間的事情,暫時放下,之後再看。