Java中的内部类

内部类

• 定义在其他类内部的类就被称为内部类，包含内部类的类称为外部类。

• 内部类的特点：

  • 提供更好的封装，可以将内部类封装到外部类里，不允许同一个包中的其他类访问该内部类。
  • 内部类可以直接访问外部类的成员，包括私有成员。但外部类不能直接访问内部类，需要创建对象。
  • 内部类比外部类可以多使用的三个权限修饰符：private, protected,static

• 定义内部类：

  • 成员内部类：在类中方法外（成员位置）定义的类；

    class Outer{
        class Inner{
            
        }
    }
    

  • 局部内部类：在方法里定义的内部类；

    class Outer{
       public void show(){
            class Inner{
            
        }
       }
    }
    

• 成员内部类

  • 创建成员内部类

  public class MyTest {
      public static void main(String[] args) {
          Outer outer = new Outer();
          System.out.println(outer.num);
          outer.outerShow();
          outer.method();
          System.out.println("--------------------------------");
      
          //创建成员内部类
          Outer.Inner inner=new Outer().new Inner();
          System.out.println(inner.b);
          inner.innerShow();
          inner.innerTest();
      }
  }
  
  class Outer {
      int num = 10;
      private int a = 100;
      //定义成员内部类
      class Inner {
          int b = 1000;
          public void innerShow() {
              System.out.println("内部类的show方法");
          }
          //内部类直接访问外部类的成员，包括私有
          public void innerTest(){
              System.out.println(num);
              System.out.println(a);
              outerShow();
              outerTest();
          }
  
      }
  
      public void outerShow() {
          System.out.println("外部类的show方法");
      }
  
      private void outerTest() {
          System.out.println("外部类的私有show方法");
      }
      //外部类访问内部类
      public void method(){
          //创建内部类的对象
          Inner inner = new Inner();
          System.out.println(inner.b);
          inner.innerShow();
  
      }
  }
  
  //结果：
  /*
      10
      外部类的show方法
      1000
      内部类的show方法
      --------------------------------
      1000
      内部类的show方法
      10
      100
      外部类的show方法
      外部类的私有show方法
  */
  

  • 当内部类被private修饰时，就不能在外部类以外的地方创建内部类对象了，若想在main()方法中访问内部类，则可以在外部类里提供一个访问内部类的方法：

    public class Test{
        public static void main(String[] args) {
           Outer outer = new Outer();
           outer.method();
        }
    }
    
    class Outer{
    
        private class Inner{
            public void show(){
                System.out.println("内部类的show方法");
            }
        }
        public void method(){
            Inner inner = new Inner();
            inner.show();
        }
    }
    
    //结果：
    //   内部类的show方法
    

  • 被static 修饰的内部ibu类即静态内部类（或者被称为类内部类），属于外部类本身，而不是外部类的某个对象。根据静态成员不能访问非静态成员的规则，静态内部类不可以访问外部类的非静态成员。

  • this关键字在内部类中的使用:

    class Test {
        public static void main(String[] args) {
            Outer.Inner oi = new Outer().new Inner();
            oi.show();
        }
    }
    class Outer {
        public int num = 1;
        class Inner {
            public int num = 2;
            public void show() {
                int num = 3;
                System.out.println(num); //3
                System.out.println(Inner.this.num); //2
                System.out.println(new Outer().num); //1
                System.out.println(Outer.this.num);//1
            }
        }
    }
    

• 局部内部类

  • 不能在外部类外直接创建局部内部类的对象。
  • 局部内部类访问外部类的局部变量时，该局部变量必须加上final修饰（Jdk1.8后默认加上），因为局部变量会随着方法的调用完毕而消失，而局部内部类的对象并没有从堆内存中消失，它仍旧需要使用该局部变量，为了让数据还能使用，则给局部变量前加一个final关键字，这样在内存中存储的就是一个常量值。

• 匿名内部类

  • 格式：

    new 类名或者接口名(){
    		重写方法;
    } ;
    

    • 匿名内部类就是局部内部类的简化写法，它实际上是一个继承了该类或者实现了该接口的子类匿名对象，只能使用一次。
    • 从上面可以看出，匿名内部类必须继承一个父类，或者实现一个借口。

  • 使用：

    interface Inter {
        public abstract void show();
    }
    
    class Outer{
        public static void method(){
            //匿名内部类，实际上是继承了Inter借口的子类匿名对象
            new Inter(){
                public void show(){
                    System.out.println("重写show()方法");
                }
            }.show();
    
        }
    }
    class OuterTest{
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.method();
    
        }
    }
    

    public class Demo {
        public static void main(String[] args) {
            Outer k = new Outer();
            //匿名对象作为参数传入
            k.method(new AbstractClass() {
                @Override
                public void show() {
                    System.out.println("重写show()方法");
                }
            });
        }
    }
    
    abstract class AbstractClass {
        public abstract void show();
    }
    
    class Outer {
        public void method(AbstractClass p) {
            p.show();
        }
    }