一文搞懂内部类

内部类分为:本地内部类, 实例内部类,静态内部类,匿名内部类

1.本地内部类

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

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

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

  1. 实例内部类

例如:

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方法。

Original: https://blog.csdn.net/m0_57950108/article/details/127794603
Author: 噜噜噜噜鲁先生
Title: 一文搞懂内部类

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/653811/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

亲爱的 Coder【最近整理,可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球