【Java中级】10章、内部类、局部内部类、匿名内部类、成员内部类、静态内部类的基本语法和细节讲解配套例题巩固理解【5】

news2025/4/25 15:57:35

❤️ 【内部类】干货满满，本章内容有点难理解，需要明白类的实例化，学完本篇文章你会对内部类有个清晰的认知
💕 内容涉及内部类的介绍、局部内部类、匿名内部类(重点)、成员内部类、静态内部类
🌈 跟着B站一位老师学习的内部类内容，先写这篇文章为学习内部类的小伙伴提供思路支持，希望可以一起感受java的魅力，爱上java编程！！！

文章目录

  • 1、内部类
    • 1.1、快速入门
    • 1.2、内部类的分类
      • 1.2.1、局部内部类的使用
    • 1.3、匿名内部类！！！！
    • 1.4、匿名内部类-最佳实践
    • 1.5、成员内部类
      • 作用域
    • 1.6、静态内部类
    • 1.7、小结
    • 1.8、一道小小题
  • 共勉

1、内部类

内部类基本介绍：一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员。
其中类的五大成员为：变量、方法、构造器、代码块和内部类

内部类的最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

在这里插入图片描述
在这里插入图片描述

1.1、快速入门

了解内部类的结构

  • 外部类Outer中内嵌一个内部类Inner
package com.fhsedu.innerclass;

public class InnerClass01 {//外部其他类
    public static void main(String[] args) {
        
    }
}
class Outer{//外部类
    private int n1 = 100;//属性
    public Outer(int n1) {
        this.n1 = n1;
    }
    {//代码块
        System.out.println("代码块...");
    }
    class Inner{//内部类，在Outer类的内部

    }
}

1.2、内部类的分类

  • 匿名内部类—>重点！！！！

1.2.1、局部内部类的使用

package com.fhsedu.innerclass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("this is outer02 m2()");
    }//私有方法
    public void m1() {//方法
        //1、局部内部类是定义在外部类的局部位置，通常在方法
        //3、不能添加访问修饰符，但是可以使用final 修饰
        //4、作用域：仅仅在定义它的方法或代码中
        final class Inner02{//局部内部类（本质任然是一个类)
            //2、可以直接访问外部类的所有成员，包括私有的
            public void f1() {
                //5、局部内部类可以直接访问外部类的成员、比如下面 外部类属性n1 和 方法m2()
                System.out.println("n1 = " + n1);
                m2();
            }
        }
        //6、外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
        /*class Inner03 extends Inner02{}*///可以的
    }
}

记住：

  1. 局部内部类定义在方法中/代码块
  2. 作用域在方法体或者代码块中
  3. 本质仍然是一个类
  1. 外部其他类----> 不能访问局部内部类(因为 局部内部类地位是一个局部变量,就好像private修饰的属性只能提供共有的get方法才能访问)
  2. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类命.this.成员)去访问

System.out.println("外部类的n2=" + 外部类命.this.n2);

代码演示获取Outer的属性：


class Outer02 {//外部类
    private int n1 = 100;

    public void m1() {//方法
        final class Inner02 {//局部内部类（本质任然是一个类)
            //2、可以直接访问外部类的所有成员，包括私有的
            private int n1 = 800;

            public void f1() {
                //   如果想访问外部类的成员，则可以使用(外部类命.this.成员)去访问
                //  解读： Outer02.this 本质就是外部类的对象，即：哪个对象调用了m1，Outer02就是哪个对象
                System.out.println("n1 = " + n1 + "外部类属性=" + Outer02.this.n1);
                System.out.println("Outer02.this 的 Hashcode=" + Outer02.this.hashCode());
            }
        }
    }
}

在这里插入图片描述

1.3、匿名内部类！！！！

Anonymous:匿名的

思考一个小问题：为什么java接口不能被实例化?

Java中的接口不能被实例化‌
这是因为接口是一种抽象类型，它定义了一组方法的签名，但不包含任何方法的实现。接口的主要目的是规定类应该实现哪些方法，而不是提供一个具体的实现。因此，接口本身并不能被实例化，也就是说不能使用new关键字来实例化一个接口。接口只能被类实现，并且类必须实现接口中定义的所有方法。然后通过类的实例来调用接口中定义的方法。

接口IA：定义了一个抽象方法cry()

