內部類（inner class）的簡單介紹

本文主要介紹內部類（inner class）的一些基本應用，將從內部類的分類角度，首先對每一個具體內部類進行介紹。主要包括普通的內部類【common inner class】、局部內部類[local inner class]、嵌套內部類【nested innner class】、匿名內部類【anonymous inner class】、然后比較一下局部內部類[local inner class]和匿名內部類【anonymous inner class ]的區別，進而知道在具體情況下該選擇內部類，即到底用local inner class還是anonymous inner class。最后介紹內部類的應用。

一：首先對每一個具體內部類進行介紹

1.普通的內部類【common inner class】

定義：在一個類里面直接定義一個類：

一些詳細情況看代碼：

package com.qls.comonInnerClass;

public class A {
    /**
     * 從B C D E 這四個普通內部類中可以看出類前面的修飾符可以是
     * private  protected default(也就是什么修飾符沒有的D) public.  而在局部內部類中修飾類的只能是：
     * abstract 或final 或者什么修飾符都沒有。
     * 注意的問題如下：
     * 1.通常情況下:外部類會有一個返回內部類引用的一個方法如getB()這個方法。
     * 2.如何在內部類中用this指代外部類引用？【答：外部類名.this 參考第19行代碼。】
     * 以及如何創建內部類的一個實例？【答：x.new B() 其中x是外部類的一個實例，B為一個內部類。
     * 若是直接寫new B()會報錯。參考第38、39兩行代碼。】
     * 上述兩個注意點對其他的內部類也適用。
     * @author 秦林森
     *
     */
    private  class B {
        public A outer(){
            return A.this;//A.this是指代A的一個引用。
        }
    }
    protected class C{
        
    }
    class D{
        
    }
    public class E{
        
    }
    /**
     * 返回內部類的引用：
     */
    B getB(){
        return new B();
    }
    public static void main(String[] args) {
        A a = new A();
        B b = a.new B();
    }
}

局部內部類【local innner class】

定義：把類定義在方法里面，或者是方法中的某一個區域中。

代碼如下：

package com.qls.localInnerClass2;
/**
 * 定義：the creation of an entire class within the scope of a method,or Nesting a class within 
 * a scope of a method.
 * This is called a local inner class.
 * 注意情況如下：
 * 1.局部內部類【local inner class】如果想要修飾的話，只有abstract 和final可以，
 * 其余的如(public protected)等都不可以。
 * 2.在局部內部類中只能訪問包含該內部類的范圍(enclosing scope)的final變量。若不是則會報錯。
 * 
 * @author 秦林森
 *
 */
public class A {
    public void ouyangfeng(){
        //把類D定義在方法ouyangfeng()的某個區域中。
        if(3>2){
            class D{
                
            }
        }
        final class B{
            
        }
    }
    
