一文搞懂内部类

内部类分为：本地内部类，实例内部类，静态内部类，匿名内部类。

1.本地内部类

其中，本地内部类用的最少，也不建议用。因为局限很大。例如

public class Test {
    public void func(){
        class  count{
            public int a;
        }
        // 内部类只能在当前方法使用
    }
}

        内部类count只能在func()函数中使用，这就限制了这个类的使用，所以很少使用，这个类就是本地内部类。

2.实例内部类

例如：

class OuterClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //实例内部类，你可以把它当作 是外部类的普通的实例的成员
    public class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        //public static int data6 = 6;//一个东西是静态的话就是属于类的，不属于对象
        public static final int data6 = 6;
 
        public InnerClass(){
            System.out.println("不带参数的实例内部类的构造方法");
        }
    }
    public void func1(){
        System.out.println("OuterClass :: func1()");
 
        static int data7 = 7;
    }
 
}

        其中，以上代码public class InnerClass{}就是实例内部类。可以看出，可以在类中定义静态（static）的变量，但不能在实例内部类中定义静态（static）的成员变量，非要定义的话，就是得定义常量（final），同样也可以在实例内部类定义构造方法，例如 public InnerClass()。     

  再观察如下代码

class OuterClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //实例内部类，你可以把它当作 是外部类的普通的实例的成员
    public class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        //public static int data6 = 6;//一个东西是静态的话就是属于类的，不属于对象
        public static final int data6 = 6;
 
        public InnerClass(){
            System.out.println("不带参数的实例内部类的构造方法");
        }
    }
    public void func1(){
        System.out.println("OuterClass :: func1()");
 
        static int data7 = 7;
    }
 
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass  innerClass = outerClass.new InnerClass();
    }
 
}

        可以看出，实例化实例内部类的对象，把内部类当作普通的成员变量就行。

        再看以下代码：

class InnerClass{
    class Inner1{
        public int a = 10;
        class Inner2{
            public int a = 10;
        }
 
    }
}

        以上代码可以看出，实例内部类可以多次嵌套。

打开project文件的out->production

可以看出，内部类的文件名称为OuterClass$InnerClass

        如果内部类中的成员变量与外部类的成员变量同名，那么在内部类的方法中调用这个名称的变量，输出的是哪一个呢？

class OuterClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //实例内部类，你可以把它当作 是外部类的普通的实例的成员
    public class InnerClass{
        public int data1 = 20;
        public int data4 = 4;
        private int data5 = 5;
        //public static int data6 = 6;//一个东西是静态的话就是属于类的，不属于对象
        public static final int data6 = 6;
 
        public void test(){
            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
 
        }
        
        public InnerClass(){
            System.out.println("不带参数的实例内部类的构造方法");
        }
    }
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass  innerClass = outerClass.new InnerClass();
        innerClass.test();
    }
 
}

外部类OuterClass中data1 = 1，内部类InnerClass中data1 = 20，主函数中调用test()方法，输出为

即就是此时的data1是内部类中的，那么如何调用外部类的data1呢？ 

可以用：外部类.this.该变量     就可以了

即就是：System.out.println(OuterClass.this.data1);

总结

1.实例内部类本质上也是类，它有类的种种特性，如可以继承，

2.在实例内部类中，不能定义一个静态的成员变量。非要定义，就要定义常量

3.实例化 实例内部类的对象：OuterClass.InnerClass  innerClass = outerClass.new InnerClass();即就是：外部类名.内部类名  变量 = 外部类对象的引用.new  内部类()

4.实例内部类中的"this":单独的"this"表示内部类，"外部类名.this"表示外部类。

3.静态内部类

class OuterClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
 
    static class InnerClass2{
        public int data4 = 1;
        private int data5 = 2;
        public static int data6 = 3;
    }
}

其中InnerClass2就是静态内部类，它与实例内部类区别就是，静态内部类前面有static。

实例化静态内部类

class OuterClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
 
    static class InnerClass{
        public int data4 = 1;
        private int data5 = 2;
        public static int data6 = 3;
 
        public void test(){
            System.out.println("没有参数的构造方法");
        }
    }
}
public class TestDome2 {
    public static void main(String[] args) {
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.test();
    }
}

        即就是：  外部类名.内部类   变量名 = new 外部类名.内部类()     

        观察test()方法，data1与data2的调用，需要在方法外实例一个out变量，才能调用外部类中的对象。

class OuterClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
 
    static class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;
 
        public OuterClass2 out = new OuterClass2();
 
        public void test(){
            System.out.println(out.data1);
            System.out.println(out.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println("没有参数的构造方法");
        }
    }
}
public class TestDome2 {
    public static void main(String[] args) {
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.test();
    }
}

4.匿名内部类

例如

class Test{
    public void func(){
        System.out.println("haha");
    }
}
public class TestDome2 {
    public static void main(String[] args) {
        new Test();
        new Test(){
 
        }.func();
    }
}

        上述代码中，main()函数中new Test()；就是匿名对象，而new Test(){ };就是匿名内部类。再次调用Test类中的func()，即可输出。如下

 重写func方法：

class Test{
    public void func(){
        System.out.println("haha");
    }
}
public class TestDome2 {
    public static void main(String[] args) {
        new Test();//匿名对象
        new Test(){//匿名内部类
 
            @Override//重写func方法
            public void func() {
                System.out.println("重写的func方法");
            }
        }.func();
    }
}

发现输出的是

即就是输出：重写之后的func方法。