Java基础之内部类（最简单最详细）

内部类概述

在Java中，允许一个类定义在另一个类的内部，前者称为内部类（寄生类），后者称为外部类（宿主类）

作用

内部类提供了更好的封装性

内部类可以用private protected等修饰，可以有更安全的权限控制。

分类

内部类分为：

静态内部类（static修饰）

成员内部类（无static修饰）

局部内部类

匿名内部类

静态内部类

类的所有成员，都可以在静态内部类中定义，权限可以任意

创建静态内部类对象：

内部类全名： 外部类名.内部类名

成员内部类

低版本的JDK（8、11）不支持静态成员

创建成员内部类的对象：

成员内部类和成员方法一样，都需要对象去调用

创建成员内部类对象，需要先创建外部类对象

静态内部类和成员内部类的区别

静态内部类只能访问外部类的静态成员

成员内部类可以访问外部类的任意成员

public class A {
    //静态内部类
    public static class B{}

    //成员内部类
    public class C{}
}
1
2
3
4
5
6
7

public static void main(String[] args) {
        //创建静态内部类对象
        A.B b = new A.B();

        //创建成员内部类对象
        A.C c = new A().new C();
    }
1
2
3
4
5
6
7

巩固练习

class Outer{
    int a = 666;
        class Inner{
            int a = 66;
            public void show(){
                int a = 6;
                System.out.println(a);//6
                System.out.println(this.a);//66
                System.out.println(Outer.this.a);//666
            }
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

局部内部类

定义在方法里面的类叫做局部内部类

局部内部类只能在方法中使用，局部内部类没有权限可言

匿名内部类（重点）

匿名内部类是指没有名字的类，省略了定义类的格式

使用前提：需要存在一个接口或抽象类

使用匿名内部类简化类的定义，既是定义类，又是创建对象，只不过定义出来的类没有名字。

作用：方便创建接口或抽象类的子类对象，最终目的是为了简化代码的编写。

实际开发中，通常使用匿名内部类作为方法参数传递

//抽象类中定义一个抽象方法
abstract class Animals{
    abstract void eat();
}
1
2
3
4

//使用原始方式，继承并重写
class Cat extends Animals{

    @Override
    void eat() {
        System.out.println("吃鱼");
    }
}
1
2
3
4
5
6
7
8

public static void main(String[] args) {
        //原始方式
        Cat cat = new Cat();
        cat.eat();

        //使用匿名内部类
        Animals animals = new Animals(){
            @Override
            void eat() {
                System.out.println("吃肉");
            }
        };
        animals.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

原本抽象类是不可以创建对象的，但是利用这种方式，我们创建出了抽象类的子类对象，方便代码编写。

最后

如果你对本文有疑问，你可以在文章下方对我留言，敬请指正，对于每个留言我都会认真查看。