    public void  sixi(final String s){
        int e=1;
        final int c=8;
        class C{
            /**
             * 在局部內部類或者匿名內部類中只能訪問包含該內部類的范圍(enclosing scope)的final變量。
             * 若不是則會報錯。
             * 如int f=e；編譯器報錯。
             */
            String str=s;
            int d=c;
//            int f=e;//編譯器報錯。
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

匿名內部類：沒有名字的內部類。

下面的代碼介紹了以下的內容：

1.匿名內部類實現一個接口，

2.匿名內部類實現一個沒有默認構造方法的抽象類

3.匿名內部類和局部內部類一樣把參數定義成final，完成字段初始化

4.匿名內部類用普通代碼塊{}完成初始化，彌補了匿名內部類沒有構造方法的缺陷。

代碼如下：

package com.qls.anonymouseInnerClass;
/**
 * 匿名內部類(anonymous inner class)一般用在return 語句中。
 * 注意情況如下：
 * 匿名內部類由於沒有名字，自然而然也就沒有構造方法，其他三種內部類都有構造方法。
 * 沒有構造方法怎么給對象賦值進行初始化呢？【答：用普通的代碼塊{},在這個代碼塊里面實行初始化。】
 * @author 秦林森
 *
 */
interface B{
    void ouyangfeng();
}
abstract class C{
    private int i;
    public C(int i) {
        this.i=i;
    }
    public abstract int value();
    
}
public class A {
    public B getB(){
        //new B(){};就是匿名內部類：用默認的構造方法
        return new B() {
            
            @Override
            public void ouyangfeng() {
                // TODO Auto-generated method stub
                System.out.println("ouyangfeng is chief village of sixi ");
            }
        };
    }
    public C getC(final int i){
        //匿名內部類用一個帶參數的構造方法
        return new C(i) {
            //用普通代碼塊實現初始化：
            {
                //這里寫兩個輸出語句作為演示。
                System.out.println("泗溪");
                System.out.println("ouyangfeng");
                System.out.println(value());//輸出value的值
            }
            @Override
            public int value() {
                // TODO Auto-generated method stub
                return i;//從這里可以看出要想引用i,必須把i定義成final。這和局部內部類一樣。
            }
        };
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new A().getC(4);//輸出泗溪、ouyangfeng、4
        
    }

}

 嵌套內部類：

package com.qls.nestedClass;
/**
 * 如果你不想讓內部類的對象和外部類的對象有如何聯系的話，你就可以把內部類定義成static
 * 嵌套內部類(Nested inner class)的定義：類中關鍵詞static修飾的內部類。
 * 注意情況如下：
 * 1.在嵌套內部類中不能訪問外部類的非靜態變量。
 * 2.創建內部類變量時，你不想通過創建外部類變量才能創建內部類變量時，你可以把這個內部類定義成static
 * 即嵌套內部類。
 * 3.在接口interface中定義的內部類默認都是public static 的，所以在接口中的內部類必是嵌套內部類。
 * @author 秦林森
 *
 */
interface D{
    void hello();
    class Test implements D{

        @Override
        public void hello() {
            // TODO Auto-generated method stub
            System.out.println("hello");
        }
        public static void main(String[] args) {
            /**
             * 由於Test類默認是public static 的，所以創建Test對象時，不需要通過外部類D，
             * 所以直接new Test()即可創建Test類中的一個對象。
             * 話又說回來了，如果在接口中的類不是public static 的那么這個內部類也就是普通的內部類
             * 在創建Test的對象時，也就需要外部類的對象。關鍵D是接口，你怎么new 呢？
             * 所以在的類只能是static 的。
             */
            new Test().hello();//輸出hello
        }
    }
}
public class A {
    int a=9;
    public static  class B{
//        int b=a;編譯報錯
         void f(){
            System.out.println("f()");
        }
    }
    public static void main(String[] args) {
        /**
         * 從這里你看到了，可以對B直接new ，訪問B中的函數f().
         * 但是如果B沒有static這個關鍵字，即B是普通內部類時，必須這樣才能訪問到f()
         * new A().new B().f();
         */
        new B().f();
    }
}

 二：比較一下局部內部類[local inner class]和匿名內部類【anonymous inner class ]的區別

1.匿名內部類沒有構造犯法，二局部內部類有構造方法。

2.如果在一個外部類有兩個或兩個以上的方法，返回的都是某個接口或者抽象類的引用，建議把寫一個局部內部類。若寫成匿名內部類時，代碼會顯得特別冗長。反之如果一個時，建議用匿名內部類。

代碼如下：

package com.qls.anonymouseInnerClass;
interface Six{
    void six();
}
public class Ouyangfeng {
    private class SixTest implements Six{

        @Override
        public void six() {
            // TODO Auto-generated method stub
            
        }
        
    }
    public Six f(){
        return new SixTest();
    }
    public Six g(){
        return new SixTest();
    }
}

三：內部類的應用：

用內部類實現java的多重繼承。

package com.qls.anonymouseInnerClass;
class D{
    
}
abstract class E{
    
}
class F extends D{
    //這是實現多重繼承的核心代碼。這里是用一個匿名內部類實現
    E makeE(){
        return new E() {
        };
    }
}
public class MultipleInherit {
    public static void takesD(D d){
        
    }
    public static void takesE(E d){
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        F d = new F();
        takesD(d);
        takesE(d.makeE());
    }

}

最后簡要介紹一下讓一個類繼承另一個類中的內部類？以及怎么讓一個類中的內部類繼承另一個類的內部類呢？

首先是：讓一個類繼承另一個類中的內部類

 代碼如下：

package com.qls.anonymouseInnerClass;

import com.qls.anonymouseInnerClass.WithInner.Inner;

class WithInner{
    class Inner{
        private int a;
        public Inner(int a) {
            this.a=a;
        }
        public Inner() {
            // TODO Auto-generated constructor stub
        }
    }
}
public class InheritInner extends Inner{
    public InheritInner(WithInner withInner) {
        // TODO Auto-generated constructor stub
        /**
         * 這句話必須要寫。否則編譯器會報錯。即：外部類的一個對象.super().
         * 這里的super()，比奧斯Inner的一個默認構造方法。
         * 如果Inner中比如有這樣一個構造方法：public Inner(int a) 
         * 你現在也可以寫成：把withInner.super();改為withInner.super(1);編譯器是不會報錯的。
         * 如果沒有默認構造方法public Inner() 則這題必須寫成：withInner.super(1);的形式。
         */
        
        withInner.super();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WithInner withInner = new WithInner();
        InheritInner inheritInner = new InheritInner(withInner);
    }

}

 讓一個類中的內部類繼承另一個類的內部類

代碼如下：

package com.qls.anonymouseInnerClass;
/**
 * 朱元璋家住鳳陽，劉伯溫家住青田
 * @author 秦林森
 *
 */
class ZhuYuanZhang{
    class FengYang{
        private String location;

        public FengYang(String location) {
            this.location = location;
        }
        
    }
}
class LiuBoWei{
    class QingTian extends ZhuYuanZhang.FengYang{
        private String location;
        public QingTian(ZhuYuanZhang zhuYuanZhang, String location) {
            zhuYuanZhang.super(location);//這句話必須要寫。或者會報錯，
            this.location=location;
        }
        public void accurate(){
            System.out.println("一統江山劉伯溫 ，家在"+location);
        }
    }
}
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new LiuBoWei().new QingTian(new ZhuYuanZhang(), "青田").accurate();
    }

}/*Output:
一統江山劉伯溫 ，家在青田*///:~