Java中内部类的讲解（Java系列8）

努力敲代码的小白✧٩(ˊωˋ*)و✧

于 2022-12-30 17:36:26 发布

阅读量703

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_61599986/article/details/128474379

版权

Java 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

前言：

这次小编主要与大家分享一下什么是内部类，那么接下来就和小编一起来见识一下内部类究竟是什么，我们又该怎么使用他们。

1.内部类

1.1内部类的概念

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整的结构最好使用内部类。在Java中，可以将一个类定义在另一个类或者另一个方法的内部，前者称之为内部类，后者称之为外部类，内部类也是封装的一种体现。

代码如下所示：

public class OutClass {
    //OutClass称之为外部类
    class InnerClass{
        //InnerClass该类为内部类
    }
}

注意：我们

1.定义在class类名{}花括号外部的，即使是在一个文件里，都不能称之为内部类。只能说是两个类。

代码如下所示：

public class Test2 {
    public int a;
}
class B{
    public int b;
}

2.内部类和外部类共用一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件。

1.2内部类的分类

我们先来看一下内部类具体度可以分布在哪些方面。

public class Test3 {
    //1.成员变量的位置
    public class InnerClass1{
        //未被static修饰的实例内部类
    }
    static class InnerClass2{
        //被static修饰的静态内部类
    }
    //2.成员方法的位置
    public void method() {
        class InnerClass3{
            //在方法中定义的局部内部类
        }
    }
}

上面代码中给大家简单的看了一下内部类的三大位置，那么接下来我们就分别具体展开给大家介绍一下各个内部类都有哪些具体的用法以及注意事项。

1.2.1实例内部类

实例内部类也叫非静态内部类，根据词意大家应该也知道了，就是不被static修饰的成员内部类。

具体代码如下所示：

public class Test4 {
    public class InnerClass{
        //实例内部类（非静态内部类）
    }
}

注意：

1.外部类中的任何成员都可以在实例内部类方法中直接访问。

public class Test4 {
    public int a;
    private int b;
    
    public class InnerClass{
        //实例内部类（非静态内部类）
        public int c;
        private int d;
        public void methodInnerClass(){
            System.out.println("内部类的方法：methodInnerClass");
            a = 100;
            b = 200;
            System.out.println(a + b);//可以访问外部被任何修饰符修饰的成员变量。
            methodOutClass();//可以访问外部的成员方法
        }
    }
    public void methodOutClass(){
        System.out.println("外部类的方法：methodOutClass");
    }
}

2.实例内部类所处的位置与外部成员位置相同，因此也受public、private等访问限定符的约束。

public class Test5 {
    //示范被各种修饰限定符修饰的内部类
    private class InnerClass1{
        //1.被private修饰的内部类
    }
    class InnerClass2{
        //2.被default（默认）修饰的内部类
    }
    protected class InnerClass3{
        //3.被protected修饰的内部类
    }
    public class InnerClass4{
        //4.被public修饰的内部类
    }
}

3.在实例内部类方法中访问同名的成员的时，会优先访问自己的，你也可以理解为遵循“就近原则”如果要访问外部类同名的成员，必须要外部类名称.this.同名成员来访问。

public class Test6 {
    public int a = 10;
    private int b = 20;
    class InnerClass{
        public int a = 30;
        private int b = 40;
        public void methodInnerClass(){
            //调用的是内部类自己的成员变量，遵循就近原则
            System.out.println(a);
            System.out.println(b);
            //要调用外部类的成员变量则可以通过外部类类名.this.相同成员变量名
            System.out.println(Test6.this.a);
            System.out.println(Test6.this.b);
        }
    }
}

4.实例内部类对象必须在先有外部类对象前提下才能创建。

5.实例内部类的非静态方法中包含了一个指向外部类对象的引用。

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

代码如下所示：

