分享一下我学到的四种Java当中的内部类;

首先，在Java中有四种内部类：

1.静态内部类     2.实例内部类    3.匿名内部类    4.局部内部类

一、静态内部类

1.静态内部类的相关语法

场景：

class OutIA{

     public int data1 = 1;
     private int data2 = 2;
     public static int data3 = 3;

     static class InnerIB{
         public int data4 = 4;
         private int data5 = 5;
         public static int data6 = 6;

         public void test(){
             System.out.println("test方法执行了。。。");
         }
     }
}

可以看到，这个由 static 修饰的类中类 InnerIB 就是静态内部类，和普通类一样，可以有自己的成员变量和方法等。

2.静态内部类在main方法中如果实例化一个对象

public class Test {
    public static void main(String[] args) {
      OutIA.InnerIA innerIA = new OutIA.InnerIA();
    }
}

这样我们就成功实例化了一个对象

3.注意事项

static class InnerIA{
 /*   data1 =10;
    data2=20;*/
    
    public int data4 = 4;
    private int data5 = 5;
    public static int data6 = 6;
    

    public void test(){
        System.out.println("test方法执行了。。。");
        System.out.println(data3);
    }
}

我们发现，静态内部类中无法访问data1和data2，但可以访问静态变量data3，由此我们引出静态内部类的第一个概念：静态内部类当中不能直接访问外部类的非静态成员，所以我们的data3是可以访问的，那如果我们一定要访问这些外部类当中的非静态成员呢？我们可以在内部类中用外部类来实例化对象，通过这个引用来访问外部类的成员：

OutIA outIA = new OutIA();
public void test(){
    System.out.println("test方法执行了。。。");
    System.out.println(data3);
    System.out.println(outIA.data1+" "+ outIA.data2);
}

二、实例内部类

1.实例内部类的相关语法

场景：

class OutIB{
    public int d1 = 1;
    private int d2 =2;
    public static int d3 = 3;

    class InnerIB{

    }
}

跟静态内部类一样，实例内部类同样可以有自己的成员变量和方法，不同于静态内部类，实例内部类中可以访问外部类的全部成员，这里不做过多描述

2.实例内部类如何在main方法中实例化一个对象

public class Test {
    public static void main(String[] args) {
     OutIB outIB = new OutIB();
     OutIB.InnerIB innerIB = outIB.new InnerIB();
    }
}

这样我们就创造出了一个实例化对象，我们可以通过这个引用访问其内部内容，就和普通类一样。

3.注意事项

当实例内部类和外部类中同时出现了重复变量时，调用实例内部类中的方法访问这个重复变量时，会优先访问内部类的

class OutIB{
    public int d1 = 1;
    private int d2 =2;
    public static int d3 = 3;

    class InnerIB{
    public int d1 = 10;
    public void test(){
        System.out.println(d1);
        System.out.println(d2);
        System.out.println(d3);
    }
    }
}
public class Test {
    public static void main(String[] args) {
     OutIB outIB = new OutIB();
     OutIB.InnerIB innerIB = outIB.new InnerIB();
        innerIB.test();
    }
}

看，我们在创建完对象后，通过引用调用内部类中的test方法，访问d1发现输出的是10而不是1，我们调用到了内部类的d1，那我们如果实在想通过这个内部了的引用访问外部类的d1怎么办呢？

同样的，我们可以在内部类中实例化一个外部类对象，通过引用来访问外部类的东西

public void test(){
    OutIB outIB = new OutIB();
    System.out.println(outIB.d1);
    System.out.println(d1);
    System.out.println(d2);
    System.out.println(d3);
}

这样我们就可以访问外部类的d1了。

三、局部内部类--一个存在于类中的方法

场景：

public class Test {
    public static void test(){
        System.out.println("test方法被执行");
        class InnerC{
            public void test2(){
                System.out.println("test2方法被执行");
            }
        }
        InnerC innerC = new InnerC();
        innerC.test2();
    }
    public static void main(String[] args) {
      test();
    }
}

注意：只能这么调用内部类中的方法，也就是在方法内，内部类外，实例化一个对象，并调用类中方法，局部内部类很少用，也没什么人会往方法里写类，所以不做过多讨论。

四、匿名内部类

匿名内部类，就是没有类名的内部类，属于Java的局部内部类，定义在方法或代码块中，定义的同时必须实例化，且只能使用一次

场景：

class Out{
    public void test(){
        System.out.println("haha");
    }
}

public class Test {
    public static void main(String[] args) {
        new Out(){
            
        }.test();
    }
}

这样我们就可以调用类中方法，那如果在new Out（）{}的花括号中重写test方法呢？

public void test(){
    System.out.println("lalala");
}
   }.test();

我们发现，此时输出是lalala，也就是眼前这个重写方法的内容，此时发生动态绑定。