如何在java中使用內部類

本篇文章給大家分享的是有關如何在java中使用內部類，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

概念

內部類：可以包含在另外一個類中的類

外部類：包含內部類的類

每個內部類都會被編譯為一個獨立的類，生成一個獨立的字節碼文件。

內部類可以方便地訪問外部類的私有變量，內部類也可以聲明為private從而實現對外完全隱藏。

分類

java中的四種內部類（根據定義的位置和方式劃分）

• -靜態內部類

• -成員內部類

• -方法內部類

• -匿名內部類

分類介紹

-靜態內部類

特征：在類的內部中存在另一個類，且該類被static修飾

使用范圍：在外部類內，可以直接使用內部類，在外部類范圍以外使用外部類名.靜態內部類名的方式使用內部類

public class StaticOuter {
    private static int shared = 100;
    public static class StaticInner{
        public void staticInnerMethod() {
            System.out.println("Static Inner Method" + shared);
        }
    }
    StaticInner si1 = new StaticInner();
    public void test() {
        StaticInner si = new StaticInner();
        si.staticInnerMethod();
    }
    public static void main(String[] args) {
        StaticOuter so = new StaticOuter();
        so.test();
    //在外部類范圍內
        StaticInner si1 = new StaticInner();
        si1.staticInnerMethod();
    //合法
    StaticOuter.StaticInner si2 = new StaticOuter.StaticInner();
        si2.staticInnerMethod();
    }
}
//在外部類范圍外
class Test{
    StaticOuter.StaticInner si2 = new StaticOuter.StaticInner();
}

訪問范圍

• 靜態內部類只能訪問外部類中的static變量和方法。

• 靜態內部類也可以訪問外部類中的private變量。

• 靜態內部類中可以定義靜態變量和靜態方法。

-成員內部類

語法:成員內部類作為外部類的一個成員存在

使用方法：

如何新建一個內部類的實例：不能直接使用外部類.內部類的方式，每個成員內部類對象對應一個外部類實例，因此需要先創建一個外部類實例，然后才能生成內部類的實例（如下面代碼）

訪問范圍：

成員內部類可以訪問外部類中的靜態變量和方法，也可以訪問實例變量和方法。但是書寫格式有兩種：

（1）直接訪問；

（2）外部類.this.xxx，主要針對外部類和內部類的出現變量重名或者方法重名的情況。

成員內部類也可以訪問外部類的私有變量

成員內部類中不可以定義靜態變量和靜態方法（final變量例外，它等同于常量），在后面的方法內部類和匿名內部類中也是不能存在靜態的變量和方法的，這是因為靜態變量和靜態方法作為類型的屬性和方法，一般是獨立使用的，而成員內部類和一個對一個的外部類實例關聯，一般不會獨立使用，所以這樣的使用意義不大。（這算是一種規定吧）。

public class OriginalClass {
    private static int t1 = 100;
    private int t2 = 200;
    class OriginalInner{
        public void test() {
      /*
           * 不合法的表示，在成員內部類中不可以定義靜態的變量和方法
          public static int inner = 100;
          public static void print() {
          }
          */
          //合法的final變量
          public static final int inner1 = 300;
            System.out.println("OriginalInner:"+ t1);//直接訪問外部類靜態變量
            System.out.println("OriginalInner:"+ t2);//直接訪問外部類成員變量
            action();//直接訪問外部類方法
            System.out.println("OriginalInner:"+ OriginalClass.this.t1);//
            System.out.println("OriginalInner:"+ OriginalClass.this.t2);
            OriginalClass.this.action();
        }
    }
    public void action() {
        System.out.println("originalinner action");
    }
    public static void main(String[] args) {
    //new一個內部類
        OriginalClass oc = new OriginalClass();
        OriginalInner oi = oc.new OriginalInner();
        oi.test();
    }
}

-方法內部類

語法：存在于方法體內部的類

使用范圍：方法內部類只能在定義的方法內被使用

訪問范圍：

如果包含內部類的方法是實例方法，那么可以訪問外部類的靜態變量和方法，也可以訪問實例變量和方法；

如果包含內部類的方法是靜態方法，那么只能訪問外部類的靜態變量和方法。

方法內部類還可以直接訪問方法的參數和方法中的局部變量，但是這些變量必須聲明為final。為什么需要聲明為final呢？這是因為方法內部類操作的并不是外部的變量，而是它自己的實例變量，只是這些變量的值和外部一樣，對這些變量賦值，并不會改變外部的值，為避免混淆，所以干脆強制規定必須聲明為final。

我們知道被final修飾的基本類型變量的值是不能被修改的，被final修飾的數組或者引用類型變量的引用是不能修改的，即只能指向一個對象或者是數組，但是我們可以修改對象中的成員變量值或者是數組中元素的值。

其實使用final來修飾參數以及局部變量的目的還是保證方法內部類外面的元素不會在方法內部類中被修改，相當于限制一個作用域的功能，保證方法內部類內部的的修改不會影響方法內部類外面的同名變量值。

public class FunctionOuter {
    private static int s= 100;
    private int s1 = 20;
    public void print(final int param) {
        final int in = 300;
        class FunctionInner{
            public void innertest() {
                System.out.println("FunctionInner：s="+s);
                System.out.println("FunctionInner：s1="+s1);
                System.out.println("FunctionInner：in"+ in);
                test();
            }
        }
        FunctionInner fi = new FunctionInner();
        fi.innertest();
        System.out.println("print:in"+in);
    }
    public void test() {
        System.out.println("FunctionOuter："+s);
    }
    public static void main(String[] args) {
        FunctionOuter fo = new FunctionOuter();
        fo.print(900);
    }
}

-匿名內部類

語法：匿名內部類沒有單獨的類定義，它在創建對象的同時定義類

new 父類(參數列表){
  //匿名內部類實現部分
}

new 父接口(){
  //匿名內部類實現部分
}

匿名內部類只能使用一次，用來創建一個對象。沒有名字，沒有構造方法，但是可以根據參數列表，調用對應的父類構造方法。

在匿名內部類中可以定義實例變量和方法，以及初始化代碼塊，初始化代碼塊可以起到構造方法的作用，只是構造方法可以有多個，但是初始化代碼塊只能有一塊，因為沒有構造方法，它自己無法接受參數，如果必須要參數，則應該是用其他內部類。

以上就是如何在java中使用內部類，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。