一、内部类的概念

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在Java中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。

内部类也是封装的一种体现。

public class OutClass{

class InnerClass{

……

}

}

🍵OutClass是外部类，InnerClass是内部类

二、内部类的分类

🥑内部类分为：

1.静态内部类

2.非静态内部类/实例内部类

3.局部内部类

4.匿名内部类

1.静态内部类（被static修饰）

静态内部类当中，不能直接访问内部类的非静态成员。

通过这个代码，我们主要注意怎么实例化对象，还有如何访问外部类的非静态变量。

class Outer {
    public int a1=1;
    private int a2=2;
    static public int a3=3;
    static class Inner{
        public int a4=4;
        private int a5=5;
     public void func(){
         Outer outer=new Outer();
         System.out.println(outer.a1);//通过引用,访问外部类的非静态成员
         System.out.println(outer.a2);
         System.out.println(a3);
         System.out.println(a4);
         System.out.println(a5);
     }
    }
}
public class Test{
    public static void main(String[] args) {
        Outer.Inner inner=new Outer.Inner();//静态内部类的实例化
        inner.func();
    }
}

2.非静态内部类

class Outer {
    public int a1=1;
    private int a2=2;
    static public int a3=3;
     class Inner{
        public int a4=4;
        private int a5=5;
       public void func(){
      Outer outer=new Outer();
           System.out.println(outer.a1);
           System.out.println(outer.a2);
         System.out.println(a3);
         System.out.println(a4);
         System.out.println(a5);
     }
    }
}
public class Test{
    public static void main(String[] args) {
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.func();
    }
}

当外部类和内部类有同名变量时：

class Outer {
    public int a1=1;
     class Inner{
        public int a1=2;
       public void func(){
      Outer outer=new Outer();
           System.out.println(outer.a1);
           System.out.println(Inner.this.a1);
     }
    }
}
public class Test{
    public static void main(String[] args) {
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.func();
    }
}

输出：

注意：

class Outer {
    public int a1=1;
     class Inner{
      static final   public  int a1=2;//加上final就相当于常量。否则会报错。因为static静态类是不依赖对象的。
       public void func(){
      Outer outer=new Outer();
           System.out.println(outer.a1);
           System.out.println(Inner.this.a1);
     }
    }
}
public class Test{
    public static void main(String[] args) {
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.func();
    }
}

3.局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少。

class Outer {
    public int a=1;
    public void method(){
        int b=10;
        class Inner{
            public void func(){
                Outer outer=new Outer();
                System.out.println(a);
                System.out.println(b);
            }
    }
    Inner inner=new Inner();
        inner.func();
    }
}
public class Test{
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.method();
    }
}

🍧局部内部类不能被public,static等访问修饰限定符修饰。同时，只能在该方法体内部使用，其他位置都不能使用。

4.匿名内部类

interface  IA{
    void func();
}
class AA implements IA{
    public void func(){
        System.out.println("hello");
    }
}
public class Test{
    public static void main(String[] args) {
        new IA(){//这个类没有名字，所以叫匿名内部类
            public void func(){
                System.out.println("hi");
            }
        }.func();
    }
}

输出结果：