Java內部類

Java內部類是Java中比較重要的一部分，準備多花幾天學習下。
以下是Java內部類的一些示例：
1、 在內部類中調用外部類和在外部類中調用內部類
* 外部類的內部類會自動創建對外部類的引用，所以外部類中的任何元素都可以被內部內訪問，private也可以。

//
package innerClass;
public class InnerClass {
    private String name="huangbiao";
    class demo{
        public void syso(){
            System.out.println("some thing");
            System.out.println(name);
        }
        //內部類中建立外部類對象
        public InnerClass returnFatherClass(){
            return InnerClass.this;
        }
    }
    class dem2{
        String lable="";
        public dem2(String i){
            this.lable=i;
        }
    }
    public demo returnReference(){
        return new demo();
    }
    public static void main(String[] args) {
        InnerClass in=new InnerClass();
        //外部中建立內部類對象
        InnerClass.demo de=in.new demo();
        InnerClass dem=de.returnFatherClass();
    }
}

2、 方法中調用內部類
* 使用關鍵字外部類名.內部類名 引用名 = 外部類引用.new,而內部類中調用外部類關鍵字爲外部類名.this。

package innerClass;
public class PartInnerClass {
    interface showSomeThing{        
    }
    public showSomeThing method(){
        class show implements showSomeThing{
            String b; 
            public show(String i){
                this.b=i;
            }
            public void print(){
                System.out.println(b);
            }
        }
        return new show("2");
    }
}

3、 內部類中實現接口以及接口中實現內部類

package innerClass;
interface demo{
    public void show(int i);
    //接口中的內部類可以實現外圍接口
    class Demo implement demo{
    //
    public static void main(String[] Args){
    //可以在其中聲明測試方法。
    }
    }
}
interface demo2{
    public void show2(String b);
}
public class InterceptereAndInnerClass {
    class innerOne implements demo{
        public int i=0;
        @Override
        public void show(int i) {
            // TODO Auto-generated method stub
            this.i= i;
        }}
    class innerTwo implements demo2{
        String i;
        @Override
        public void show2(String b) {
            // TODO Auto-generated method stub
            this.i=b;
            System.out.println(i);
        }
    }
    public demo returnInnerOne(){
        return new innerOne();
    }
    public demo2 returnInnerTwo(){
        return new innerTwo();
    }
    public static void main(String[] args) {
        InterceptereAndInnerClass in=new InterceptereAndInnerClass();
        //Type mismatch: cannot convert from demo to InterceptereAndInnerClass.innerOne
        //錯誤，不能再向下轉型：
        //InterceptereAndInnerClass.innerOne inOne=in.returnInnerOne();
        demo de=in.returnInnerOne();  
    }
}

1. 匿名內部類
   
   • 匿名內部類沒有構造函數，但是抽象類有，所以可以在抽象類中定義構造函數，實現匿名類的默認構造函數，如果用接口實現就會默認使用無參構造。
   • 匿名內部類中的參數必須是final的（如果不在內部類中直接使用的話就不需要是final的，有些情況在構造器中使用）
     代碼如下：

package com.innerClazz;

interface Wrap2{

}

abstract class Wrap{
    public Wrap(int x){

    }
}
public class InnerClazz_NoName {
    int a=1;
    public Wrap returnWrap(final int x){
        return new Wrap(x){
            public void showSomeThing(){
                a = a+x;
            }
        };//標記結束
    }
    public Wrap2 returnWrap2(){
        return new Wrap2(){

        };
    };
}

1. 嵌套類和多層嵌套內部類
   即將內部類聲明爲Static，
   
   • 此時內部類沒有了默認的指向外部類的引用
   • 創建這個內部類時直接創建就可以了
   • 不能訪問外部類中非靜態的變量

package com.innerClazz;

public class InnerClazz_Static {
    private int i=0;
    static class Some{
        //不能訪問i
    } 
    public void some(){
        Some s = new Some();
    }
    class A{
        class B{

        }
    }
    public void show(){
        //多層嵌套內部類
        InnerClazz_Static.A.B b =new InnerClazz_Static().new A().new B();
    }
}

1. 內部類的繼承與覆蓋
   內部類可以被繼承，但是不能被覆蓋，但是可以通過集成內部類的方式覆蓋,通過方法將繼承類中的內部類對象傳上去，調用內部類中的方法
   代碼如下：

        package com.innerClazz;


class Some{
    SomeThing so;
    class SomeThing{
        public void say(){
            System.out.println("say");
        }
    }
    public void setSo(SomeThing st){
        so = st;
    }
}

public class InnnerClazz_Extends extends Some{
    class Ok extends Some.SomeThing{
        public Ok(Some s){
            s.super();
        }

        public void say(){
            System.out.println("sys extends");
        }

    }
    public static void main(String[] args) {
        Some s = new Some();
        InnnerClazz_Extends.Ok o = new InnnerClazz_Extends().new Ok(s); 
        s.setSo(o);
    }
}

內部類真的很重要，這方面要多看下。