Java语言中四种内部类（成员内部类，局部内部类，静态内部类，匿名内部类）在实际使用中有啥好处？

Posted 2023-05-10

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java语言中四种内部类（成员内部类，局部内部类，静态内部类，匿名内部类）在实际使用中有啥好处？相关的知识，希望对你有一定的参考价值。

哪一种使用的频率高？

首先，内部类本身使用频率就不高（某些特殊场景用用，比如Swing，android一些监听器之类的，都是偷懒的用法）
说实在的，我看就匿名内部类用的多一些，Swing Android一些监听器啊，或者自己定义接口做注入时，都有可能用到参考技术A 一般为了让java代码结构清晰
都不推荐使用内部类
一个java文件里面 class太多可读性就不行了
一般也就在swing里面用用匿名内部类
一般在一些简单的example里面也会用其他内部类。但是对于正式开发的项目里面。。几乎不用参考技术B 一般使用匿名内部类比较多，匿名内部类一般使用在需要添加监听器的情况下使用，这个时候代码是比较清晰的，你可以参考一下一些swing的监听，一般都用匿名内部类来写的

Java——基础知识——内部类

如有不妥之处欢迎指正

内部类

内部类是在类的内部定义的类，即套娃类中类，内部类所在的类称为外部类

内部类的四种形式

成员内部类
局部内部类（方法内部类）
静态内部类（static）
匿名内部类

成员内部类

普通的内部类，直接在类的内部创建类，其“级别”与该类内其他成员同级
其内部成员能够访问成员的范围是该内部类的外部类的所有成员
其内部成员能够被访问的范围是该内部类的外部类的所有成员

成员内部类的形式

以定义成员方法或成员变量的“方式“定义类
内外类成员的访问只能借助于方法，不能直接由类名访问

class A         //外部类
{
    class B     //内部类
    {
        
    }
}

成员内部类的使用

实例化（创建对象）成员内部类的语法

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

class A         //外部类
{
    int m=0;
    public void f()
    {
        B b = new B();
        System.out.printf("%d\\n",b.n);      //外部类的方法要访问你内部类需要先实例化内部类
        System.out.print("Out\\n");
    }

    class B     //内部类
    {
        int n=1;
        public void g()
        {
            System.out.printf("%d\\n",m);    //内部类借由方法访问了外部类的变量
            System.out.print("In\\n");
        }
    }
}

public class Main
{
    public static void main(String [] args)
    {
        A a = new A();              //创建外部类对象
     
        A.B b =a.new B();           //用外部类对象创建内部类对象
        A.B b2 = new A().new B();   //直接创建内部类对象
        a.f();
        b.g();
    }
}

输出

1
Out
0
In

局部内部类

局部内部类又叫方法方法内部类，即在方法的内部创建类，其“级别”与局部变量同级

局部内部类的形式

其声明方式与方法内其他成员的声明方式相同
其能够访问的范围与成员内部类相同，即该内部类的外部类的所有成员
其能够被访问的范围仅为创建该内部类的方法内的成员

class A
{
    public void f()
    {
        class B{}       //创建局部内部类
    }
}

局部内部类的使用

class A
{
    public void f()
    {
        int n=1;
        class B
        {
            int m;
            public void g()
            {
                System.out.printf("n = %d\\n",n);
            }
        }

        B b = new B();

        b.g();                              //只能在创建该基部内部类的方法内才能访问该内部类的成员

        System.out.printf("m = %d\\n",b.m);
    }
}

public class Main
{
    public static void main(String [] args)
    {
        A a = new A();        //无法直接实例化局部内部类
        a.f();
    }
}

输出

n = 1
m = 0

静态内部类

由static关键字修饰的成员内部类
其内部成员只能访问外部类的静态成员
其内部成员在被访问时，能够跳过外部类直接被访问到

静态内部类的声明

class A                //外部类
{
    static class B     //静态内部类
    {

    }
}

静态内部类的使用

实例化（创建对象）静态内部类的语法

外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名();

以上语法表明静态内部类可以经由外部类直接创建，因此节省了时间

class A                //外部类
{
    static int n = 0;

    static class B     //静态内部类
    {
        public void f()
        {
            System.out.printf("n = %d\\n",n);    //通过方法访问外部类的静态变量
        }
    }
}

public class Main
{
    public static void main(String [] args)
    {
        A.B b = new A.B();                      //外部类直接创建内部类
        b.f();
    }
}

输出

n = 1

匿名内部类

没有名称的内部类
充当接口类型的参数写在方法的传入参数部分
当调用某个方法时，如果该方法的参数是一个接口类型，除了传入一个参数接口实现类还可通过匿名内部类的形式传入一个接口类型参数，直接在匿名内部类中完成方法的实现，通过此举可以简化代码

匿名内部类的形式

interface 接口名{}	//首先声明一个接口

参数类型为接口的方法名( new 接口名(){实现方法} )

说明：

调用以接口为参数的方法时，在方法的参数位置写入
new 接口名(){实现方法}
相当于创建了一个实例对象，并将此对象作为参数传给该方法
后方的大括号表示创建的是接口的子类实例，且该子类是匿名的
大括号中的内容是匿名子类的实现代码(接口功能的实现代码)
~~这一部分好丑好长好难懂啊啊~~

匿名内部类的使用

interface Z
{
    void f();
}

public class Main
{
    public static void main(String [] args)
    {
        int n = 1;

        g(new Z(){                  //g()为参数类型为接口类型的方法
            public void f()
            {
                System.out.printf("n = %d",n);
            }
        });
    }

    public static void g(Z z)       //注意在main方法的外部
    {
        z.f();
    }
}