Java中內部類的原理是什么

本篇文章為大家展示了Java中內部類的原理是什么，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

Java可以用來干什么

Java主要應用于：1. web開發；2. Android開發；3. 客戶端開發；4. 網頁開發；5. 企業級應用開發；6. Java大數據開發；7.游戲開發等。

內部類的概述

/*
  內部類概述:
    把類定義在其他類的內部，這個類就被稱為內部類。
    舉例：在類A中定義了一個類B，類B就是內部類。
  內部的訪問特點：
    A:內部類可以直接訪問外部類的成員，包括私有。
    B:外部類要訪問內部類的成員，必須創建對象。
*/
class Outer {
  private int num = 10;
  class Inner {
    public void show() {
      //內部類可以直接訪問外部類的成員，包括私有。
      System.out.println(num);
    }
  }
  public void method() {
    //找不到符號
    //show();
    //外部類要訪問內部類的成員，必須創建對象。
    Inner i = new Inner();
    i.show();
  }
}
class InnerClassDemo {
  public static void main(String[] args) {
  }
}

內部類位置

/*
  內部類位置
    成員位置:在成員位置定義的類，被稱為成員內部類。
    局部位置:在局部位置定義的類，被稱為局部內部類。
  成員位置:在成員位置定義的類，被稱為成員內部類。
*/
class Outer {
  private int num = 10;
  //成員位置
  /*
  class Inner {
  }
  */
  public void method() {
    //局部位置
    class Inner {
    }
  }
}
class InnerClassDemo2 {
  public static void main(String[] args) {
  }
}

如何直接訪問成員內部類的成員

/*
  成員內部類:
    如何直接訪問內部類的成員。
    外部類名.內部類名 對象名 = 外部類對象.內部類對象;
*/
class Outer {
  private int num = 10;
  class Inner {
    public void show() {
      System.out.println(num);
    }
  }
}
class InnerClassDemo3 {
  public static void main(String[] args) {
    //需求：我要訪問Inner類的show()方法
    //格式：外部類名.內部類名 對象名 = 外部類對象.內部類對象;
    Outer.Inner oi = new Outer().new Inner();
    oi.show();
  }
}

成員內部類的修飾符：

/*
  成員內部類的修飾符：
    private 為了保證數據的安全性
    static 為了方便訪問數據
      注意：靜態內部類訪問的外部類數據必須用靜態修飾。
  案例：我有一個人(人有身體，身體內有心臟。)
    class Body {
      private class Heart {
        public void operator() {
          System.out.println("心臟搭橋");
        }
      }
      public void method() {
        if(如果你是外科醫生) {
          Heart h = new Heart();
          h.operator();
        }
      }
    }
    按照我們剛才的講解，來使用一下
    Body.Heart bh = new Body().new Heart();
    bh.operator();
    //加了private后，就不能被訪問了，那么，怎么玩呢?
    Body b = new Body();
    b.method();
*/
class Outer {
  private int num = 10;
  private static int num2 = 100;
  //內部類用靜態修飾是因為內部類可以看出是外部類的成員
  public static class Inner {
    public void show() {
      //System.out.println(num);
      System.out.println(num2);
    }
    public static void show2() {
      //System.out.println(num);//報錯。靜態內部類訪問的外部類數據必須用靜態修飾。
      System.out.println(num2);
    }
  }
}
class InnerClassDemo4 {
  public static void main(String[] args) {
    //使用內部類
    // 限定的新靜態類
    //Outer.Inner oi = new Outer().new Inner();//這個訪問方式錯誤
    //oi.show();
    //oi.show2();
    //成員內部類被靜態修飾后的訪問方式是:
    //格式：外部類名.內部類名 對象名 = new 外部類名.內部類名();
    Outer.Inner oi = new Outer.Inner();
    oi.show();
    oi.show2();
    //show2()的另一種調用方式。因為靜態方法，可以通過類名調用。
    Outer.Inner.show2();
  }
}

內部類和外部類沒有繼承關系。

通過外部類名限定this對象

/*
  案例：
    要求請填空分別輸出30，20，10。
  注意：
    1:內部類和外部類沒有繼承關系。
    2:通過外部類名限定this對象
      Outer.this
*/
class Outer {
  public int num = 10;
  class Inner {
    public int num = 20;
    public void show() {
      int num = 30;
      System.out.println(num);
      System.out.println(this.num);
      //System.out.println(new Outer().num);
      System.out.println(Outer.this.num);
    }
  }
}
class InnerClassTest {
  public static void main(String[] args) {
    Outer.Inner oi = new Outer().new Inner();
    oi.show();
  }
}

