内部类都有哪些？什么是内部类

撒木木

于 2022-12-06 15:16:17 发布

阅读量170

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Samumu_Li/article/details/128203548

版权

内部类

类中定义类

成员内部类

定义在外部类的成员位置的类
具有类的特点，可以继承其他父类，实现其他接口
具有成员的特点，可以被修饰符所修饰

只有静态内部类可以直接定义静态的内容，其他内部类只能定义静态的常量

在成员内部类中可以直接使用外部类的成员，包括私有的

在外部类的成员方法中需要通过成员内部类的对象，调用其成员，包括私有的

在其他类汇总，需要通过外部类对象创建内部类对象，通过内部类对象调用其成员

私有内部类

被private修饰的成员内部类
在私有内部类中可以直接使用所在外部类的成员，包括私有的
所在外部类中可以通过私有内部类的对象调用其方法成员
在其他类中无法使用

静态内部类

被static修饰的成员内部类
可以定义静态内容，可以定义非静态内容
静态内部类中可以直接使用外部类的静态内容，需要依赖外部类对象访问其成员，包括私有的
在所在外部类中可以通过静态内部类的对象访问其成员，通过静态内部类的类名访问其静态内容，包括私有的
在其他类中可以通过外部类类名.静态内部类类名.静态内容访问静态内部类的静态内容
在其他类中可以通过new 外部类类名.静态内容（）；对象访问其成员内容

局部内部类

内部类定义在外部类的局部位置
局部内部类不能通过访问权限修饰符、static等修饰，但是final可以修饰
局部内部类中不能定义静态内容，除了静态的常量
在局部内部类中可以使用外部类的成员，看局部内部类所在的方法时静态还是非静态
在局部内部类中可以使用所在方法的局部变量，但是如果一旦在局部内部类中使用这个局部变量，这个局部变量在jdk1.8及之后默认被final修饰，在jdk1.7及之前需要显示手动被final修饰
只能在所在方法中通过局部内部类的对象访问其成员，外部类的其他方法中或者其他类中都无法访问

public class Class005_Outer {
    private int i = 1;
    private static int j = 2;


    //外部类成员方法
    public void outer(int haha){
        //局部
        int a = 1; //局部变量

        //局部内部类
        class Inner extends Object{
            int m = 1;
            static final int N = 10;

            public void inner(){
                System.out.println("局部内部类中的成员方法");

                System.out.println(i);
                System.out.println(j);

                System.out.println(a);
            }
        }

        //所在方法中测试使用局部内部类
        Inner in = new Inner();
        in.inner();
    }

    public static void main(String[] args) {

    }
}

匿名内部类

没有自己类本身作用，就是用来重写方法
只在当前使用一次，不会在不同类中重复使用
将定义实现类 | 子类重写方法+创建实现类 | 子类对象 - >合二为一

语法：

new 接口 | 抽象父类（）{//实现类 | 子类的类体

重写方法…

}；

public class Class006_Outer {

    public static void main(String[] args) {
        //创建实现类对象
        Demo demo = new Demo();

        //通过对象调用重写方法
        demo.swimming();

        //匿名内部类对象
        //1)匿名对象 :  只能在当前行使用一次
        new Swim(){//匿名内部类类体
            @Override
            public void swimming() {
                System.out.println("花样游泳...");
            }
        }.swimming();

        //2)接口多态 : 可以后续通过引用多次使用当前实现类对象
        Swim s = new Swim(){
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
        s.swimming();
        s.swimming();

        //3)匿名内部类对象作为方法的实参
        test(new Swim() {
            @Override
            public void swimming() {
                System.out.println("狗刨...");
            }
        });
    }

    //统计所有会游泳的人
    public static void test(Swim swim){
        swim.swimming();
    }
}

interface Swim{
    void swimming();
}

//实现类
class Demo implements Swim{
    @Override
    public void swimming() {
        System.out.println("仰泳....");
    }
}