Java学习笔记——内部类(InnerClass)浅析

已于 2024-01-24 01:02:39 修改
阅读量1.7k 收藏 51
点赞数 46
文章标签： java 学习 笔记 后端 jvm 开发语言
于 2024-01-23 23:56:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itsetggg/article/details/135775874
版权

内部类的定义

Java中可以在一个外部类的内部再定义一个类。这个类就叫做内部类(InnerClass)

分类：按照定义的位置不同，内部类又可以分为以下四种类型：
如果定义类在局部位置(方法/代码块中) ，可分为：

  • (1) 局部内部类（有类名）
  • (2) 匿名内部类（无类名）

如定义在成员位置，内部类可分为：

  • (1) 成员内部类（无static修饰）
  • (2) 静态内部类（使用static修饰）

内部类的作用

为什么要引入内部类呢？因为它有如下的作用

  • 有时候在一个类中，需要多次通过不同的方式实现同一个接口，按照传统方法，必须多次定义不同的类，但是定义的类可能只使用一次。使用内部类可以很好的解决这个问题，每个内部类都可以实现同一个接口，既实现了代码的封装，又实现了同一接口不同的实现。
  • 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据，可以认为内部类提供了某种进入其外部类的窗口。
  • 内部类提供了可以继承多个具体的或抽象的类的能力，这使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了"多重继承"。
  • 内部类可以将组合的实现封装在内部中，而不为同一包的其他类所见，具有很好的封装性
  • 匿名内部类可以很方便的定义回调

局部内部类

局部内部类是定义在外部类的局部位置比如方法中，并且有类名，其定义方式如下：

class outer{
	private v1;
	public void f1{
		class inner{
			System.out.println("v1 = " + v1);
			f2();
		}
	}
	public void f2{}
}

局部内部类具有以下特点：

  1. 可以直接访问外部类的所有成员，包含私有的
  2. 除了final外，不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
  3. 局部内部类的作用域仅仅在定义它的方法或代码块中。
  4. 外部类访问局部内部类的成员需要先创建对象，再进行访问
  5. 外部其他类不能访问局部内部类的成员，因为局部内部类地位是一个局部变量
  6. 如果外部类和局部内部类的成员重名时,默认遵循就近原则，如果想访问外部类的成员,则可以使用外部类名.this.成员去访问。如System.out.println("外部类的n2=”+外部类名.this.n2);Outer.this 本质就是外部类的对象

代码示例

package com.dhw.innerclass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer outer= new Outer();
        outer.m1();
        System.out.println("outer 的 hashcode=" + outer);
    }
}
class Outer {//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("Outer m2()");
        //3. 作用域 : 仅仅在定义它的方法或代码块中
        //Inner inner = new Inner();
    }
    public void m1() {
        //2. 除了final外，不能添加访问修饰符
        final class Inner {//局部内部类(本质仍然是一个类)
            private int n1 = 800;
            public void f1() {
                //1. 局部内部类可以直接访问外部类的所有成员，包括私有的，比如下面 外部类的  n1 和 m2()
                //6. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                // 使用 外部类名.this.成员）去访问
                // Outer.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer.this 就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer.this.n1);
                System.out.println("Outer.this 的 hashcode=" + Outer.this);
                m2();
            }
        }
        //4. 外部类在方法中，可以创建内部类对象，然后调用方法即可
        //5. 外部其他类不能访问内部类
        Inner inner = new Inner();
        inner.f1();
    }
}

匿名内部类

匿名内部类是定义在外部类的局部位置比如方法中，且没有类名的内部类，定义方式如下：

class outer{
	public void f1{
		new 外部其他类或接口 (参数列表){
			类体
		}
	}

匿名内部类的本质还是类，同时它也是一个对象。
有时候在一个类中，需要多次通过不同的方式实现同一个接口，按照传统方法，必须多次定义不同的类，但是定义的类可能只使用一次。使用匿名内部类可以很好的解决这个问题，每个内部类都可以实现同一个接口，既实现了代码的封装，又实现了同一接口不同的实现。

package com.dhw.innerclass;

public class AnonymousInnerClasses {
    public static void main(String[] args) {
        Cellphone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        Cellphone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴们上课了");
            }
        });
    }
}
interface Bell{
    public abstract void ring();
}
class Cellphone {
    public static void alarmClock(Bell bell){
        System.out.println(bell.getClass());
        bell.ring();
    }
}

在定义匿名内部类时，底层会按顺序自动分配类名 Outer$1，Outerr$2…并马上创建该类的实例并返回，而在这之后匿名内部类Outer$1就被销毁了，因此匿名内部类只能使用一次。
此外，其参数列表会传递给它继承的类
new 外部其他类或接口 (参数列表){类体}，底层就相当于实现了如下这样的类，并马上返回该类的对象。

