Java 内部类的四种实现方式

最新推荐文章于 2024-04-25 12:25:03 发布
最新推荐文章于 2024-04-25 12:25:03 发布
阅读量2.9k 收藏 18
点赞数 2
分类专栏： Java 文章标签： java 开发语言 内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45834685/article/details/121477434
版权

Java 内部类的四种实现方式

前言

今天的话我将为大家介绍Java的四种内部类，他们分别是普通内部类，静态内部类，局部内部类，匿名内部类。

提示：以下是本篇文章正文内容，下面案例可供参考

一、内部类是什么？

  • 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。

  • 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

二、内部类的分类

2.1 普通内部类

普通内部类-直接将一个类的定义放在另外一个类的类体中。（对象层级）

这种内部类的写法其实和外部类也基本是一致的。

普通内部类的特点：

  • 普通内部类可以使用的关键字为：public，private，protected，final，abstract
  • 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
  • 普通内部类需要使用外部类对象来创建对象。
  • 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。
    语法格式：
访问修饰符 class 外部类的类名{
    访问修饰符 class 内部类的类名{
        内部类的类体;
    }
}

案例：

package com.lagou.task03.generalClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 16:18
 * @description
 */
public class GeneralClass {
    private int cnt;

    public GeneralClass() {
    }

    public GeneralClass(int cnt) {
        setCnt(cnt);
    }

    public int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    public void show() {
        System.out.println("Outer class: " + getCnt());
    }

    // 创建第一种内部类：普通内部类
    public class InnerClass {
        private int cnt;

        public InnerClass() {
        }

        public InnerClass(int cnt) {
            setCnt(cnt);
        }

        public int getCnt() {
            return cnt;
        }

        public void setCnt(int cnt) {
            this.cnt = cnt;
        }

        public void show() {
            // 当内部类和外部类成员变量名相同时
            // 上面三种都是获取 内部类 成员变量的方法
            // 最后一种是获取 外部类 成员变量的方法
            System.out.println("Inner class: " + getCnt());
            System.out.println("Inner class: " + this.getCnt());
            System.out.println("Inner class: " + InnerClass.this.getCnt());
            System.out.println("Outer class: " + GeneralClass.this.getCnt()); // 使用 this 关键字
        }
    }
}

对应的测试类：

package com.lagou.task03.generalClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 16:33
 * @description
 */
public class GeneralClassTest {

    public static void main(String[] args) {

        GeneralClass generalClass = new GeneralClass(3);
        // 使用外部类对象 实例化 内部类对象
        GeneralClass.InnerClass innerClass = generalClass.new InnerClass(33);
        generalClass.show(); // Outer class: 3
        innerClass.show();
        // Inner class: 33
        //Inner class: 33
        //Inner class: 33
        //Outer class: 3
    }
}

运行结果：
在这里插入图片描述

2.2 静态内部类

静态内部类-使用static关键字修饰的内部类，隶属于类层级。（类层级）
语法格式：

访问修饰符 class 外部类的类名{
    访问修饰符 static class 内部类的类名{
        内部类的类体;
    }
}

静态内部类的特点：

  • 静态内部类不能直接访问外部类的非静态成员。
  • 静态内部类可以直接创建对象。
  • 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。

静态内部类调用外部类中的成员变量：

  • 第一种方式可以将静态外部类的类型写为static，然后在静态内部列使用 类名. 的形式引用
  • 第二种方式可以在静态内部类中 new 对象，然后进行引用

案例：

package com.lagou.task03.staticClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 16:41
 * @description
 */
public class StaticClass {
    private static int cnt;
    private int cnt2;

    public StaticClass() {
    }

    public StaticClass(int cnt) {
        setCnt(cnt);
    }

    public static int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    public int getCnt2() {
        return cnt2;
    }

    public void setCnt2(int cnt2) {
        this.cnt2 = cnt2;
    }

    public void show() {
        System.out.println("Outer class: " + getCnt());
    }

    // 创建第二种内部类：静态内部类
    public static class InnerClass {
        private int cnt;

        public InnerClass() {
        }

