JavaSE-11 【内部类】

news2024/11/18 1:26:48

文章目录

  • JavaSE-11 【内部类】
  • 第一章 成员内部类和局部内部类
    • 1.1 四种权限修饰符
    • 1.2 内部类的概念和分类
    • 1.3 成员内部类的定义格式
    • 1.4 成员内部类的使用
    • 1.5 内部类的同名变量访问
    • 1.6 局部内部类定义
    • 1.7 局部内部类的final问题
  • 第二章 匿名内部类
    • 2.1 匿名内部类
    • 2.2 匿名内部类的注意事项
    • 2.3 类作为成员变量类型
    • 2.4 接口作为成员变量类型

JavaSE-11 【内部类】

第一章 成员内部类和局部内部类

1.1 四种权限修饰符

  • 1、private：可以修饰成员变量和成员方法.被修饰的成员只能在本类中访问.其他类不能直接访问
  • 2、default：它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问
  • 3、protected： 当前类或子类可以访问，同时相同包内的其他类也可以访问protected成员；
  • 4、public： 它具有最大的访问权限，可以访问任何一个在类路径下的类、接口、异常等。

四种权限修饰符的访问权限

  • 在同一个类当中使用public、protected、（default）、private修饰的成员变量或者成员方法，都可以直接访问或调用类中的成员变量或者成员方法

  • 在同一个包中的两个不同类时，使用public、protected、（default）修饰的成员变量或者成员方法，可以直接访问或调用两个类中的成员变量或者成员方法

  • 在某一个类和不同包的子类，使用public、protected修饰的成员变量或者成员方法，可以直接访问或调用两个类中的成员变量或者成员方法

  • 在某一个类和不同包的非子类中，使用public修饰的成员变量或者成员方法，可以直接访问或调用两个类中的成员变量或者成员方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FwDLpdQ6-1687769389555)(photo/JavaSE11_内部类.assest/1664966769356.png)]

1.2 内部类的概念和分类

  • 内部类：如果一个事物的内部包含另一个事物，那么它就是一个类内部包含了另一个类
  • 分类：
    • 1、成员内部类
    • 2、局部内部类 （局部内部类包含匿名内部类）

1.3 成员内部类的定义格式

  • 定义格式
  修饰符 class 外部类名称{
      修饰符 class 内部类名称{
          //...
      }
     //...
  }
  • 访问规则：内用外，随意访问。外用内，需要内部类对象

1.4 成员内部类的使用

  • 使用成员内部类的两种方式
    • 1、间接方式：在外部类的方法中，使用内部类
    • 2、直接方式：直接使用成员内部类对象
  • 创建内部类对象的格式
    • 外部类名称.内部类名称 对象名称 = new 外部类名称().new 内部类名称();
