Java 内部类

• 成员内部类

  • 内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
  • 内部类的访问修饰符，可以任意，但是访问权限会收影响。
  • 内部类可以直接访问外部类的成员，如果出现同名属性和方法，优先访问内部类中定义的
  • 可以使用： 外部类.this.成员 这种方式访问同名的成员或者方法
  • 外部类访问内部类信息，需要通过内部类实例，否则是无法进行直接访问的
  • 内部类编译后 .class 文件名字会为： 外部类$内部类.class

  package com.bihu;
  
  public class Main {
      public static void main(String[] args) {
          // 创建内部类的三种方式
  
          // 1匿名类 + 内部类 创建
          Waibu_class.NeiBu_class neiBu_class = new Waibu_class().new NeiBu_class();
          neiBu_class.eat();
  
          // 2
          // 外部类 + 内部类
          Waibu_class wbClass = new Waibu_class();
          Waibu_class.NeiBu_class neiBu_class1 = wbClass.new NeiBu_class();
          neiBu_class1.eat();
  
          // 3 用 外部类的 get内部类方法 [如果有的话]
          Waibu_class.NeiBu_class neiBu_class2 = wbClass.getNeiBu_class();
          neiBu_class.eat();
  
      }
  }
  

  package com.bihu;
  
  /**
   * 外部类
   */
  public class Waibu_class {
  
      String temp = "外部";
  
      public void eat() {
          System.out.println(this.getClass().getSimpleName() + "我是外部类的 Eat 方法()");
      }
  
  
      //获取内部类方法 [ 编码习惯 ]
      public NeiBu_class getNeiBu_class() {
          return new NeiBu_class();
      }
  
      //    内部类
      class NeiBu_class {
  
          String temp = "内部";
  
          public void eat() {
  //            Waibu_class.this.eat(); // 可以使用： 外部类.this.成员 这种方式访问同名的成员或者方法
              System.out.println(this.getClass().getSimpleName() + "我是内部类的 Eat 方法()");
          }
      }
  
  }
  

• 静态内部类

  • 静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
  • 静态内部类对象实例时，可以不依赖于外部类对象
  • 可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
  • 当内部类属性与外部类属性同名时，默认直接调用内部类中的成员
  • 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式
  • 如果需要访问外部类中的非静态属性，则可以通过 new 外部类()属性 的方式

  package com.bihu;
  
  public class Main {
      public static void main(String[] args) {
          // 创建 静态内部类
          Waibu_class.NeiBu_class neiBu_class = new Waibu_class.NeiBu_class();
          neiBu_class.eat();
      }
  }
  

  package com.bihu;
  
  /**
   * 外部类
   */
  public class Waibu_class {
  
      String temp = "外部类 成员";
      static String static_temp = "外部类 静态成员";
  
      public static void eat() {
          System.out.println("我是外类的 静态的 Eat 方法()");
      }
  
      public void go() {
          System.out.println("我是外类的 非静态的 Go 方法()");
      }
  
      //    静态内部类
      static class NeiBu_class {
  
          String temp = "内部";
  
          public void eat() {
  
              //调用外部类的静态方法 eat | 访问成员变量也是一样的
              Waibu_class.eat();
              System.out.println(Waibu_class.static_temp);
  
              //调用外部类的非静态方法 go | 访问成员变量也是一样的
              new Waibu_class().go();
              System.out.println(new Waibu_class().temp);
  
              //打印
              System.out.println("我是静态内部类的 Eat 方法()");
          }
  
          //调用外部类的非静态方法
  //        public  void go() {
  //            new Waibu_class().go();
  //        }
      }
  
  }
  

  输出：
  
  我是外类的 静态的 Eat 方法()
  外部类 静态成员
  我是外类的 非静态的 Go 方法()
  外部类 成员
  我是静态内部类的 Eat 方法()
  

• 方法内部类

  • 定义在方法内部，作用范围也在方法内
  • 和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
  • 类中不能包含静态成员
  • 类中可以包含final、abstract 修饰的成员

  package com.bihu;
  
  public class Main {
      public static void main(String[] args) {
      // 创建方法内部类
          Waibu_class waibu_class = new Waibu_class();
          System.out.println( waibu_class.get_fun_class());
      }
  }
  

  package com.bihu;
  
  
  /**
   * 外部类
   */
  public class Waibu_class {
  
      String temp = "外部类 成员";
      static String static_temp = "外部类 静态成员";
  
      public Object get_fun_class() {
          class FunClass {
              // 是不允许存在静态的属性或变量的  否则报错
  //            static String test = "11";
               String test = "方法内部类 成员 test";
  
              public String getTest() {
                  return test;
              }
          }
          // 一般返回都会调用里面的方法，因为方法内部类的方法只有在本方法作用域有效,否则返回FunClass的对象 啥也干不了。。。
          return new FunClass().getTest();
      }
  }
  

• 匿名内部类

  • 自己百度，，，也没啥

几年前因为觉得理解很乱 用的少 就没写笔记，也么见用的着...