        public InnerClass(int cnt) {
            setCnt(cnt);
        }

        public int getCnt() {
            return cnt;
        }

        public void setCnt(int cnt) {
            this.cnt = cnt;
        }

        public void show() {
            // 当内部类和外部类成员变量名相同时
            // 上面三种都是获取 内部类 成员变量的方法
            System.out.println("Inner class: " + getCnt());
            System.out.println("Inner class: " + this.getCnt());
            System.out.println("Inner class: " + InnerClass.this.getCnt());
            // 最后一种是获取 外部类 成员变量的方法，
            // 1.静态内部类中调用外部的变量必须也是静态的才行
            System.out.println("Outer class: 静态成员变量 " + StaticClass.getCnt());
            // 2.在静态内部类中 new 外部类的对象，然后进行引用
            StaticClass staticClass = new StaticClass();
            staticClass.setCnt2(555);
            System.out.println("Outer class: 非静态成员变量 " + staticClass.getCnt2());
        }
    }
}

对应的测试代码：

package com.lagou.task03.staticClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 16:49
 * @description
 */
public class StaticClassTest {

    public static void main(String[] args) {

        StaticClass staticClass = new StaticClass(5);
        StaticClass.InnerClass innerClass = new StaticClass.InnerClass(55);
        staticClass.show(); // Outer class: 5
        innerClass.show();
        // Inner class: 55
        //Inner class: 55
        //Inner class: 55
        //Outer class: 静态成员变量 5
        //Outer class: 非静态成员变量 555
    }
}

运行结果：
在这里插入图片描述

2.3 局部内部类

局部内部类-直接将一个类的定义放在方法体的内部时。（方法块层级）
语法格式：

访问修饰符 class 外部类的类名{
    访问修饰符 返回值类型 成员方法名（形参列表）{
        class 内部类的类名{
            内部类的类体;
        }
    } 
}

局部内部类的特点：

  • 局部内部类只能在该方法的内部可以使用。
  • 局部内部类可以在方法体内部直接创建对象。
  • 局部内部类不能使用访问控制符和static关键字修饰符
  • 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

案例：

package com.lagou.task03.areaClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 16:58
 * @description
 */
public class AreaClass {
    private int cnt;

    public AreaClass(int cnt) {
        setCnt(cnt);
    }

    public int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    public void show() {
        System.out.println("Outer class: " + getCnt());

        // 如果 内部类要使用 局部变量，为了保证数据的一致性，将局部变量设置为 final
        // 添加的原因：局部变量比局部内部类的作用范围更大，当局部内部类在使用时，会在底层从局部变量复制一份到局部内部类
        // 如果不使用final，当在局部内部类的外部修改这个变量的值以后，就会造成数据的不一致性
        final int snt = 6666;
        // 局部内部类不需要，也不能使用 访问控制符 和 static 进行修饰
        class InnerClass {
            private int cnt;

            public InnerClass() {
            }

            public InnerClass(int cnt) {
                this.cnt = cnt;
            }

            public int getCnt() {
                return cnt;
            }

            public void setCnt(int cnt) {
                this.cnt = cnt;
            }

            public void show() {
                System.out.println("Inner class: " + getCnt());
                System.out.println("snt : " + snt);
            }
        }

        InnerClass innerClass = new InnerClass(666);
        innerClass.show();
    }
}

对应的测试类：

package com.lagou.task03.areaClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 17:06
 * @description
 */
public class AreaClassTest {

    public static void main(String[] args) {

        AreaClass areaClass = new AreaClass(66);
        areaClass.show();
        // Outer class: 66
        //Inner class: 666
        //snt : 6666
    }
}

运行结果：
在这里插入图片描述

2.4 匿名内部类（最常用）

匿名内部类-就是指没有名字的内部类。
语法格式：

  • 常规写法：
接口/父类类型 引用变量名= new 接口/父类类型() { 方法的重写};
  • lambda写法（Java8之后的特性）
(参数列表) -> (方法体)

案例：

package com.lagou.task03.anonymousClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 17:39
 * @description
 */
