Java内部类

内部类

在Java中， 可以将一个类定义到一个类中，其中，前者就被称为内部类，后者为外部类。
内部类又可分为实例内部类，静态内部类，局部内部类，匿名内部类

一、 实例内部类

实例内部类指的是无static修饰的类，如下：

class OuterClass{
    //外部类
    
    public int data1 = 1;
    private int date2 = 2;
    public static int data3 = 3;

    class InnerClass{
        //实例内部类
        
        public int data4 = 4;
        private int data5 = 5; 
        public static final int data6 = 6;
        //实例内部类中不可以定义static
        //需要用final，来表示这是一个常量
        
        public void fun() {
            //实例内部类方法

            System.out.println(data1);
            System.out.println(date2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            
            //可以直接访问数据
        }
    }
}

public class Instance {

    public static void main(String[] args) {
        
        //实例内部类的创建
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();

    }
}

依据代码我们可以知道：

1. 实力内部类中不可以直接用static修饰成员变量，如果一定要用，需要用final来表示该变量是常量。
2. 实例内部类中可以直接访问外部类的成员变量
3. 创建实例内部类对象时，需要先实例化外部类，再按照以下方式创建：
   外部类名.内部类名 内部类对象名 = 外部类对象.new 内部类名();

二、静态内部类

静态内部类指的是被static修饰的内部类，如下

class OuterClass{
    //外部类

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

    static class InnerClass{
        //静态内部类

        public int data4 = 4;
        private int data5 = 5;

        private static int data6 = 6;

        public void innerFun() {
            //静态内部类方法
            
            OuterClass outerClass = new OuterClass();

            System.out.println(outerClass.data1);
            System.out.println(outerClass.date2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public void outerFun() {
        //外部类方法
        
        InnerClass innerClass = new InnerClass();
        
        System.out.println(data1);
        System.out.println(date2);
        System.out.println(data3);
        System.out.println(innerClass.data4);
        System.out.println(innerClass.data5);
        System.out.println(innerClass.data6);
    }
}

public class Instance {

    public static void main(String[] args) {
        //实例化静态内部类
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
    }
}

由代码可知：

1. 静态内部类只能直接访问外部类的静态成员变量，若要访问其他变量， 需要通过外部类对象调用。
2. 静态内部类可以创建静态成员变量。
3. 外部类不可以直接访问静态内部类，需要先创建静态内部类对象，通过对象调用
4. 创建静态内部类：
   ==外部类.静态内部类 对象名 = new 外部类.静态内部类(); ==

三、局部内部类

局部内部类是定义在方法内部的类，不可被static，public等修饰词修饰，且该内部类只能在方法内部使用，如下，

public class Test {
    public static void fun(){
        int data1 = 1;

        class Local{
            //局部内部类

            public int data2 = 2;
            private int data3 = 3;
        }

        Local local = new Local();

        System.out.println(local.data2);
        System.out.println(local.data3);
    }
}

四、匿名内部类

匿名内部类指的是没有名字的内部类，通常出现在当一个接口/类的方法的实现在程序中只会出现一次，使用匿名内部类可以简化代码，无需创建新的类，如下，

interface IA{
    void func();
}
public class InnerClass {

    public static void main(String[] args) {

        //匿名内部类
        new IA(){
            public void func() {
                System.out.println("这里使用了匿名内部类");
            }
        }.func();
    }
}