成员内部类、静态内部类、局部内部类、匿名内部类

内部类

• 内部类可以直接访问外部类的成员

•     public class Outer {
      int num = 10;
      class Inner {
          public void show() {
              System.out.println("num=" + num);
          }
      }
  
      public static void main(String[] args) {
          Outer.Inner inner = new Outer().new Inner();
          inner.show();
          }
      }
  

  • 运行结果

  

• 外部类访问内部类的成员，需要创建内部类的对象

  public class Outer1 {
  Inner inner = new Inner();
  
  public void show() {
      int num = inner.num = 20;
      System.out.println("num=" + num);
  }
  
  class Inner {
      int num;
  }
  
  public static void main(String[] args) {
      Outer1 outer = new Outer1();
      outer.show();
  }
  

  }

• 运行结果

  

静态内部类

• 内部类中有静态方法，那么这个内部类就是静态内部类

• 静态内部类不需要外部类对象

  public class Outer3 {
      static int num = 10;
      static class Inner {
          public static void show() {
              System.out.println("num=" + num);
          }
      }
      public static void main(String[] args) {
          Outer3.Inner inner = new Outer3.Inner();
          inner.show();
      }
  }
  

• 运行结果

  

• 静态内部类不能访问外部类的非静态属性和方法

  

  扫描二维码关注公众号，回复： 3160158 查看本文章

成员内部类

• 如何new对象

  • 外部类.内部类 对象名=new 外部类（）.new 内部类

    public class Outer {
    int num = 10;
    class Inner {
        public void show() {
            System.out.println("num=" + num);
        }
    }
    
    public static void main(String[] args) {
        //Outer.Inner inner = new Outer().new Inner();
        //相当于  Outer outer=new Outer();
        // Outer.Inner inner=outer.new Inner();
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
        }
    }
    

  • 运行结果

  

• 使用成员内部类会造成内存泄漏，内存越用越少。因为你在释放外部类对象的时候，内部类持有外部类对象的引用，GC不能回收

局部内部类

• 在外部类的方法中定义一个内部类，叫做局部内部类

  public class Outer4 {
  private String name;
  private int age;
  
  public void show() {
      class Inner {
          public void showInner(String name, int age) {
              System.out.println(name + "今年" + age + "岁");
          }
      }
      Inner inner = new Inner();
      inner.showInner("小明", 15);
  }
  
  public static void main(String[] args) {
      Outer4 outer = new Outer4();
      outer.show();
  }
  

  }

  • 运行结果

  

• 局部内部类访问方法中的变量，变量需定义成final修饰的，在内部类中访问局部变量，而定义的这个局部变量在之后还会使用，如果不定义成final修饰的，变量会随着方法的结束从栈内存中消失，就会导致局部内部类不能访问局部局部变量。

  • Inner类

    public abstract class Inner {
        public abstract void show();
    }
    

  • Outer类

    public class Outer {
        public Inner showInner(){
            final int i=10;
            Inner inner=new Inner() {
                @Override
                public void show() {
                    System.out.println("i="+i);
                }
            };
            return inner;
        }
        public static void main(String[] args) {
            Outer outer=new Outer();
            Inner inner=outer.showInner();
            inner.show();
        }
    }
    

  • 运行结果

    

匿名内部类

• 匿名内部类只使用一次

  • Animal类

    public abstract class Animal {
        public abstract void eat();
    }
    

  • 测试类

    public class Test {
    
    class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫在吃老鼠");
        }
    }
    public static void main(String[] args) {
        new Animal() {
            @Override
            public void eat() {
                System.out.println("猫在吃鱼");
            }
        }.eat();
    }
    }
    

  • 运行结果