AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

​java-内部类详解

2022-06-08 73
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 定义:把类定义在其他类的内部，这个类被称为内部类（嵌套类）。

定义:把类定义在其他类的内部，这个类被称为内部类（嵌套类）。


分类:根据其所在位置及形式的不同,分为成员内部类、静态内部类、局部内部类、匿名内部类。

1、成员内部类


(联想到成员变量和成员方法，内部类所在位置和类的成员同级)


// 外部类
class OuterClass01 {
// 成员内部类
class InnerClass01 {
}
}
复制代码


观察一下生成的字节码文件，有两个：OuterClass01.class、OuterClass01$InnerClass01.class，


成员内部类字节码名称为： 外部类名称$成员内部类名称.class。


创建方式:


1.1 创建成员内部类对象的方式


通过调用成员内部类的构造函数。


格式：外部类名.内部类名 成员内部类对象名 = 外部类对象.new 内部类构造函数();

方法1、OuterClass01.InnerClass01 innerClass01 = (new OuterClass01()).new InnerClass01();

方法2、OuterClass01.InnerClass01 innerClass01 = new OuterClass01().new InnerClass01();


package cn.temptation;
public class Test {
    public static void main(String[] args) {
    //创建出外部类对象
        OuterClass01 outerClass01 = new OuterClass01();
        OuterClass01.InnerClass01 innerClass01 = outerClass01.new InnerClass01();
        System.out.println(innerClass01);
        // cn.temptation.OuterClass01$InnerClass01@15db9742
    }
}
复制代码


理解：OuterClass01.InnerClass01 innerClass01 = outerClass01.new InnerClass01();


可以理解为：OuterClass01.InnerClass01 innerClass01 = outerClass01.(new InnerClass01());（这种写法语法有错,只是为了方便理解才这样写）即，通过对象名.这样的方式调用类的成员，这里的成员内部类也是这个外部类的成员，也就考虑使用对象名.这样的方式进行调用且这里要获取的是成员内部类对象，所以通过new 成员内部类的构造函数获取成员内部类对象


1.2 创建成员内部类对象的方式


通过调用成员内部类所在的外部类的成员方法，在外部类中创建出成员内部类的对象


// 外部类
class OuterClass02 {
// 成员变量
private InnerClass02 innerClass02;
// 成员方法
// 多例创建方法（在类的内部，成员方法可以访问成员）
public InnerClass02 getInnerClass02() {
return new InnerClass02();
}
// 单例创建方法（懒汉式，在类的内部，成员方法可以访问成员）
public InnerClass02 getInstance() {
if (innerClass02 == null) {
innerClass02 = new InnerClass02();
}
return innerClass02;
}
// 成员内部类
class InnerClass02 {
// 设置构造函数为私有
private InnerClass02() {
}
}
}
package cn.temptation;
public class Test {
    public static void main(String[] args) {
        OuterClass02 outerClass02 = new OuterClass02();
        // 创建成员内部类对象的写法（多例）
        OuterClass02.InnerClass02 innerClass02 = outerClass02.getInnerClass02();
        System.out.println(innerClass02);  
        //cn.temptation.OuterClass02$InnerClass02@15db9742
        OuterClass02.InnerClass02 innerClass02Ex = outerClass02.getInnerClass02();
        System.out.println(innerClass02Ex);  
        //cn.temptation.OuterClass02$InnerClass02@6d06d69c
        System.out.println("----------------------");
        // 创建成员内部类对象的写法（单例）
        OuterClass02.InnerClass02 innerClass02Demo = outerClass02.getInstance();
        System.out.println(innerClass02Demo);      
       //cn.temptation.OuterClass02$InnerClass02@7852e922
        OuterClass02.InnerClass02 innerClass02DemoEx = outerClass02.getInstance();
        System.out.println(innerClass02DemoEx);          
       //cn.temptation.OuterClass02$InnerClass02@7852e922
    }
}
复制代码


特点:


1、成员内部类可以直接访问其所在的外部类的非静态成员变量和静态的成员变量


