【Java】内部类

认识内部类：Java中内部类分如下三种

匿名内部类

实例内部类

静态实例内部类

匿名内部类

匿名内部类顾名思义就是在创建的时候不用赋予名字。

代码演示：

//匿名内部类
interface IA{
    void test();
}
public class Main{
    public static void main(String[] args) {
        new IA(){
            @Override
            public void test() {
                System.out.println("hallo World");
            }
        }.test();
    }
}

我们定义了一个接口 IA 接着我们在 Main 方法中实例化了该接口，但没有用引用来接收该接口，这就表示内部类，接着我们在内部类中重写了 test 方法，并且在最后调用了该方法。

运行截图：

实例内部类

我们在一个类中定义的变量和方法都叫做实例成员和实例方法，顾名思义定义在一个类中的类就被称作为实例内部类。

代码演示：

class OutClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
 
        public void test(){
            System.out.println("内部类的test方法");
        }
    }
 
    public void test(){
        System.out.println("外部类的test方法");
    }
}
 
public class Main{
    public static void main(String[] args) {
        //获取实例内部类时，要依赖外部类
        OutClass outclass = new OutClass();
        OutClass.InnerClass innerclass = outclass.new InnerClass();
        OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();
        innerclass2.test();
        innerclass.test();
    }
}

我们在 OutClass 类中定义了另外一个类 InnerClass ，在内部类中同样也可以拥有成员权限修饰符修饰的变量和方法。

既然定义了一个类，那么必然就可以实例化，这里我们实例化内部类有两种方法：

//获取实例内部类时，要依赖外部类
//第一种
OutClass outclass = new OutClass();
OutClass.InnerClass innerclass = outclass.new InnerClass();
//第二种
OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();

我们在实例化内部类的时候必须要依靠外部类，也就是说我们先要实例化外部类，再实例化内部类。

上述代码的运行截图：

 

我们可以看出两种实例化都可行。

在内部类中我们能否有 static 修饰的成员？我们在编译器中试试看

我们发现报错了，为什么呢？我们知道被 static 修饰的成员就会变得不依靠实例，但是我们在实例化内部类的时候必须要依靠外部类的实例，很明显冲突了！

但是我们可以有 final 修饰的成员。

这时就不报错了！

如果在外部类和内部类中有同名的成员，那么如何在内部类中访问外部类的成员。

class OutClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public int data1 = 6;
 
        public void test(){
            System.out.println(OutClass.this.data1);
        }
    }
 
    public void test(){
 
    }
}
 
public class Main{
    public static void main(String[] args) {
        OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();
       innerclass2.test();
    }
}

运行截图：

使用 外部类类名.this.重名成员 就可以在内部类中访问外部类的重名成员。

在外部类中是不能直接访问内部类中的成员，如果要访问就必须要实例化内部类。

代码演示：

class OutClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public int data1 = 6;
 
        public void test(){
            System.out.println(OutClass.this.data1);
        }
    }
 
    public void test(){
        InnerClass innerclass = new InnerClass();
        System.out.println(innerclass.data4);
    }
}
 
public class Main{
    public static void main(String[] args) {
        OutClass outclass = new OutClass();
        outclass.test();
    }
}

静态实例内部类

代码示例：

class OutClass{
    private int data1 = 1;
    public int data2 = 2;
    public static int data3 = 3;
 
    static class InnerClass{
        private int data4 = 4;
        public int data5 = 5;
        public static int data6 = 6;
    }
}
public class Main{
    public static void main(String[] args) {
        OutClass.InnerClass innerclass = new OutClass.InnerClass();
        System.out.println(innerclass.data5);
    }
}

运行结果：

我们在实例化静态内部类的时候就不需要依靠外部内部类的实例了，就变得方便了许多。

我们可以看到在静态内部类中定义成员变量用了 static 修饰，是的静态内部类可以用 static 修饰，因为静态内部类的实例化不依靠外部类的实例。

在静态内部类中是无法直接访问外部类的成员，并且外部类也无法直接访问静态内部类的成员，都必须借助实例化才能访问。