class Outer$1 extends 外部的其他类{
	类体
}
或
class Outer$1  implements 接口{
	类体
}

匿名内部类的使用体现了多态以及动态绑定机制，它在编程中十分重要，关于多态和动态绑定机制，可以参看以下的文章：Java多态详解和Java的动态绑定机制
匿名内部类的特点有：

  1. 因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法。
  2. 匿名内部类可以直接访问外部类的所有成员，包括私有的
  3. 匿名内部类不能添加访问修饰符，因为它的地位就是一个局部变量
  4. 匿名内部类的作用域仅仅在定义它的方法或代码块中。
  5. 外部其他类不能访问匿名内部类（因为匿名内部类地位是一个局部变量)
  6. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用（外部类名.this.成员)去访问

代码示例：

package com.dhw.innerclass;

public class AnonymousInnerClassesDetails {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
        System.out.println("main outer05 hashcode=" + outer05);
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
    //创建一个基于类的匿名内部类
    //不能添加访问修饰符,因为它的地位就是一个局部变量
    //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person(){//体现了多态的向上转型
            private int n1 = 88;
            @Override
            public void hi() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                 System.out.println("匿名内部类重写了 hi 方法 内部类的n1=" + n1 +
                        " 外部类的 n1=" + Outer05.this.n1 );
            //Outer05.this 就是调用 f1 的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        p.hi();//动态绑定, 运行类型是 Outer05$1
        System.out.println(p.getClass());
         new Person(){
         @Override
         public void hi() {
            System.out.println("匿名内部类重写了 hi 方法222");
         }
         @Override
         public void ok(String str) {
            super.ok(str);
         }
         }.ok("jack");
        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
    }
}
class Person {//类
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }
}

运行结果如图所示
在这里插入图片描述
可以看到，Java底层确实生成了一个叫做Outer05$1的类

成员内部类

成员内部类定义在外部类的成员位置，并且没有static修饰，其定义方式如下

class outer{
	private v1;
	public void f1{
	}
	public void f2{}
	修饰符 class inner{
		//类体
	}
}

成员内部类具有以下特点：

  1. 成员内部类可以直接访问外部类的所有成员，包括私有的
  2. 可以添加任意修饰符（private、public…）因为它就相当于一个外部类的成员
  3. 作用域为整个类体，也就是说，只能通过外部类创建内部类对象
  4. 外部类访问成员内部类要创建对象，再访问
  5. 外部其他类访问成员内部类的成员(前提是满足访问权限)有两种方式，一是通过外部类的对象进行访问Outer.Inner ii = new Outer(参数列表).new Inner();或new Outer().new Inner().fun();二是在外部类中，编写一个可以返回 Inner对象的方法
  6. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

代码示例：