public class OuterClassA {
    //成员属性
    private String name;
    //成员方法
    public void methodA(){
        System.out.println("我是外部类的方法");
        //在外部类的方法中创建内部类对象
        InnerClassA innerA = new InnerClassA();
        //调用内部类的方法
        innerA.methodB();
    }
    //成员内部类
    public class InnerClassA{
        //定义成员内部类的方法
        public void methodB(){
            System.out.println("我是成员内部类的成员方法");
            //内部类访问外部类的成员变量
            System.out.println("name的值是："+name);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 /**  成员内部类的定义格式
 *  修饰符 class 外部类名称{
 *      修饰符 class 内部类名称{
 *          //...
 *      }
 *      //...
 *  }
 *  注意事项：内用外，随意访问。外用内，需要内部类对象
 *
 *  使用成员内部类的两种方式：
 *  1、间接方式：在外部类的方法中，使用内部类
 *  2、直接方式：直接使用成员内部类对象
 *      格式：外部类名称.内部类名称 对象名称 = new 外部类名称().new 内部类名称();
 */
public class TestInnerClassA {
    public static void main(String[] args) {
        //方式一：间接方式
        OuterClassA outerA = new OuterClassA();
        outerA.setName("Tom");
        //通过外部类的对象调用外部类的成员方法，同时间接调用方法中的内部类
        outerA.methodA();

        System.out.println("------------------");

        //方式二：直接使用
        //创建内部类对象吧
        OuterClassA outerB = new OuterClassA();
        outerB.setName("Anny");
        //OuterClassA.InnerClassA innerClassA = new OuterClassA().new InnerClassA();
        OuterClassA.InnerClassA innerClassA = outerB.new InnerClassA();
        //调用内部类的成员方法
        innerClassA.methodB();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Ce2qS0e-1687769389556)(photo/JavaSE11_内部类.assest/1664969746232.png)]

1.5 内部类的同名变量访问

  • 内部类的同名变量：即外部类的成员变量、内部类的成员变量、内部类的局部变量，三者重名
  • 内部类访问外部类的成员变量的格式 ： 外部类名称.this.外部类成员变量名
public class OuterClassB {
    int num = 100;//外部类的成员变量
    //成员内部类
    public class InnerClassB{
        int num = 200;//内部类的成员变量
        public void methodInner(){
            int num = 300;//内部类的局部变量
            System.out.println("内部类局部变量："+num);//局部变量 就近原则
            System.out.println("内部类成员变量："+this.num);//内部类的成员变量
            System.out.println("外部类成员变量："+OuterClassB.this.num);//外部了的成员变量
        }
    }
}

/**
 * 内部类的同名变量访问
 *  内部类访问外部类的成员变量的格式
 *  格式：外部类名称.this.变量名
 */
public class TestInnerClassB {
    public static void main(String[] args) {
        //创建内部类对象
        //外部类名称.内部类名称 对象名称 = new 外部类名称().new 内部类名称();
        OuterClassB.InnerClassB innerClassB = new OuterClassB().new InnerClassB();
        //调用内部类的方法
        innerClassB.methodInner();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EQ0CsXrJ-1687769389556)(photo/JavaSE11_内部类.assest/1664969934620.png)]

1.6 局部内部类定义

  • 概念：如果一个类是定义在外部类的成员方法中，那么这个类就是局部内部类
  • 作用域：外部类的成员方法内，且局部内部类的对象只能在外部类的成员方法内创建
  • 格式：
修饰符 class 外部类{
    修饰符 返回值类型 方法名（参数列表）{
         class 局部内部类名称{
              //...
         }
    }
}

public class OuterA {
    //外部类的成员方法
    public void methodOuter(){
        //局部内部类
        class InnerA{
            //局部内部类成员变量
            int num = 100;
            //局部内部类成员方法
            public void methodInnerA(){
                System.out.println("我是局部内部类中的成员方法");
                System.out.println("局部内部类成员变量: "+num);//100
            }
        }

        //创建局部内部类对象(在外部类的成员方法范围内)
        InnerA innerA = new InnerA();
        //调用方法
        innerA.methodInnerA();
    }
}

public class TestOuterA {
    public static void main(String[] args) {
        //创建外部类对象
        OuterA outerA = new OuterA();
        //调用外部类的成员方法
        outerA.methodOuter();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bTrHi6VI-1687769389556)(photo/JavaSE11_内部类.assest/1664970599473.png)]

1.7 局部内部类的final问题

  • 局部内部类，如果想访问所在成员方法中的局部变量，那么这个局部变量必须是有效的final的
  • 从Java8开始，只要局部变量事实不变，那么final关键字可以省略
  • 原因
    • 1、new的对象存储在堆内存中
    • 2、局部变量跟着方法走。存储于栈内存中
    • 3、方法运行结束后，执行出栈操作，局部变量就会跟着立即消失
    • 4、但是new出来的对象会在堆内存中持续存在，直到垃圾回收器回收
    • 5、所以局部变量如果不用final修饰，那么在局部变量消失之后，局部内部类对象无法获取
    • 6、故而局部变量使用final修饰，存放在常量区，可以随时访问使用
public class OuterClass {
    public void methodA(){
        final int num1 = 100;
        int num2 = 100;//未改变，可以访问获取
        //num2 =200;//以改变 无法访问获取
        class InnerClass{
            public void methodB(){
                System.out.println(num1);
                System.out.println(num2);
            }
        }
    }
}

第二章 匿名内部类

2.1 匿名内部类

  • 匿名内部类
    • 如果接口的实现类，或者父类的子类，只需要使用一次
    • 那么这种情况下就可以省略掉实现类或子类的定义，改为使用匿名内部类
  • 匿名内部类定义格式：
   接口名称 对象名 = new 接口名称(){
       //覆盖重写所有的抽象方法
   };
  • 格式解析：
    • 1、new 代表创建接口实现类对象的动作
    • 2、接口名称就是匿名内部类需要实现的那个接口
    • 3、{…}才是匿名内部类的内容。也就是接口的无名称的实现类

2.2 匿名内部类的注意事项

  • 注意事项
    • 1、匿名内部类在创建对象的时候，只能使用唯一一次
    • 2、若果重写的抽象方法有多个，就不能使用简化写法
    • 3、匿名对象是匿名内部类的一个具体实现
/**
 * 定义接口以及抽象方法
 */
public interface AnonymousInnerInterface {
    public abstract void method1();
}

/**
 * 实现类
 */
public class AnonymousInnerInterfaceImpl implements AnonymousInnerInterface {
    @Override
    public void method1() {
        System.out.println("实现类重写了接口的抽象方法");
    }
}

public class TestAnonymousInner {
    public static void main(String[] args) {
        //普通方式
        AnonymousInnerInterfaceImpl impl1 = new AnonymousInnerInterfaceImpl();
        AnonymousInnerInterface impl2 = new AnonymousInnerInterfaceImpl();
        impl1.method1();
        impl2.method1();

        System.out.println("-------------------------------------------");

        //匿名内部类方式
        AnonymousInnerInterface impl3 = new AnonymousInnerInterface() {
            @Override
            public void method1() {
                System.out.println("使用匿名内部类的形式重写了抽象方法---AAA");
            }
        };
        //通过对象名，调用方法
        impl3.method1();

        System.out.println("--------------------------------------------");

        //匿名内部类简化写法--省略对象名接收
        new AnonymousInnerInterface(){
            @Override
            public void method1() {
                System.out.println("使用匿名内部类的形式重写了抽象方法---AAA");
            }
        }.method1();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aK0VCd08-1687769389557)(photo/JavaSE11_内部类.assest/1664975329586.png)]

2.3 类作为成员变量类型

**
* 类作为成员变量类型
*/
public class HeroRole {
   private String name;//英雄名称
   private int age;//英雄年龄
   private Arms arms;//武器

   public HeroRole() {
   }

   public HeroRole(String name, int age, Arms arms) {
       this.name = name;
       this.age = age;
       this.arms = arms;
   }

   //英雄攻击的方法
   public void attack(){
       System.out.println("英雄："+name+",年龄："+age+",使用武器是："+arms.getArmsName());
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public Arms getArms() {
       return arms;
   }

   public void setArms(Arms arms) {
       this.arms = arms;
   }
}

public class Arms {
    private String armsName;//武器名称

    public Arms() {
    }

    public Arms(String armsName) {
        this.armsName = armsName;
    }

    public String getArmsName() {
        return armsName;
    }

    public void setArmsName(String armsName) {
        this.armsName = armsName;
    }
}

public class TestHero {
    public static void main(String[] args) {
        //创建英雄角色
        HeroRole heroRole = new HeroRole();
        //设置英雄名称
        heroRole.setName("金克斯");
        //设置英雄年龄
        heroRole.setAge(18);
        //创建武器对象
        Arms arms = new Arms("无尽之刃");
        //为英雄设置武器
        heroRole.setArms(arms);
        //调用攻击的方法
        heroRole.attack();
    }
}

2.4 接口作为成员变量类型

/**
 * 接口作为成员变量类型
 */
public class HeroRole {
    private String name;//英雄的名称
    private Skill skill;//英雄的技能

    public HeroRole() {
    }

    public HeroRole(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    //英雄的攻击方法
    public void attack(){
        System.out.println("开始释放技能");
        skill.use();//释放的具体技能
        System.out.println("技能释放完成");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

public interface Skill {
    //使用技能的方法
    public abstract void use();
}

public class SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("释放的技能是：光之束缚");
    }
}

public class TestHero {
    public static void main(String[] args) {
        /*
            方式一：创建Skill的接口实现类重写方法，并创实现类的对象，
         */
        //创建英雄
        HeroRole heroRole = new HeroRole();
        //设置英雄的名称
        heroRole.setName("光辉女郎");
        //创建技能实现类对象
        SkillImpl skillImpl = new SkillImpl();
        //设置英雄的技能属性
        heroRole.setSkill(skillImpl);
        //调用英雄的攻击方法
        heroRole.attack();

        System.out.println("----------------------");

        /*
            方式二：使用匿名内部类实现
         */
        //创建英雄
        HeroRole heroRole1 = new HeroRole();
        //设置英雄的名称
        heroRole1.setName("亚索");
        //使用匿名内部类创建对象
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("释放的技能是：风墙被动");
            }
        };
        //设置英雄的技能
        heroRole1.setSkill(skill);
        //调用英雄的攻击方法
        heroRole1.attack();

        System.out.println("-----------------------------");

        /*
            方式三：匿名内部类的简写
         */
        HeroRole heroRole2 = new HeroRole();
        heroRole2.setName("德邦总管");
        heroRole2.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("释放的技能是：枪出如龙");
            }
        });
        heroRole2.attack();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQhKmyyj-1687769389557)(photo/JavaSE11_内部类.assest/1664982505284.png)]