// 外部类
class OuterClass04 {
// 非静态的成员变量
public int i = 2;
private int j = 3;
// 静态的成员变量
public static int x = 4;
private static int y = 5;
// 成员内部类
class InnerClass04 {
// 成员方法
public void showByInner() {
// 成员内部类对于其所在的外部类的非静态成员变量均可以访问（不论使用public修饰，还是private修饰）
System.out.println(i);
System.out.println(j);
// 成员内部类对于其所在的外部类的静态成员变量均可以访问（不论使用public修饰，还是private修饰）
System.out.println(x);
System.out.println(y);
}
}
复制代码


外部类和内部类成员变量相同时: 获取的变量值采取的是就近原则


// 外部类
class OuterClass05 {
// 非静态的成员变量
public int i = 2;
// 外部类的成员变量和内部类的成员变量同名
public int k = 4;
// 静态的成员变量
public static int x = 6;
public static int z = 8;
// 成员内部类
class InnerClass05 {
// 非静态的成员变量
public int j = 3;
// 外部类的成员变量和内部类的成员变量同名
public int k = 5;
// 静态的成员变量：在非静态的成员内部类中定义静态的成员变量，语法出错
// 语法错误：The field y cannot be declared static in a non-static inner type, unless initialized with a constant expression
// public static int y = 7;
// 语法错误：The field z cannot be declared static in a non-static inner type, unless initialized with a constant expression
// public static int z = 9;
// 成员方法
public void showByInner() {
System.out.println(i); // 2
System.out.println(j); // 3
System.out.println(k); // 5 --- 内部类的成员变量（就近原则）
System.out.println(this.k); // 5 --- 内部类的成员变量（this指的是当前这个成员内部类对象）
System.out.println(this); // cn.temptation.OuterClass05$InnerClass05@15db9742
// 问题：就想在成员内部类的成员方法中使用其所在的外部类的同名成员变量，怎么办？
// 思路1、考虑创建外部类对象，再通过外部类对象.成员变量获取
System.out.println((new OuterClass05()).k); // 4 --- 外部类的成员变量
// 思路2、考虑成员内部类对象创建出来时，其所在的外部类对象是否创建了，如果创建了，是什么样的访问形式
// 答：创建了，访问形式为外部类类名.this
System.out.println(OuterClass05.this); // cn.temptation.OuterClass05@6d06d69c
System.out.println(OuterClass05.this.k); // 4 --- 外部类的成员变量
// 访问外部类的静态成员变量，直接通过外部类类名.静态成员变量
System.out.println(OuterClass05.x); // 6
System.out.println(OuterClass05.z); // 8
}
}
复制代码


2、成员内部类的成员方法可以访问其所在的外部类的所有成员方法（不论是否公有，不论是否静态）


// 外部类
class OuterClass06 {
// 成员方法
public void method1() {
System.out.println("外部类的公有非静态成员方法");
}
private void method2() {
System.out.println("外部类的私有非静态成员方法");
}
public static void method3() {
System.out.println("外部类的公有静态成员方法");
}
private static void method4() {
System.out.println("外部类的私有静态成员方法");
}
// 成员内部类
class InnerClass06 {
// 成员方法
public void showByInner() {
// 成员内部类的成员方法可以访问其所在的外部类的所有成员方法（不论是否公有，不论是否静态）
method1();
method2();
method3();
method4();
}
}
复制代码


2、静态内部类 (联想到静态成员，使用static修饰)


// 外部类
class OuterClass08 {
// 静态内部类
static class InnerClass08 {
}
}
复制代码


观察一下生成的字节码文件，有两个：OuterClass08.class、OuterClass08InnerClass08.class，静态内部类字节码名称为：外部类名称InnerClass08.class，静态内部类字节码名称为：外部类名称InnerClass08.class，静态内部类字节码名称为：外部类名称静态内部类名称.class。


创建方式：


格式：外部类名.内部类名   静态内部类对象名  =  new 外部类名.静态内部类构造函数();


package cn.temptation;
public class Test {
    public static void main(String[] args) {
        OuterClass08.InnerClass08 innerClass08 = new OuterClass08.InnerClass08();
        System.out.println(innerClass08);
        // cn.temptation.OuterClass08$InnerClass08@15db9742
    }
}
复制代码


特点：


1、静态内部类中不论是静态的成员方法，还是非静态的成员方法，只能访问其所在的外部类的静态成员变量


// 外部类
class OuterClass09 {
// 非静态的成员变量
public int i = 2;
private int j = 3;
// 静态的成员变量
public static int x = 4;
private static int y = 5;
// 静态内部类
static class InnerClass09 {
// 非静态的成员方法
public void showByInner() {
// 静态内部类中的非静态成员方法无法访问其所在的外部类的非静态的成员变量
// Cannot make a static reference to the non-static field i
// System.out.println(i);
// Cannot make a static reference to the non-static field j
// System.out.println(j);
// 静态内部类中的非静态成员方法可以访问其所在的外部类的静态的成员变量
System.out.println(x); // 4
System.out.println(y); // 5
}
// 静态的成员方法
public static void showByInnerStatic() {
// 静态内部类中的静态成员方法无法访问其所在的外部类的非静态的成员变量
// Cannot make a static reference to the non-static field i
// System.out.println(i);
// Cannot make a static reference to the non-static field j
// System.out.println(j);
System.out.println(x); // 4
System.out.println(y); // 5
}
}
复制代码


2、静态内部类中不论是静态的成员方法，还是非静态的成员方法，只能访问其所在的外部类的静态成员方法


// 外部类
class OuterClass10 {
// 成员方法
public void method1() {
System.out.println("外部类的公有非静态成员方法");
}
private void method2() {
System.out.println("外部类的私有非静态成员方法");
}
public static void method3() {
System.out.println("外部类的公有静态成员方法");
}
private static void method4() {
System.out.println("外部类的私有静态成员方法");
}
// 静态内部类
static class InnerClass10 {
// 非静态的成员方法
public void showByInner() {
// 语法错误：Cannot make a static reference to the non-static method method1() from the type OuterClass10
// method1();
// 语法错误：Cannot make a static reference to the non-static method method2() from the type OuterClass10
// method2();
method3();
method4();
}
// 静态的成员方法
public static void showByInnerStatic() {
// 语法错误：Cannot make a static reference to the non-static method method1() from the type OuterClass10
// method1();
// 语法错误：Cannot make a static reference to the non-static method method2() from the type OuterClass10
// method2();
method3();
method4();
}
}
复制代码


3、局部内部类(联想到局部变量，位于外部类的成员方法之中)


// 外部类
class OuterClass12 {
// 成员方法
public Object showByOuter() {
// 局部内部类
class InnerClass12 {
}
// 在外部类的成员方法中实例化局部内部类
InnerClass12 innerClass12 = new InnerClass12();
return innerClass12;
}
}
复制代码


观察一下生成的字节码文件，有两个：OuterClass12.class、OuterClass121InnerClass12.class局部内部类字节码名称为：外部类名称1InnerClass12.class 局部内部类字节码名称为： 外部类名称 1InnerClass12.class局部内部类字节码名称为：外部类名称 编号 局部内部类名称.class。这里的编号是局部内部类类型的相应的编号，同一种局部内部类编号从1开始。


注意:在同一个外部类的成员方法中，不允许创建多个同名的局部内部类；外部类中的不同成员方法中可以定义相同名称的局部内部类，这些局部内部类可以名称相同、成员不同。


局部内部类的成员方法访问局部内部类所在的外部类的成员方法中定义的局部变量，局部变量可以使用final修饰，也可以不使用final修饰 ，但是不论是否使用final修饰，对于局部内部类的成员方法均只能访问（读取），而不能设置（赋值）

创建方式：


// 只能通过其所在的外部类的成员方法返回在成员方法中创建出的局部内部类对象


OuterClass12 outerClass12 = new OuterClass12();


System.out.println(outerClass12.showByOuter());


特点

1、局部内部类中可以直接访问其所在的外部类的非静态的成员变量 和 静态的成员变量


// 外部类
class OuterClass13 {
// 非静态的成员变量
public int i = 2;
private int j = 3;
// 外部类和局部内部类同名的成员变量
public int k = 4;
// 静态的成员变量
public static int x = 6;
private static int y = 7;
public static int z = 8;
// 成员方法
public void showByOuter() {
// 局部内部类
class InnerClass13 {
// 非静态的成员变量
// 外部类和局部内部类同名的成员变量
public int k = 5;
// 静态的成员变量
// 语法错误：The field z cannot be declared static in a non-static inner type, unless initialized with a constant expression
// public static int z = 8;
// 成员方法
public void showByInner() {
// 局部内部类对于其所在的外部类的非静态成员变量均可以访问（不论使用public修饰，还是private修饰）
System.out.println(i); // 2
System.out.println(j); // 3
// 局部内部类对于其所在的外部类的静态成员变量均可以访问（不论使用public修饰，还是private修饰）
System.out.println(x); // 6
System.out.println(y); // 7
System.out.println(k); // 5 --- 局部内部类的非静态成员变量（就近原则）
System.out.println(this.k); // 5 --- 局部内部类的非静态成员变量（this指的是局部内部类对象）
System.out.println(this); // cn.temptation.OuterClass13$1InnerClass13@15db9742
System.out.println(OuterClass13.this); // cn.temptation.OuterClass13@6d06d69c
System.out.println(OuterClass13.this.k); // 4 --- 外部类的非静态成员变量
System.out.println(OuterClass13.z); // 8
}
}
// 在外部类的成员方法中实例化局部内部类对象
InnerClass13 innerClass13 = new InnerClass13();
innerClass13.showByInner();
}
 2、局部内部类中可以直接访问其所在的外部类的非静态的成员方法 和 静态的成员方法
// 外部类
class OuterClass14 {
// 成员方法
public void method1() {
System.out.println("外部类的公有非静态成员方法");
}
private void method2() {
System.out.println("外部类的私有非静态成员方法");
}
public static void method3() {
System.out.println("外部类的公有静态成员方法");
}
private static void method4() {
System.out.println("外部类的私有静态成员方法");
}
public void showByOuter() {
// 局部内部类
class InnerClass14 {
// 成员方法
public void showByInner() {
// 局部内部类对于其所在的外部类的非静态成员方法均可以访问（不论使用public修饰，还是private修饰）
method1();
method2();
// 局部内部类对于其所在的外部类的静态成员方法均可以访问（不论使用public修饰，还是private修饰）
method3();
method4();
}
}
// 在外部类的成员方法中实例化局部内部类对象
InnerClass14 innerClass14 = new InnerClass14();
innerClass14.showByInner();
}
复制代码


4、匿名内部类(联想到匿名对象和匿名数组，内部类没有名称，需要存在一个类或接口)


// 定义接口
interface Foo {
public abstract void show();
}
// 接口的实现类
class FooImpl implements Foo {
@Override
public void show() {
System.out.println("接口的实现类的成员方法");
}
}
// 外部类
class OuterClass18 {
// 成员方法
public Foo showByOuter() {
// 多态的写法，创建接口类型的变量，接收接口实现类类型的对象，并返回
// Foo foo = new FooImpl();
// return foo;
// 对上述写法的变形，匿名对象的写法
// return new FooImpl();
// 实现了Foo接口的匿名内部类（位置位于类似局部内部类的位置）
return new Foo() {
@Override
public void show() {
System.out.println("实现了接口的匿名内部类");
}
};
}
复制代码


观察一下生成的字节码文件，有两个：OuterClass18.class、OuterClass18$1.class


匿名内部类字节码名称为： 外部类名称$编号.class


创建方式


通过调用匿名内部类所在的外部类的成员方法


package cn.temptation;
public class Test {
    public static void main(String[] args) {
        OuterClass18 outerClass18 = new OuterClass18();
        // 定义接口类型的变量来接收匿名内部类对象的返回
        Foo foo = outerClass18.showByOuter();
        System.out.println(foo);
        // cn.temptation.OuterClass18$1@15db9742
        foo.show(); // 这句语句实际调用接口实现对象（匿名内部类对象）的成员方法
    }
}
复制代码


特点


1、匿名内部类没有构造函数，且使用者无法创建构造函数，但是实际上JDK为匿名内部类生成了构造函数


2、匿名内部类的成员方法中可以访问其所在的外部类的成员变量（不论是否公有私有，不论是否静态非静态），变量相同时也是就近原则


// 接口
interface Sample {
public abstract void show();
}
// 外部类
class OuterClass22 {
// 成员变量
public int i = 2;
private int j = 3;
int k = 6;
public static int x = 4;
private static int y = 5;
// 成员方法
public void showByOuter() {
// 局部变量
int k = 7;
// 匿名内部类
(new Sample() {
@Override
public void show() {
System.out.println(i); // 2
System.out.println(j); // 3
System.out.println(x); // 4
System.out.println(y); // 5
System.out.println(k); // 7 --- 局部变量（就近原则）
// 语法错误：k cannot be resolved or is not a field
// System.out.println(this.k);
System.out.println(this); // cn.temptation.OuterClass22$1@15db9742
System.out.println(OuterClass22.this); // cn.temptation.OuterClass22@6d06d69c
System.out.println(OuterClass22.this.k);// 6
}
}).show();
}


文章标签：
Java
关键词：
Java内部类
Java内部类详解
香菜11111
目录
相关文章
椰椰椰耶
|
1月前
|
Java 编译器
【Java】内部类
【Java】内部类
椰椰椰耶
20 0
热爱技术的小郑
|
3月前
|
Java
【Java基础面试二】、个Java文件里可以有多个类吗（不含内部类）？
这篇文章讨论了Java文件中类的定义规则，指出一个Java文件可以包含多个类（不包含内部类），但其中最多只能有一个public类，且如果有public类，它的名称必须与文件名一致。
热爱技术的小郑
63 4
yinying293
|
3月前
|
算法 Java
12 Java常用类（一）（内部类+object类+包装类）
12 Java常用类（一）（内部类+object类+包装类）
yinying293
35 5
兴化
|
4月前
|
Java
Java进阶之内部类
【7月更文挑战第13天】Java内部类增进代码组织与封装，允许直接访问外部类成员，包括私有成员。主要有四种类型：成员、静态、局部和匿名内部类。匿名内部类常用于一次性实现接口或扩展类。内部类可隐藏实现细节，减少命名冲突，并在特定上下文中定义辅助类。示例展示了静态和非静态内部类如何在Shape类中封装Circle和Rectangle。使用内部类能提升代码可读性，但可能增加复杂性。
兴化
37 6
睡觉待开机
|
3月前
|
Java
【Java】内部类、枚举、泛型
【Java】内部类、枚举、泛型
睡觉待开机
19 0
jjczqyjxgdegi
|
5月前
|
Java
一篇文章讲明白Java中内部类详解—匿名内部类
一篇文章讲明白Java中内部类详解—匿名内部类
jjczqyjxgdegi
89 2
秋刀鱼不做梦
|
5月前
|
设计模式 Java 编译器
Java中的内部类（如果想知道Java中有关内部类的知识点，那么只看这一篇就足够了！）
Java中的内部类（如果想知道Java中有关内部类的知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦
48 7
艾尼麻麻
|
5月前
|
Java 编译器
24. 【Java教程】内部类
24. 【Java教程】内部类
艾尼麻麻
29 2
闫嘉辉
|
6月前
|
Java 程序员
Java的内部类与匿名类的技术性文章
Java的内部类与匿名类的技术性文章
闫嘉辉
43 1
叶落闲庭
|
6月前
|
Java
Java内部类（成员内部类、静态内部类、局部内部类、局部内部类）
Java内部类（成员内部类、静态内部类、局部内部类、局部内部类）
叶落闲庭
41 3

热门文章

最新文章