interface IA{
    void cry();
}

定义一个主类

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

外部类和匿名内部类

class Outer04{//内部类
    private int n1 = 10;//属性
    public void method() {//方法
        //基于接口的匿名内部类
        //匿名内部类使用一次，就不能再使用
        //  即不能  new tiger$1()
        IA tiger = new IA(){
            @Override
            public  void cry() {
                System.out.println("老虎...");
            }
        };
        tiger.cry();
        IA dog = new IA(){
            @Override
            public void cry() {
                System.out.println("小狗...");
            }
        };
        dog.cry();
        
        //打印两个匿名内部类的类类型
        //dog的运行类型:class com.fhsedu.Outer04$1
		System.out.println("dog的运行类型:" + dog.getClass());
		//cat的运行类型:class com.fhsedu.Outer04$2
        System.out.println("cat的运行类型:" + cat.getClass());
    }
}

小结：

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

new  类或接口(参数列表){
		类体;
};

小结：

  1. 本质是类，内部类
  2. 该类没有名字，同时还是一个对象
  3. 可以直接访问外部类的所有成员，包括私有的
  4. 不能添加访问修饰符，因为它的地位就是一个局部变量。
  5. 作用域：仅仅在定义它的方法或代码块中。
  6. 匿名内部类—>访问---->外部类成员【访问方式：直接访问或外部类名.this.属性】
  7. 外部其他类---->不能访问---->匿名内部类【因为匿名内部类地位就是一个局部变量】
  8. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问

1.4、匿名内部类-最佳实践

Exercise01

package com.fhsedu.innerclass;

public class AnonymousInnerClassExercise01 {
    public static void main(String[] args) {
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("this is a picture!!!");
            }
        });
        //传统方法
        f1(new Picture());
    }
    //静态方法，形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}
//接口
interface IL {
    void show();
}
//传统方法-》类实现IL-》编程领域(硬编码)
class Picture implements IL {

    @Override
    public void show() {
        System.out.println("this is a picture!");
    }
}

在这里插入图片描述

在这里插入图片描述

自己可以先思考一下实现思想，重要的是培养编程思维

代码实现

  • 接口
//定义一个接口
interface Bell{
    //默认抽象方法
    void ring();
}
//定义一个类
class Cellphone{
    //参数是Bell
    public void alarmClock(Bell bell){
            bell.ring();
    }
}
  • 实现类
public class homework02 {
    public static void main(String[] args) {
        //创建一个对象，并调用它里面的alarmClock(..)方法,
        //  进行传入一个匿名内部类
        new Cellphone().alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println(this.getClass());
                System.out.println("小伙伴，别熬夜了！");
            }
        });
		//跟上面一样
        new Cellphone().alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println(this.getClass());
                System.out.println("明天吃火锅！");
            }
        });

    }
}

在这里插入图片描述
(这里我把接口也打印出来了，复习一下接口的名字)

  • 如果有两个类：类1 和 类2 都有匿名内部类，那么分别为各自的类起名字（Java内部）如：类1种的匿名内部类为 Outer$1、Outer$2 此时下面的为：Inner$1、Inner$2。。。
  • 匿名内部类中编译类型是赋予的，运行类型是系统给的

1.5、成员内部类

说明：成员内部是定义在外部类的成员位置，并且没有static修饰

  1. 可以直接访问外部类的所有成员
  2. 可以添加访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员

代码演示

package com.fhsedu.innerclass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
    }
}
class Outer08 {//外部类
    private int n1 = 10;
    public String name = "张三";
    class Inner08{//成员内部类
        public void say() {
            //成员内部类可以访问所有外部类的成员、包含私有的
            System.out.println("Outer08 的 n1 =" +
                    Outer08.this.n1 + "Outer08 的 name = " + Outer08.this.name);
        }
    }
    public void t1() {
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

成员内部类的使用：在外部类创建方法创建对象调用方法
在这里插入图片描述

作用域

作用于和外部类的其他成员一样，为整个类体
比如之前我们在外部类的成员方法中创建成员内部类对象，再调用对象

  • 外部其他类访问内部类
package com.fhsedu.innerclass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
		//外部类自己的方法直接调用
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类，使用成员内部类的三种方式
        //new Inner08();错误方法
        //第一种语法，不要特别的纠结
        //Outer08.new Inner08()
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        
        //第二种方法：
        //在外部类中创建一个方法用于返回匿名内部类
        Outer08.Inner08 inner08Instance = outer08.getInner08();
        inner08Instance.say();
    }
}
class Outer08 {//外部类
    private int n1 = 10;
    public String name = "张三";
    protected class Inner08{//成员内部类  //可以使用访问修饰符
        public void say() {
            //成员内部类可以访问所有外部类的成员、包含私有的
            System.out.println("Outer08 的 n1 =" +
                    Outer08.this.n1 + "Outer08 的 name = " + Outer08.this.name);
        }
    }
    public Inner08 getInner08() {
        return new Inner08();
    }
    public void t1() {
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

重要的事情说三遍！！！
如果外部类和内部类成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员)去访问。

代码演示

（看高亮块）

1.6、静态内部类