局部位置的內部類訪問局部變量問題

/*
  局部內部類
    A:可以直接訪問外部類的成員
    B:在局部位置，可以創建內部類對象，通過對象調用內部類方法，來使用局部內部類功能
  注意事項：
    局部內部類訪問局部變量的注意事項?
    A:局部內部類訪問局部變量必須用final修飾
    B:為什么呢?
      局部變量是隨著方法的調用而調用，隨著調用完畢而消失。
      而堆內存Inner的內容并不會立即消失。所以，我們加final修飾。
      加入final修飾后，這個變量就成了常量。既然是常量。你消失了。
      我在內存中存儲的是數據20，所以，我還是有數據在使用。
*/
class Outer {
  private int num = 10;
  public void method() {
    //int num2 = 20;
    final int num2 = 20; //局部內部類訪問局部變量必須用final修飾
    class Inner {
      public void show() {
        System.out.println(num);
        //從內部類中訪問本地變量num2; 需要被聲明為最終類型
        System.out.println(num2);//20
      }
    }
    //System.out.println(num2);
    Inner i = new Inner();
    i.show();
  }
}
class InnerClassDemo5 {
  public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
  }
}

匿名內部類格式，方法調用

/*
  匿名內部類
    就是內部類的簡化寫法。
  前提：存在一個類或者接口
    這里的類可以是具體類也可以是抽象類。
  格式：
    new 類名或者接口名(){
      重寫方法;
    }
  本質是什么呢?
    是一個繼承了該類或者實現了該接口的子類的匿名對象。
*/
interface Inter {
  public abstract void show();
  public abstract void show2();
}
class Outer {
  public void method() {
    Inter i = new Inter() { //多態
      public void show() {
        System.out.println("show");
      }
      public void show2() {
        System.out.println("show2");
      }
    };
    i.show();//是一個繼承了該類或者實現了該接口的子類的匿名對象。所以可以調用方法
    i.show2();
  }
}
class InnerClassDemo6 {
  public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
  }
}

匿名內部類在開發中的使用

/*
  匿名內部類在開發中的使用
*/
interface Person {
  public abstract void study();
}
class PersonDemo {
  //接口名作為形式參數
  //其實這里需要的不是接口，而是該接口的實現類的對象
  public void method(Person p) {
    p.study();
  }
}
//實現類
class Student implements Person {
  public void study() {
    System.out.println("好好學習,天天向上");
  }
}
class InnerClassTest2 {
  public static void main(String[] args) {
    //測試
    PersonDemo pd = new PersonDemo();
    Person p = new Student();
    pd.method(p);
    System.out.println("--------------------");
    //匿名內部類在開發中的使用
    //匿名內部類的本質是繼承類或者實現了接口的子類匿名對象
    //用完一次就消失
    Person ss = new Person(){
      public void study() {
        System.out.println("好好學習,天天向上");
      }
    };
    pd.method(ss);
    // pd.method(new Person(){
      // public void study() {
        // System.out.println("好好學習,天天向上");
      // }
    // });
  }
}

案例

/*
  案例：
    按照要求，補齊代碼
      interface Inter { void show(); }
      class Outer { //補齊代碼 }
      class OuterDemo {
        public static void main(String[] args) {
           Outer.method().show();
         }
      }
      要求在控制臺輸出”HelloWorld”
*/
interface Inter {
  void show();
  //記得默認有 public abstract
}
class Outer {
  //補齊代碼
  public static Inter method() {
    //子類對象 -- 子類匿名對象
    return new Inter() {
      public void show() {
        System.out.println("HelloWorld");
      }
    };
  }
}
class OuterDemo {
  public static void main(String[] args) {
    Outer.method().show();
    /*
      1:Outer.method()可以看出method()應該是Outer中的一個靜態方法。
      2:Outer.method().show()可以看出method()方法的返回值是一個對象。
        又由于接口Inter中有一個show()方法,所以我認為method()方法的返回值類型是一個接口。
    */
  }
}

上述內容就是Java中內部類的原理是什么，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。