  • 1
    java集成opencv(不踩坑),实现人脸检测小demo(含上传人像图片识别接口),windows,IDEA,Springboot
  • 2
    java Redis工具类
  • 3
    JAVA SERVLET 属性范围样例
  • 4
    Java一分钟之-JavaMail：发送电子邮件
  • 5
    2024年全新基于Java爬取微博数据（完整版）
  • 6
    Java的几种创建实例方法的性能对比
  • 7
    Java杂记9—NIO
  • 8
    16.2. jps - Java Virtual Machine Process Status Tool
  • 9
    Java多线程初学者指南（9）：为什么要进行数据同步
  • 10
    Java——基于java自身包实现消息系统间的通信（TCP/IP+BIO）
  • 1
    java接口防爬虫
    127
  • 2
    day14：Java零基础-条件运算符
    40
  • 3
    Java并发编程中的锁机制与性能优化
    50
  • 4
    深入理解Java虚拟机：垃圾收集机制的演变与最佳实践
    49
  • 5
    《手把手教你》系列基础篇（九十五）-java+ selenium自动化测试-框架之设计篇-java实现自定义日志输出（详解教程）
    293
  • 6
    Java并发编程之线程池深度解析
    61
  • 7
    Java中的并发编程：从基础到高级
    62
  • 8
    Java并发编程中的线程安全性与性能优化
    53
  • 9
    《手把手教你》系列基础篇（九十四）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇（详解教程）
    46
  • 10
    Spring Boot框架在java领域的优势
    74

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云OSS设置跨域访问