  • 静态类只能访问静态成员

  1. 静态内部类—>访问—>外部类(静态属性)【访问方式：直接访问所有静态成员】
  2. 外部类—>访问—>静态内部类 访问方式：创建对象，再访问

外部其他类访问静态内部类：

  • 外部类访问静态内部类，跟之前的不一样


外部类&&内部类

class Outer10 {
    private int n1 = 10;
    private static String name = "张三";

    private static void cry() {
        System.out.println("cry静态成员方法");
    }

    //Inner10就是静态内部类
    //1、放在外部类的成员位置
    //2、使用static 修饰
    //3、可以直接访问外部类的所有静态成员包括私有的，但不能直接访问非静态成员
    //4、可以添加任意访问修饰符（public、protected、默认、private）因为它的地位就是一个成员
     static class Inner10 {
        public void say() {
            cry();
            System.out.println(name);
        }

    }

    public void m1() {
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
    public Inner10 getInner10() {//非静态的可以访问静态和非静态
        return new Inner10();
    }
    public static Inner10 getInner10_() {//静态只能访问静态
        return new Inner10();
    }
 }

测试类

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();

        //外部其他类 使用静态内部类
        //方式1
        //因为静态内部类，是可以通过哦类命直接访问（前提是满足访问权限）
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式2
        Outer10.Inner10 inner101 = outer10.getInner10();
        inner101.say();

        Outer10.Inner10 inner10_ = Outer10.getInner10_();//访问静态的
        inner10_.say();

    }
}

注意细节点
在这里插入图片描述

7.如果外部类和静态内部类的成员重名时，静态内部类(之前是局部内部类和匿名内部类)访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问

  • 此时不用加this了，因为访问的是静态的

在这里插入图片描述

1.7、小结

