<p id="rrtt5"></p><ruby id="rrtt5"></ruby>

      系統城裝機大師 - 唯一官網:www.1999hs.com!

      當前位置:首頁 > 網絡編程 > JavaScript > 詳細頁面

      Java內部類的實現原理與可能的內存泄漏說明

      時間:2020-10-08來源:www.1999hs.com作者:電腦系統城

      在使用java內部類的時候要注意可能引起的內存泄漏

      代碼如下

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      package com.example;
      public class MyClass {
       
       public static void main(String[] args) throws Throwable {
       
       }
       
       public class A{
        public void methed1(){
       
        }
       }
       
       public static class B{
        public void methed1(){
       
        }
       }

      編譯生成了如下文件

      反編譯MyClass

      反編譯MyClassA

      反編譯GlassB

      從反編譯的結果可以知道,內部類的實現其實是通過編譯器的語法糖實現的,通過生成相應的子類即以OutClassName$InteriorClassName命名的Class文件。

      并添加構造函數,在構造函數中傳入外部類,這也是為什么內部類能使用外部類的方法與字段的原因。

      我們明白了這個也就要小心,當外部類與內部類生命周期不一致的時候很有可能發生內存泄漏,例如在一個Activity啟動一個Thread執行一個任務,因為Thread是內部類持有了Activity的引用,當Activity銷毀的時候如果Thread的任務沒有執行完成,造成Activity的引用不能釋放,Activity不能被釋放而引起了內存泄漏。

      這種情況下可以通過聲明一個static的內部類來解決問題,從反編譯中可以看出,聲明為static的類不會持有外部類的引用,如果你想使用外部類的話,可以通過軟引用的方式保存外部類的引用。

      具體的代碼就不上了。

      補充知識:Java內部類的底層實現原理

      摘要:

      定義:在一個類中創建另一個類,叫做成員內部類,這個內部類可以是靜態的,也可以是非靜態的。

      已知靜態內部類的應用(可以解決的問題):

      通過內部類解決java 的單繼承問題,外部類不能同時繼承的類可以交給內部類繼承

      設計模式中,builder 模式通過定義一個靜態內部類實現

      類型匯總:

      靜態內部類

      成員內部類

      方法內部類

      匿名內部類

      一、靜態內部類

      靜態內部類的定義和普通的靜態變量或者靜態方法的定義方法是一樣的,使用static關鍵字,只不過這次static是修飾在class上的,一般而言,只有靜態內部類才允許使用static關鍵字修飾,普通類的定義是不能用static關鍵字修飾的,這一點需要注意一下。下面定義一個靜態內部類:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class Out {
       private static String name;
       private int age;
        
       public static class In{
        private int age;
        public void sayHello(){
          
         System.out.println("my name is : "+name);
         //--編譯報錯---
         //System.out.println("my age is :"+ age);
        }
       }
      }

      在上述代碼中,In這個類就是一個靜態內部類。我們說內部類是可以訪問外部類的私有字段和私有方法的,對于靜態內部類,它遵循一致的原則,只能訪問外部類的靜態成員。上述代碼中,外部類的非靜態私有字段age在靜態內部類中使不允許訪問的,而靜態字段name則是可訪問的。下面我們看,如何創建一個靜態內部類的實例對象。

      ?
      1
      2
      3
      4
      public static void main(String [] args){
       Out.In innerClass = new Out.In();
       innerClass.sayHello();
      }

      靜態內部類的實例對象創建還是比較簡潔的,不同于成員內部類,它不需要關聯外部類實例(具體的下文介紹),下面我們再看一段代碼:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class Out {
       private static String name;
        
       public static class In{
        public void sayHello(){
         System.out.println(name);
         showName();
        }
       }
        
       private static void showName(){
        System.out.println(name);
       }
      }

      上述代碼在內部類中兩次訪問了外部類的靜態成員,第一次訪問了靜態字段name,第二次訪問的靜態方法showName。在我們反編譯這個類之前,首先需要知道的是,所謂的內部類的概念只是出現在編譯階段,對于jvm層是沒有內部類這個概念的。也就是說,編譯器會將一個類編譯成一個源文件,對于內部類也是一樣,它會從它的外部類中抽離出來,增加一些與外部類的聯系,然后被編譯成一個單獨的源文件。下面我們先編譯運行之后,利用Dj反編譯class文件看看編譯器都做了些什么事情。

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      //這是我們的Out外部類
      public class Out
      {
       //省去了一些不重要的部分
       private static void showName()
       {
        System.out.println(name);
       }
        
       private static String name;
        
       static String access$000(){return name;}
       static void access$100(){showName();}
        
      }
      //這是我們的內部類
      public static class Out$In
      {
        
       public void sayHello()
       {
        System.out.println(Out.access$000());
        Out.access$100();
       }
        
       public Out$In()
       {
       }
      }

      相信大家也已經看出來這兩者之間的某種聯系,編譯器將Out這個類編譯成兩個獨立的class源文件。對于Out中所有的私有成員(也就是內部類分離出去之后不能訪問的成員),增設了可供調用的access$xxx方法,從而實現內部類與外部類之間的聯系。這就是他們的本質。

      至于使用場景,一般來說,對于和外部類聯系緊密但是并不依賴于外部類實例的情況下,可以考慮定義成靜態內部類。下面我們看稍顯復雜的成員內部類。

      二、成員內部類

      我們說了,四種不同類型的內部類都各自有各自的使用場景,靜態內部類適合于那種和外部類關系密切但是并不依賴外部類實例的情況。但是對于需要和外部類實例相關聯的情況下,可以選擇將內部類定義成成員內部類。以下代碼定義了一個簡單的成員內部類:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class Out {
       private String name;
        
       public void showName(){
        System.out.println("my name is : "+name);
       }
        
       public class In{
        public void sayHello(){
         System.out.println(name);
         Out.this.showName();
        }
       }
      }

      以上定義了一個簡單的內部類In,我們的成員內部類可以直接訪問外部類的成員字段和成員方法,因為它是關聯著一個外部類實例的。下面我們看看在外部是如何創建該內部類實例的。

      ?
      1
      2
      3
      4
      5
      public static void main(String [] args){
       Out out = new Out();
       Out.In in = out.new In();
       in.sayHello();
      }

      因為成員內部類是關聯著一個具體的外部類實例的,所以它的實例創建必然是由外部類實例來創建的。對于實例的創建,我們只需要記住即可,成員內部類的實例創建需要關聯外部類實例對象,靜態內部類實例創建相對簡單。下面我們主要看看在編譯階段編譯器是如何保持內部類對外部類成員信息可訪問的。

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      //反編譯的Out外部類源碼
      public class Out
      {
       //省略部分非核心代碼
       public void showName()
       {
        System.out.println((new StringBuilder()).append("my name is : ").append(name).toString());
       }
        
       private String name;
        
       static String access$000(Out o){return o.name;}
      }
      //反編譯的內部類In源碼
      public class Out$In
      {
       public void sayHello()
       {
        System.out.println(Out.access$000(Out.this));
        showName();
       }
        
       final Out this$0;
        
       public Out$In()
       {
        this.this$0 = Out.this;
        super();
       }
      }

      由上述代碼其實我們可以知道,當我們利用外部類實例創建內部類實例的時候,會將外部類實例作為初始資源傳入內部類構造過程。這樣我們就可以通過該實例訪問外部類所有的成員信息,包括私有成員。(顯式增加了暴露方法)

      至于使用場景,對于那種要高度依賴外部類實例的情況下,定義一個成員內部類則會顯的更加明智。

      三、方法內部類

      方法內部類,顧名思義,定義在一個方法內部的類。方法內部類相對而言要復雜一些,下面定義一個方法內部類:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class Out {
       private String name;
        
       public void sayHello(){
        class In{
         public void showName(){
          System.out.println("my name is : "+name);
         }
        }
        
        In in = new In();
        in.showName();
       }
      }

      我們定義了一個類,在該類中又定義了一個方法sayHello,然而在該方法中我們定義了一個內部類,類In就是一個方法內部類。我們的方法內部類的生命周期不超過包含它的方法的生命周期,也就是說,方法內部類只能在方法中使用。所以在聲明的時候,任何的訪問修飾符都是沒有意義的,于是Java干脆不允許使用任何的訪問修飾符修飾方法內部類。其中還需要注意一點的是,定義和使用時兩回事,別看那一大串定義類的代碼,你實際想要使用該類,就必須new對象,而對于方法內部類而言,只能在方法內部new對象。這就是方法內部類的簡單介紹,下面我們看看其實現原理。

      有關方法內部類的實現原理其實是和成員內部類差不太多的,也是在內部類初始化的時候為其傳入一個外部類實例,區別在哪呢?就在于方法內部類是定義在具體方法的內部的,所以該類除了可以通過傳入的外部實例訪問外部類中的字段和方法,對于包含它的方法中被傳入的參數也會隨著外部類實例一起初始化給內部類。

      毋庸置疑的是,方法內部類的封裝性比之前介紹的兩種都要完善。所以一般只有在需要高度封裝的時候才會將類定義成方法內部類。

      四、匿名內部類

      可能內部類的所有分類中,匿名內部類的名號是最大的,也是我們最常用到的,多見于函數式編程,lambda表達式等。下面我們重點看看這個匿名內部類。

      匿名內部類就是沒有名字的內部類,在定義完成同時,實例也創建好了,常常和new關鍵字緊密結合。當然,它也不局限于類,也可以是接口 ,可以出現在任何位置。下面我們定義一個匿名內部類:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      //首先定義一個普通類
      public class Out {
       private String name;
        
       private void sayHello(){
        System.out.println("my name is :" + name);
       }
      }
      //定義和使用一個匿名內部類
      public static void main(String [] args){
       Out out = new Out(){
        @Override
        public void sayHello(){
         System.out.println("my name is cyy");
        }
        public void showName(){
         System.out.println("hello single");
        }
       };
       out.sayHello();
      }

      從上述代碼中可以很顯然的讓我們看出來,我們的匿名內部類必定是要依托一個父類的,因為它是沒有名字的,無法用一個具體的類型來表示。所以匿名內部類往往都是通過繼承一個父類,重寫或者重新聲明一些成員來實現一個匿名內部類的定義。實際上還是利用了里式轉換原理。

      從中我們也可以看到,一個匿名內部類定義的完成就意味著該內部類實例創建的完成。下面我們看看其實現原理:

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      //反編譯出來的匿名內部類
      static class Test$1 extends Out
      {
       Out out;
       public void sayHello()
       {
        System.out.println("my name is cyy");
       }
        
       Test$1(Out o)
       {
        this.out = o;
       }
      }

      其實在看了上述三種內部類的原理之后,反而覺得匿名內部類的實現較為簡單了。主要思路還是將內部類抽離出來,通過初始化傳入外部類的實例以達到對外部類所有成員的訪問。只是在匿名內部類中,被依托的父類不是他的外部類。匿名內部類的主要特點在于,沒有名字,對象只能被使用一次,可以出現在任意位置。所以它的使用場景也是呼之欲出,對于一些對代碼簡潔度有所要求的情況下,可首選匿名內部類。

      以上完成了對四種內部類的簡單介紹,對于他們各自實現的原理也都已經介紹過了。其實大致相同,由于jvm對每個類都要求一個單獨的源碼文件,所以編譯階段就完成了分離的操作,但是在分離的過程中又要保持內部類和外部類之間的這種聯系,于是編譯器添加了一些接口保持這種信息共享的結構。使用內部類可以大大增加程序的封裝性,使得代碼整體簡潔度較高。

      分享到:

      相關信息

      系統教程欄目

      欄目熱門教程

      人氣教程排行

      站長推薦

      熱門系統下載

      天堂资源中文WWW,久久精品女人天堂AV免费观看,无码专区一ⅤA亚洲V天堂,免费观看在线AⅤ天堂视频