public class OutClass2 {
    public int a = 10;
    private int b = 20;
    public void methodOutClass(){
        System.out.println("这是一个外部类方法：methodOutClass！");
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
    class InnerClass{
        public int a = 30;
        private int b = 40;
        public void methodInnerClass() {
            System.out.println("这是一个内部类方法：methodInnerClass！");
            System.out.println("******这是内部类的成员变量！*****");
            System.out.println("a = " + a);
            System.out.println("b = " + b);
            System.out.println("******这是外部类的成员变量！*****");
            System.out.println("a = " + OutClass2.this.a);
            System.out.println("b = " + OutClass2.this.b);
        }
    }

    public static void main(String[] args) {
        //实例化外部类
        OutClass2 outClass2 = new OutClass2();
        outClass2.methodOutClass();
        //实例内部类
        //创建方法一：
        OutClass2.InnerClass innerClass1 = new OutClass2().new InnerClass();
        innerClass1.methodInnerClass();
        //创建方法二：
        //该方法需要先创建外部类对象后才能创建出来！！！
        OutClass2.InnerClass innerClass2 = outClass2.new InnerClass();
        innerClass2.methodInnerClass();
    }
}

结果如下所示：

1.2.2静态内部类

看完实例内部类（非静态内部类）那么对于静态内部类大家应该会更加好理解一点吧，就是被static修饰的内部类就叫静态内部类。

public class OutClass1 {
    static class InnerClass1{
        //静态内部类
    }
}

那么接下来我们具体通过代码和注意事项来学习一下什么是静态内部类，如何使用静态内部类。

注意：

1.在静态内部类中只能访问外部类中的静态成员。

public class OutClass1 {
    public int a = 10;
    public static int b = 30;
    //在静态内部类中只能访问外部类中的静态成员
    static class InnerClass1{
        //静态内部类
        public void methodInnerClass() {
            //System.out.println(a);
            System.out.println(b);
        }
    }
}

在上述代码中我们只能访问b而不能访问a。

2.创建静态内部类对象时，不需要先创建外部类对象。

public class OutClass1 {
    public int a = 10;
    public static int b = 30;
    //在静态内部类中只能访问外部类中的静态成员
    static class InnerClass1{
        //静态内部类
        public void methodInnerClass() {
            //System.out.println(a);
            System.out.println(b);
        }
    }

    public static void main(String[] args) {
        InnerClass1 innerClass1 = new InnerClass1();
        innerClass1.methodInnerClass();
    }
}

1.2.3局部内部类

局部内部类是定义在外部类的方法体或者是{}中，该种类内部类只能在其定义的位置使用，一般使用的非常少。

public class OutClass1 {
    public void methodOutClass1(){
        class InnerClass1{
            //局部内部类
        }
    }
    {
        class InnerClass2{
            //局部内部类
        }
    }
}

注意：

1.局部内部类只能在所在定义的方法体内部使用。

public class OutClass1 {
    public void methodOutClass1(){
        class InnerClass1{
            public int a = 10;
            //局部内部类
            public void methodInnerClass1() {
                System.out.println(a);
            }
        }
        //只能在方法体内部使用
        InnerClass1 innerClass1 = new InnerClass1();
        innerClass1.methodInnerClass1();
    }
    
    {
        class InnerClass2{
            //局部内部类
            public int b = 20;
            public void methodInnerClass2() {
                System.out.println(b);
            }
        }
        InnerClass2 innerClass2 = new InnerClass2();
        innerClass2.methodInnerClass2();
    }
}

2.不能被public、static等修饰符修饰。

3.编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class。

1.2.4匿名内部类

顾名思义就是没有名字的，具体的看下面的代码。

interface IClass{
    void func();
}
public class OutClass1 implements IClass{

    @Override
    public void func() {
        System.out.println("这是一个接口方法的重写！");
    }

    public static void main(String[] args) {
        //匿名内部类
        new IClass(){
            @Override
            public void func() {
                System.out.println("这是在创建对象的时候接口方法的重写！！！");
            }
        }.func();//方法的调用
    }
}