小结：

  1. 内部类有四种 局部内部类，匿名内部类，成员内部类，静态内部类
  2. 重点还是掌握 匿名内部类使用
    1. new 类/接口（参数列表）{ //… }
  3. 成员内部类，静态内部类 是放在外部类的成员位置，本质就是一个成员
  4. 其他细节：看笔记…

1.8、一道小小题

在这里插入图片描述

分别指向不同的对象空间：答案：5，5

package com.fhsedu;

public class Test_ {
    public Test_() {
        Inner s1 = new Inner();
        s1.a = 10;
        Inner s2 = new Inner();
        System.out.println(s2.a);
    }

    class Inner {
        public int a = 5;
    }

    public static void main(String[] args) {
        Test_ t = new Test_();//5
        Inner r = t.new Inner();
        System.out.println(r.a);//5
    }
}

共勉

整理心情，再次出发！！！
老黄牛精神，持之以恒坚持
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2327125.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

swift-7-汇编分析闭包本质

swift-7-汇编分析闭包本质

一、汇编分析 fn1里面存放的东西 func testClosure2() {class Person {var age: Int 10}typealias Fn (Int) -> Intvar num 0func plus(_ i: Int) -> Int {num ireturn num}return plus} // 返回的plus和num形成了闭包var fn1 getFn()print(fn1(1)) // 1print(fn1(…
阅读更多...
Linux: 进程信号初识

Linux: 进程信号初识

目录 一 前言 二 信号的感性认识 三 信号处理常见方式 四 系统信号列表 五 信号的保存 六 信号的产生 1. 通过终端按键产生信号 2. 通过系统调用向进程发送信号 3. 硬件异常产生信号 4. 软件条件产生信号 一 前言 在Linux操作系统中，进程信号是一个非常重…
阅读更多...
CSS--解决float: right在空间不够时会自动往下移的问题

CSS--解决float: right在空间不够时会自动往下移的问题

原文网址：CSS--解决float: right在空间不够时会自动往下移的问题-CSDN博客 简介 众所周知，float: right在空间不够时会自动往下移。那么怎样让它不要往下移呢？本文介绍解决方案。 需求 我想写一个无需列表，每个列表后边跟一个…
阅读更多...
深度学习 Deep Learning 第14章 自编码器

深度学习 Deep Learning 第14章 自编码器

深度学习 Deep Learning 第14章 自编码器 内容概要 本章深入探讨了自编码器（Autoencoders），这是一种用于特征学习和降维的神经网络架构。自编码器通过编码器和解码器两个部分，将输入数据映射到一个内部表示（编码&…
阅读更多...
C++(匿名函数+继承+多态)

C++(匿名函数+继承+多态)

#include <iostream> #include <cstring> #include <cstdlib> #include <unistd.h> #include <sstream> #include <vector> #include <memory>using namespace std;// 基类 Weapon class Weapon { protected:int atk; public:Weapon…
阅读更多...
软考中级网络工程师第十一章网络管理

软考中级网络工程师第十一章网络管理

11-1考点分析 11-2网络管理基础&#xff08;记忆&#xff09; 网络管理体系结构 网络管理五大功能域&#xff1a;故障管理、配置管理、计费管理、性能管理和安全管理。 助记&#xff1a; “安配能计障” 故障管理&#xff1a;尽快发现故障&#xff0c;找出故障原因&#x…
阅读更多...
创维E900V22C／E900V22D_S905L3(B)_安卓9.0_指示灯正常_线刷固件包

创维E900V22C／E900V22D_S905L3(B)_安卓9.0_指示灯正常_线刷固件包

创维E900V22C&#xff0f;E900V22D_S905L3(B)_安卓9.0_指示灯正常_线刷固件包 线刷方法&#xff1a;&#xff08;新手参考借鉴一下&#xff09; 1、准备好一根双公头USB线刷刷机线&#xff0c;长度30-50CM长度最佳&#xff0c;同时准备一台电脑&#xff1b; 2、电脑上安装好刷…
阅读更多...
“京数青算“启新篇|北方算网与海东市数据局签署合作协议

“京数青算“启新篇|北方算网与海东市数据局签署合作协议

近日&#xff0c;青海省海东市2025年“京数青算”推介会在北京召开。海东市委常委、副市长梁荣勃&#xff0c;海东市数据局局长安志忠出席会议&#xff0c;北方算网副总经理&#xff08;主持工作&#xff09;喻一鸣等60余家人工智能企业的代表参会。 梁荣勃在致辞中代表海东市…
阅读更多...
QML输入控件: Slider的高级外观定制（音视频控制条）

QML输入控件: Slider的高级外观定制（音视频控制条）

目录 引言相关阅读示例1&#xff1a;基础样式定制要点效果 示例2&#xff1a;音量控制滑块要点效果 示例3&#xff1a;视频进度条要点效果 解决问题总结工程下载 引言 在现代用户界面设计中&#xff0c;滑块控件(Slider)是一个不可或缺的交互元素。它不仅能让用户直观地进行数…
阅读更多...
密码学基础——古典密码学

密码学基础——古典密码学

目录 一、定义 特点&#xff1a; 二、发展阶段 三、代换密码 1.单表代换密码 1.1恺撒密码 1.2 移位变换 1.3 仿射变换 2.多表代换密码 维吉尼亚密码 四、置换密码 栅栏密码 一、定义 古典密码学是指在现代密码学出现之前&#xff0c;使用较为简单的数学方法和手工…
阅读更多...
KingbaseES物理备份还原之备份还原

KingbaseES物理备份还原之备份还原

此篇续接上一篇<<KingbaseES物理备份还原之物理备份>>,上一篇写物理备份相关操作,此篇写备份还原的具体操作步骤. KingbaseES版本:V009R004C011B003 一.执行最新物理备份还原 --停止数据库服务,并创建物理备份还原测试目录 [V9R4C11B3192-168-198-198 V8]$ sys_ct…
阅读更多...
jdk21新特性详解使用总结

jdk21新特性详解使用总结

jdk21新特性详解总结 1.StringBuilder和StringBuffer新增了一个repeat方法 /*** Java 21的StringBuilder和StringBuffer新增了一个repeat方法*/public static void repeatStr(){var sbnew StringBuilder().repeat("*",10);System.out.println(sb);}运行结果如下&…
阅读更多...
【实用技巧】电脑重装后的Office下载和设置

【实用技巧】电脑重装后的Office下载和设置

写在前面&#xff1a;本博客仅作记录学习之用&#xff0c;部分图片来自网络&#xff0c;如需引用请注明出处&#xff0c;同时如有侵犯您的权益&#xff0c;请联系删除&#xff01; 文章目录 前言下载设置总结互动致谢参考目录导航 前言 在数字化办公时代&#xff0c;Windows和…
阅读更多...
206. 反转链表 92. 反转链表 II 25. K 个一组翻转链表

206. 反转链表 92. 反转链表 II 25. K 个一组翻转链表

leetcode Hot 100系列 文章目录 一、翻转链表二、反转链表 II三、K 个一组翻转链表总结 一、翻转链表 建立pre为空&#xff0c;建立cur为head&#xff0c;开始循环&#xff1a;先保存cur的next的值&#xff0c;再将cur的next置为pre&#xff0c;将pre前进到cur的位置&#xf…
阅读更多...
离线语音识别 （ 小语种国家都支持）可定制词组

离线语音识别 （ 小语种国家都支持）可定制词组

1产品介绍 离线语音模组采用神经网络算法&#xff0c;支持语音识别、自学习等功能。运用此模组将 AI 技 术赋能产品&#xff0c;升级改造出语音操控的智能硬件 ( 例如风扇、台灯、空调、马桶、按摩椅、运 动相机、行车记录仪等 ) 。支持全球多种语言识别&#xff0c;如中文…
阅读更多...
网络华为HCIA+HCIP 策略路由，双点双向

网络华为HCIA+HCIP 策略路由，双点双向

目录 路由策略&#xff0c;策略路由 策略路由优势 策略路由分类 接口策略路由 双点双向 双点双向路由引入特点: 联系 路由回灌和环路问题 路由策略&#xff0c;策略路由 路由策略:是对路由条目进行控制&#xff0c;通过控制路由条目影响报文的转发路径&#xff0c;即路…
阅读更多...
【TI MSPM0】ADC DAC学习

【TI MSPM0】ADC DAC学习

一、样例展示 通过ADC0触发单次采样&#xff0c;如果采样结果大于0.5倍的VDD&#xff0c;就点亮LED 否则熄灭LED 编译加载运行这个历程&#xff0c;提供一个电压到A0_2引脚上,电压范围在0-VCC之间同时观察LED1.在上电后&#xff0c;默认将ADC配置到正确的引脚模式&#xff0c;…
阅读更多...
Cesium系列：从入门到实践，打造属于你的3D地球应用

Cesium系列：从入门到实践，打造属于你的3D地球应用

一、Cesium简介 CesiumJS 是一个开源的 JavaScript 库&#xff0c;它能够帮助开发者创建出具有卓越性能、高精度、出色视觉质量和易用性的世界级 3D 地球仪和地图。无论是在航空航天领域&#xff0c;用于模拟飞行路径和展示卫星数据&#xff1b;还是在智能城市中&#xff0c;用…
阅读更多...
Linux系统程序设计：从入门到高级Day01

Linux系统程序设计：从入门到高级Day01

知识点1 【系统调用】 系统调用的概述 系统调用&#xff1a;内核 提供给 用户 可以 操作内核 的一组函数接口 关系&#xff1a;用户 借助 系统调用 操作内核 进程的空间分为&#xff1a;内核空间 和 用户空间 用户一般都是在用户空间操作的&#xff0c;但是有的时候用户需要…
阅读更多...
openEuler24.03 LTS下安装HBase集群

openEuler24.03 LTS下安装HBase集群

前提条件 安装好Hadoop完全分布式集群&#xff0c;可参考&#xff1a;openEuler24.03 LTS下安装Hadoop3完全分布式 安装好ZooKeeper集群&#xff0c;可参考&#xff1a;openEuler24.03 LTS下安装ZooKeeper集群 HBase集群规划 node2node3node4MasterBackup MasterRegionServ…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023