`

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

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

相关文章

Sangfor华东天勇战队：shiro注入filter内存马

Sangfor华东天勇战队：shiro注入filter内存马

注入步骤 https://github.com/yyhuni/shiroMemshell&#xff08;实验环境&#xff09; 这里用的 pom.xml加入 <dependency><groupId>org.javassist</groupId><artifactId>javassist</artifactId><version>3.28.0-GA</version> <…
阅读更多...
阿里企业邮箱域名解析MX记录值设置

阿里企业邮箱域名解析MX记录值设置

阿里企业邮箱配置需要为域名添加MX解析记录&#xff0c;不只是MX域名解析记录值&#xff0c;还需要为域名添加pop3、imap、smtp及mail等CNAME解析类型&#xff0c;阿里云百科分享阿里云企业邮箱域名MX解析记录类型、记录值及服务器地址&#xff1a; 目录 新版阿里企业邮箱域名…
阅读更多...
FPGA解码 4K MIPI 视频自定义IP版 纯vhdl实现 CSI2 RX 采集OV13850 提供工程源码和技术支持

FPGA解码 4K MIPI 视频自定义IP版 纯vhdl实现 CSI2 RX 采集OV13850 提供工程源码和技术支持

目录 1、前言2、Xilinx官方主推的MIPI解码方案3、本 MIPI CSI2 模块性能及其优越性4、我这里已有的 MIPI 编解码方案5、vivado工程介绍6、上板调试验证7、福利&#xff1a;工程代码的获取 1、前言 FPGA图像采集领域目前协议最复杂、技术难度最高的应该就是MIPI协议了&#xff…
阅读更多...
div转data:image/svg编码图片

div转data:image/svg编码图片

前言 将div转base64图片 <!DOCTYPE html> <html><head><meta charset"UTF-8"><title>div-svg-base64</title><script type"text/javascript" src"/js/jquery-3.2.1.min.js"></script><scr…
阅读更多...
使用 Jetpack Compose 的 TextButton 组件

使用 Jetpack Compose 的 TextButton 组件

Jetpack Compose 是 Google 推出的一种声明式 UI 框架&#xff0c;它使 Android UI 开发变得更加简单和直观。在本篇博客中&#xff0c;我们将深入探索 Jetpack Compose 中的 TextButton 组件。 一、TextButton的使用 二、自定义TextButton 三、Button和TextButton的区别 一…
阅读更多...
搜索算法特训 ----- Week5/6/7 (它太重要了)

搜索算法特训 ----- Week5/6/7 (它太重要了)

学会二叉树不知道干啥?二叉树的深度优先搜索和广度优先搜索,我要打十个乃至二十个(打开你的LeetCode撸起来)学练并举_二叉树广度优先搜索_小杰312的博客-CSDN博客 上述文章&#xff0c;初步介绍了搜索过程和关于二叉树中进行搜索的很多实例。将搜索的过程写的还是很详细的。很…
阅读更多...
网站出现卡顿是什么原因，要怎么解决？

网站出现卡顿是什么原因，要怎么解决？

&#x1f482; 个人网站:【海拥】【游戏大全】【神级源码资源网】&#x1f91f; 前端学习课程&#xff1a;&#x1f449;【28个案例趣学前端】【400个JS面试题】&#x1f485; 寻找学习交流、摸鱼划水的小伙伴&#xff0c;请点击【摸鱼学习交流群】 目录 前言网站卡顿的原因解决…
阅读更多...
人工智能算法在外卖配送系统中的应用和前景

人工智能算法在外卖配送系统中的应用和前景

随着人们对于外卖服务需求的增加&#xff0c;外卖配送系统的效率和精确度成为了重要的考虑因素。而人工智能算法的出现&#xff0c;则为外卖配送系统提供了更好的解决方案。 一、应用场景 1.1 路线规划 在外卖配送过程中&#xff0c;路线的规划是非常重要的。通过人工智能算…
阅读更多...
一线大厂最全Java面试题及答案整理汇总（2023最新版）

一线大厂最全Java面试题及答案整理汇总（2023最新版）

程序员一步入中年&#xff0c;不知不觉便会被铺天盖地的“危机感”上身&#xff0c;曾经的那个少年已经不在&#xff0c;时间就是这样公平。就算你能发明 Java 语言&#xff0c;随着时间的推移&#xff0c;你注定还是要成为慢慢变蔫的茄子&#xff0c;缓缓变黑的葡萄。 看着金…
阅读更多...
uniapp 自定义发行 动态修改 manifest.json

uniapp 自定义发行 动态修改 manifest.json

这边需求是&#xff1a;根据不同的打包环境 设置不同的标题以及路径。方便各种调试。防止 每次手动每次修改 manifest.json 出错 uniapp 自定义发行: 添加自定义发行之后 Hbuilder 编辑器会自动多 出来按钮&#xff1a; 官方文档&#xff1a;概述 | uni-app官网 我这里的配置是…
阅读更多...
大数据开发基础-环境配置篇-Hadoop集群安装

大数据开发基础-环境配置篇-Hadoop集群安装

鼠鼠接下来将更新一系列自己在学习大数据开发过程中收集的资源、和自己的总结、以及面经答案、LeetCode刷题分析题解。 首先是大数据开发基础篇 环境搭建、组件面试题等 其次是更新大数据开发面经的java面试基础 最后更新一个大数据开发离线数仓的实战项目&#xff0c;自己写入…
阅读更多...
利用R中的corrmorant包绘制精美的相关性热图

利用R中的corrmorant包绘制精美的相关性热图

大家好&#xff0c;我是带我去滑雪&#xff01; 相关性热图 (correlation heatmap) 是一种可视化工具&#xff0c;用于展示数据集中各个变量之间的相关性。它以矩阵的形式显示变量之间的相关系数&#xff0c;并通过色彩编码来表示相关性的强度。在相关性热图中&#xff0c;每个…
阅读更多...
html面试题-概念题汇总

html面试题-概念题汇总

文章目录 html面试题汇总 src和href的区别 HMTL的全局属性有哪些&#xff1f; 超链接访问过后hover样式就不出现的原因是什么&#xff1f;怎么解决&#xff1f; 表单中readonly和disabled属性的区别&#xff1f; iframe的优缺点&#xff1f; 浏览器渲染页面的过程 viewport属性…
阅读更多...
GO channel解析

GO channel解析

GO channel解析 是什么&#xff1f; 官方文档&#xff1a; https://go.dev/ref/spec#Channel_typeshttps://go.dev/blog/pipelines&#xff08;channel提供了流式编程的例子&#xff09; 在 Go 语言中&#xff0c;channel 是一种用于在 goroutine 之间进行通信和同步的机制。…
阅读更多...
【FFmpeg实战】音频解码与编码流程

【FFmpeg实战】音频解码与编码流程

解码流程 音频编解码流程与视频编解码流程一致&#xff0c;我们可以对 mp4 文件的音频流进行解码&#xff0c;并将解码后的音频数据保存到 PCM 文件中&#xff0c;后续我们可以通过读取 PCM 文件中的数据实现音频流的编码操作 FFmpeg音频解码流程 extern"C" { #inc…
阅读更多...
ICC2: Create Placement Blockage

ICC2: Create Placement Blockage

area-based的placement blockage有四种，hard、hard macro、soft，partial。hard 属性限制所有standard cell、hard macro放进hard blockage中；hard macro仅限制hard macro(如sram)；soft属性限制placement的init_place阶段(也叫coarse placement)把standard cell和hard macro…
阅读更多...
Vuex学习

Vuex学习

5.1.理解 Vuex 5.1.1.Vuex 是什么 概念&#xff1a;专门在Vue中实现集中式状态&#xff08;数据&#xff09;管理的一个Vue插件&#xff0c;对Vue应用中多个组件的共享状态进行集中式的管理&#xff08;读/写&#xff09;&#xff0c;也是一种组件间通信的方式&#xff0c;且适…
阅读更多...
深度学习05-CNN循环神经网络

深度学习05-CNN循环神经网络

概述 循环神经网络&#xff08;Recurrent Neural Network&#xff0c;RNN&#xff09;是一种具有循环连接的神经网络结构&#xff0c;被广泛应用于自然语言处理、语音识别、时序数据分析等任务中。相较于传统神经网络&#xff0c;RNN的主要特点在于它可以处理序列数据&#xf…
阅读更多...
超全汇总，性能测试常用指标大全（重要）

超全汇总，性能测试常用指标大全（重要）

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 两种性能指标 业…
阅读更多...
Java又双叒叕“凉”了？

Java又双叒叕“凉”了？

前几天&#xff0c;TIOBE的一份6月编程语言榜单公布&#xff1a;Java退出前三&#xff0c;位居第四。一波Java凉了的言论甚嚣尘上。其实不止Java&#xff0c;python、C、C&#xff0c;哪一个没被提过“凉”... 而现实是&#xff0c;Java的招聘需求依然很大&#xff1a; 不可否…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023