package com.dhw.innerclass;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //外部其他类使用成员内部类的2种方式
        //第一种方式
        //相当于把 new Inner08()当做是 outer08 成员
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        //也可以这么写
        new Outer08().new Inner08().say();
        // 第二种方式，在外部类中，编写一个可以返回 Inner对象的方法
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}
class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";
    private void hi() {
        System.out.println("hi()方法...");
    }
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
        //可以直接访问外部类的所有成员，包含私有的
        //如果成员内部类的成员和外部类的成员重名，会遵守就近原则可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("内部类的n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }
    //写能返回内部类的方法
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    public void t1() {
    //外部类使用成员内部类
    //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

静态内部类

静态内部类定义在外部类的成员位置，并且有static修饰，其定义方式如下：

class outer{
	private v1;
	public void f1{
	}
	public void f2{}
	修饰符 static class inner{
		//类体
	}
}

静态内部类的特点如下：

  1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  2. 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
  3. 作用域为整个类体
  4. 外部类访问静态内部类访问方式需先创建对象再访问
  5. 外部其他类访问静态内部类也有两种方式(前提是满足访问权限)，一是直接通过类名来访问Outer.Inner ii = new Outer.Inner();二是在外部类定义一个可以返回静态内部类对象的方法
  6. 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

代码示例

package com.dhw.innerclass;

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        //外部类访问静态内部类需创建对象，再访问
        outer10.m1();
        //外部其他类 使用静态内部类
        //方式 1
        //因为是静态内部类，可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //另一种方法
        new Outer10.Inner10().say();
        //方式 2
        //编写一个方法，可以返回静态内部类的对象实例
        Outer10.Inner10 inner101 = outer10.getInner10();
        inner101.say();
        //可以编写静态方法，这样可以直接通过外部类名访问，更方便
        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        inner10_.say();
    }
}
class Outer10 { //外部类
    private int n1 = 10;
    private static int n2 = 22;
    private static String name = "张三";
    private static void cry() {}

    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域为整个类体
    static class Inner10 {
        private static String name = "李维斯";
        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(" 内部类 name= " +name + " 外部类 name= " + Outer10.name);
            cry();
            //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
            //System.out.println(n1);
            System.out.println(n2);
        }
    }
    public void m1() { //外部类访问静态内部类需创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
    public Inner10 getInner10() {
        return new Inner10();
    }
    //可以编写静态方法，这样可以直接通过外部类名访问，更方便
    public static Inner10 getInner10_() {
        return new Inner10();
    }
}
itsetggg
关注
  • 46
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
Solidworks学习笔记——随形变化.docx
07-13
Solidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——...
刷题笔记——java学习
05-12
刷题笔记——java学习
Java基础 学习笔记 Markdownr版
06-27
Java基础 java学习笔记 Java Java基础Markdown学习笔记，可转换成PDF、Word等格式
Collection学习笔记——每天一个Java小技巧
12-21
Collection学习笔记Collection集合概述Collection集合常用方法Collection集合的遍历(迭代器)集合的使用样例 Collection集合概述 是单例集合的顶层接口 它提供了更具体的子接口的实现，如set和list. Collection集合...
jar包增量更新分析
junlaiyan的专栏
05-16 263
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 694
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 622
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 23
1，引入核心关键依赖。
命令执行漏洞（二）
XLbb的博客
05-15 906
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
JVM学习-执行引擎
丢爸
05-21 416
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
【java-数据结构19-队列的模拟实现】
2302_80519942的博客
05-21 377
（这个才是重点）同上，没有元素直接返回即可，只有一个元素（全部置空），普通情况（rear等于前驱，rear置为空），
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1025
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
shijialeya
05-18 403
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
Spring6基础笔记
最新发布
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 538
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Solon 的 InjectGather 在 AppContext 里起到了什么作用？
Itmastergo的博客
05-20 567
Solon是一款轻量级的Java开发框架，其设计理念简单且易于使用，主要应用于微服务和现代化的Java应用开发。Solon框架的核心目标是提供一个高效且简洁的开发环境，使开发者能够快速构建和部署应用程序。在Solon框架中，AppContext是核心上下文，它管理着整个应用程序的生命周期，包括bean的注册、依赖注入、事件管理等。AppContext是一个应用程序的核心容器，类似于Spring中的。Bean管理：负责注册和管理应用程序中的所有bean。依赖注入：提供自动化的依赖注入机制。事件管理。
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 218
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
java 上传文件_JAVA学习笔记——fileUpload文件上传
05-17
文件上传是Web开发中常见的功能之一，Java中也提供了多种方式来实现文件上传。其中，一种常用的方式是通过Apache的commons-fileupload组件来实现文件上传。 以下是实现文件上传的步骤： 1.在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.3</version> </dependency> ``` 2.在前端页面中添加文件上传表单： ```html <form method="post" enctype="multipart/form-data" action="upload"> <input type="file" name="file"> <input type="submit" value="Upload"> </form> ``` 3.在后台Java代码中处理上传文件： ```java // 创建一个DiskFileItemFactory对象，用于解析上传的文件 DiskFileItemFactory factory = new DiskFileItemFactory(); // 设置缓冲区大小，如果上传的文件大于缓冲区大小，则先将文件保存到临时文件中，再进行处理 factory.setSizeThreshold(1024 * 1024); // 创建一个ServletFileUpload对象，用于解析上传的文件 ServletFileUpload upload = new ServletFileUpload(factory); // 设置上传文件的大小限制，这里设置为10MB upload.setFileSizeMax(10 * 1024 * 1024); // 解析上传的文件，得到一个FileItem的List集合 List<FileItem> items = upload.parseRequest(request); // 遍历FileItem的List集合，处理上传的文件 for (FileItem item : items) { // 判断当前FileItem是否为上传的文件 if (!item.isFormField()) { // 获取上传文件的文件名 String fileName = item.getName(); // 创建一个File对象，用于保存上传的文件 File file = new File("D:/uploads/" + fileName); // 将上传的文件保存到指定的目录中 item.write(file); } } ``` 以上代码中，首先创建了一个DiskFileItemFactory对象，用于解析上传的文件。然后设置了缓冲区大小和上传文件的大小限制。接着创建一个ServletFileUpload对象，用于解析上传的文件。最后遍历FileItem的List集合，判断当前FileItem是否为上传的文件，如果是，则获取文件名，创建一个File对象，将上传的文件保存到指定的目录中。 4.文件上传完成后，可以给用户一个提示信息，例如： ```java response.getWriter().write("File uploaded successfully!"); ``` 以上就是使用Apache的commons-fileupload组件实现文件上传的步骤。需要注意的是，文件上传可能会带来安全隐患，因此在处理上传的文件时，需要进行严格的校验和过滤。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值