public interface AnonymousInterface {

    public void show();
}

对应的测试类：

package com.lagou.task03.anonymousClass;

/**
 * @author 云梦归遥
 * @date 2021/11/22 17:42
 * @description
 */
public class AnonymousInterfaceTest {

    public static void main(String[] args) {

        // 第一种：匿名内部类，常规写法
        AnonymousInterface anonymousInterface = new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("这是 匿名内部类 常规写法");
            }
        };
        anonymousInterface.show(); // 这是 匿名内部类 常规写法

        // 第二种：匿名内部类，lambda写法，更加简单（Java8）
        AnonymousInterface anonymousInterface1 = () -> System.out.println("这是 匿名内部类 lambda写法");
        anonymousInterface1.show(); // 这是 匿名内部类 lambda写法
    }
}

在这里插入图片描述

三，总结

以上就是Java的四种内部类的实现方式，相对来说，匿名内部类会更常用一些，而且匿名内部类如果使用lambda写法会更加的简洁。

好了，本期内容就到这里，谢谢大家。

云梦归遥
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单了解Java多线程实现的四种方式
08-19
Java 多线程实现的四种方式 Java 多线程是 Java 语言中一个非常重要的概念，它允许程序同时执行多个任务，以提高程序的效率和性能。在 Java 中，实现多线程的方式有多种，本文将介绍四种常见的实现方式。 继承 ...
Java静态内部类实现单例过程
08-25
在Java中，有多种实现单例的方式，包括饿汉式、懒汉式、双重检查锁定(DCL)、静态内部类和枚举。这里我们将重点讨论静态内部类和枚举实现单例的过程。 首先，让我们来看看静态内部类实现单例的方式： ```java ...
Java内部类
骑个小蜗牛的博客
02-14 6774
一、内部类的概念 二、内部类的分析 三、内部类的分类 1. 成员内部类 2. 静态内部类 3. 局部内部类 4. 匿名内部类 匿名内部类与Lambda表达式
Java枚举类
yu的博客
02-03 4595
Java的内部类详解（成员内部类、静态内部类、局部内部类、匿名内部类）
Java内部类（静态内部类、匿名内部类等）详解
最新发布
????
04-25 1248
总结了常见的四大内部类（成员内部类、静态内部类、局部内部类、匿名内部类）相关知识，通过写代码详细讲解了静态内部类和匿名内部类，成员内部类和局部内部类使用较少就没有写代码举例。
内部类的四种实现方式
znoone的博客
01-21 2906
内部类分为四种： 1.成员内部类 2.局部内部类 3.静态内部类 4.匿名内部类 1.成员内部类  Java code <!-- Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> //成员内部类......相当于非静态方法
内部类详解
qq_35810741的博客
10-06 552
Java 内部类详解 分类编程技术 一.内部类基础 在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。 1.成员内部类 成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式： class Circle { double radius = 0; public Circle(double r.
java中的内部类简单实现
weixin_67573348的博客
04-14 738
内部类分类：成员内部类 局部内部类 静态内部类 匿名内部类 成员内部类 定义： 在一个类中 定义一个类 为成员内部类（简单理解） 访问特点： （1 ）内部类可以直接访问内部类的成员间，包括私有成员 ( 2 ) 外部类要访问内部类的成员，必须要建立内部类的对象。 访问秘诀： 外部类名.内部类名 对象名 = new 外部类型()...
详细分析Java内部类——局部内部类
08-24
Java内部类是一种特殊的类，它可以嵌套在其他类中，今天我们主要介绍Java局部内部类的相关知识，了解局部内部类的定义、特性和使用场景。 什么是局部内部类？ 局部内部类是定义在代码块、方法体内或作用域中的类。...
Java中匿名类的两种实现方式
08-31
在Java编程语言中，匿名类是一种特殊的类定义方式，它没有名称，并且通常用于简洁地实现特定的功能。本文将深入探讨Java中匿名类的两种主要实现方式：继承一个类和实现一个接口。 首先，让我们来看一下匿名类继承一...
JAVA内部类与异常类实验报告
06-30
总结，这个实验报告深入浅出地介绍了Java内部类的概念及其使用，以及异常处理的基本思想，通过实际的编程练习，有助于提高学生的编程技能和问题解决能力。通过扩展内部类的应用和异常处理的实践，学生可以更好地理解...
Java之内部类
y_k_j_c的博客
06-14 938
类的五大成员：属性，方法，构造器，代码块和内部类内部类字如其名就是在类的内部定义一个类这个类就叫做内部类内部类最大的特点是可以直接访问私有属性，并可以体现类与类之间的包含关系。从种类上说，内部类可以分为四类：首先是定义在外部类的成员位置上的普通内部类（没用static修饰）和静态内部类（使用static修饰）然后是定义在外部类的局部位置上（比如说方法体内）的匿名内部类（无类名）、局部内部类（有类名）我们来一个个看： 在这种定义方式下，成员内部类对象依赖外部类对象而存在，即在创建一个普通内部类对象时首先需
Java中的类以及内部类实现
weixin_43222122的博客
03-07 380
Java中类的定义 Java中类的定义由访问级别、类型、类名、是否抽象、是否静态、泛型标识、继承或实现关键字、父类或接口名称等组成。类的访问级别有pubic和无访问控制符，类型为class、interface、enum。 Java类主要由两部分组成：成员和方法。在定义Java类时，推荐首先定义变量，然后定义方法。 公有方法是类的调用者和维护者最关心的方法，因此最好首屏展示； 保护方法虽然只被子类关心，但也可能是模板设计模式下的核心方法，因此重要性仅次于公有方法； 私有方法对外部来说是一个黑盒...
Java的内部类主要分为哪几种？分别简单的举例实现
KissTooTrue的博客
12-26 454
成员内部类是最常见的内部类类型，它像外部类的一个普通成员一样，可以访问外部类的所有成员和方法（包括private和静态成员）。：局部内部类是在外部类的一个方法内部被定义的，它仅在该方法的作用域内可见。内部类与外部类之间存在一种特殊的关系，这种关系允许内部类访问外部类的成员和方法，同时，外部类也可以访问内部类的成员和方法。：匿名内部类是没有名称的局部内部类，它通常用于扩展一个类或实现一个接口。而内部类（Inner Class）是一种特殊的类，它可以在另一个类（外部类）的内部进行定义。
内部类种类以及使用方法
sinat_35814207的博客
02-24 1855
定义： 内部类指的是在类的内部定义再定义一个类。 内部类仅仅是一个编译时的概念。Outer.java 中定义一个Inner.java ，编译成功后会生成两个完全不同的class文件，分别是 Outer.class 和 Outer$Inner.class , 所以内部类的名字完全可以和它的外部类名字相同。 内部类的分类：  成员内部类； 局部内部类； 匿名内部类； 静态内部类； 成员内...
java内部类及四种内部类的实现方式
weixin_30781433的博客
03-02 291
java内部类及四种内部类的实现方式 一、内部类定义：内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。 二、为何要内部类？a、内部类提供了某种进入外围类的窗户。b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。...
Java——匿名内部类实现线程的两种方式
beyond谚语的博客
07-27 7377
package com.yy.thread; public class Demo4_Thread { public static void main(String[] args) { demo1(); //匿名内部类，第一种，继承Thread demo2(); //匿名内部类，第二种，实现Runnable接口 } ...
Java多线程（三）多线程实现方式
android开发笔记
08-10 135
多线程有几种实现方式？如果被问到这个问题一定很头疼，因为百度一下随便就能出现各种各样的答案。两种、三种、四种、五种、六种、七种。。。 但本质上来讲，个人认为只有一种方式：实现Runnable接口。 先放个图： 线程相关类图.png 1、实现Runnable接口 public class DemoThreadTask implements Runnable{ @Over...
java的四种内部类
10-07
Java的四种内部类分别是成员内部类、局部内部类、匿名内部类和静态内部类。 - 成员内部类是定义在类内部的非静态类，它不能定义静态方法和变量（final修饰的除外）。成员内部类是非静态的，所以在其中不能定义静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值