内部类(Nested Classes)

已于 2023-03-30 22:43:50 修改
阅读量1.5k 收藏 10
点赞数 4
分类专栏： JAVA基础 文章标签： java jvm 开发语言
于 2023-03-30 20:32:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tweek_/article/details/129866058
版权

目录

一、内部类

二、内部类的分类

1、成员内部类

2、静态内部类

3、局部内部类

4、匿名内部类

三、Lambda表达式

1、Lambda表达式

2、Lambda表达式的省略写法

3、Lambda表达式和匿名内部类的区别

一、内部类

1、定义在类中定义的另一个类或是在类的方法中定义的另外一个类

创建对象的格式：

class Outer{
    class Inner{
        
    }
}
外部类.内部类 内部类对象名 = new 外部类对象().new内部类对象() 
Outer.Inner in = new Outer().new Inner();

二、内部类的分类

一般有四种类：成员内部类、局部内部类、匿名内部类和静态内部类

1、成员内部类

成员访问特点

(1)内部类中，访问外部类成员:直接访问，包括私有

下面是代码示例：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner in = new Outer().new Inner();
       in.show();
​
    }
}
​
class Outer{
    /**
     * 内部类访问外部类成员
     */
    private int num = 30;
    public void method(){
        System.out.println("I'm a method of Outttter!");
    }
    class Inner{
​
        public void show(){
​
            System.out.println(num);  //直接访问外部类的私有成员变量
            method();    //直接访问外部类的成员方法
​
        }
    }
}
​
控制台输出：
30
I'm a method of Outttter!

(2)外部类中，访问内部类成员:需要创建对象访问

下面是代码示例：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner in = new Outer().new Inner();
       in.show();
       Outer outer = new Outer();
       outer.method();
​
    }
}
​
class Outer{
    /**
     * 外部类访问内部类的访问特点
     */
    Inner inner = new Inner(); //创建内部类的对象
    public void method(){
        inner.show();
    }
​
    class Inner{
​
        public void show(){
            System.out.println("I'm a method of Innnnnnner!");
        }
    }
}
​
控制台输出：
I'm a method of Innnnnnner!
I'm a method of Innnnnnner!

(3)内部类与外部类变量重名时的访问特点

下面是代码示例：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner in = new Outer().new Inner();
       in.show();
    }
}
​
class Outer{
    /**
     * 变量访问特点
     */
    int num =10;
    class Inner{
        int num =20;
        public void show(){
            int num =30;
            System.out.println(num);    //就近原则访问变量
            System.out.println(this.num);  //在该内中的成员变量
            System.out.println(Outer.this.num); //类名引用成员变量
​
        }
    }
}

2、静态内部类

静态内部类：static修饰的成员内部类

(1)创建对象格式

class Outer{
    static class Inner{
        
    }
}
外部类名.内部类名 对象名 = new 外部类名.内部类对象();
Outer.Inner in = new Outer.Inner();

(2)调用方法

一般情况：

下面是代码示例：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner in = new Outer.Inner();
       in.show();
    }
}
​
class Outer{
    /**
     * 访问static内部类中的方法
     */
   static class Inner{
        public void show(){
            System.out.println("I'm a method of Innnnnnner!");
        }
    }
}
​
控制台输出：
I'm a method of Innnnnnner!

当内部类方法被static修饰时：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner.show();   //因为内部类中的方法是静态的，且内部类也是静态的，故调用静态类中的静态方法时可以用类名调用
    }
}
​
class Outer{
    /**
     * 访问static内部类中static修饰的方法
     */
   static class Inner{
        public static void show(){
            System.out.println("I'm a method of Innnnnnner!");
        }
    }
}
​
控制台输出：
I'm a method of Innnnnnner!

注意：静态内部类只能调用静态方法，当静态内部类想要调用外部类的非静态成员时，需要在内部类中创建对象。

下面是代码示例：

/**
 * @author Tweek
 */
public class NestedClasses {
    public static void main(String[] args) {
       Outer.Inner.show();   //因为内部类中的方法是静态的，且内部类也是静态的，故调用静态类中的静态方法时可以用类名调用
    }
}
​
class Outer{
    /**
     * static内部类访问外部类的成员
     */
    int num =20;
    public void method(){
        System.out.println("I'm a method of Outtttter!");
    }
   static class Inner{
        public static void show(){
            Outer outer = new Outer();  //创建外部类的对象
            outer.method();
            System.out.println(outer.num);
            System.out.println("I'm a method of Innnnnnner!");
        }
    }
}
​
控制台输出：
I'm a method of Outtttter!
20
I'm a method of Innnnnnner!

3、局部内部类

局部内部类：存在与方法、底阿妈快、构造器等执行体中

下面是代码示例：

/**
 * @author Tweek
 */
public class Test2 {
    public static void main(String[] args) {
        Outer outer = new Outer(); //创建外部类对象
        outer.method();  //调用外部类方法，外部类方法进入内部类，找到外部类中创建的局部内部类对象，再用局部类对象调用其方法show()
    }
}
class Outer{
    /**
     * 局部内部类
     * 例在方法内定义
     */
    public void method(){
    class Inner{
        public void show(){
​
            System.out.println("I'm a method of Innnnner!");
         }
      }
      Inner inner = new Inner();   //外部类访问内部类，先创建局部内部类对象
      inner.show(); //调用内部类方法
    }
}
​
控制台输出：
I'm a method of Innnnner!

4、匿名内部类

匿名内部类：匿名内部类是一种特殊的内部类，定义在方法内部。

定义匿名内部类的前提：需要存在一个接口或类

格式：new 类名\接口名(){

}

new 类名(){} ： 代表继承这个类

new 接口名(){}: 代表实现这个接口

匿名内部类的使用场景：若接口中的方法只有一个时（方法多的时候不建议使用匿名内部类，这样会使得代码变得臃肿，适得其反），我们可以使用匿名内部类，来使得我们的代码更加地简洁，因为若不使用匿名内部类，我们则需要创建新的类并实现接口，调用新类中重写接口的方法。

下面的代码示例，能让我们更好地理解匿名内部类

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
         * 通过额外的类来实现接口
         * 当方法参参数为接口时，我们此时应该传入接口的实现类，因为接口不能实例化。
         */
        userInter(new InterImp());
        userInter(new Inter(){
            /**
             * 通过匿名内部类来实现接口中的方法，不用再额外创建一个类来实现接口
             */
            @Override
            public void show() {
                System.out.println("I'm a method of The Interface Inter!");
            }
        } );
    }
​
    /**
     * 此处方法的参数传入的是一个接口，但是接口不能实例化，所以有两种方法
     * 1、创建新类实现接口
     * 2、利用方法内部的匿名内部类来实现接口中的方法
     * @param i
     */
    public static void userInter(Inter i){
        i.show();
    }
}
interface Inter{
    void show();
}
class InterImp implements Inter{
​
    @Override
    public void show() {
        System.out.println("I'm a method of The InterImp!");
    }
}
​
​
控制台输出：
I'm a method of The InterImp!
I'm a method of The Interface Inter!

三、Lambda表达式

1、Lambda表达式

JDK8开始后的一种新语法形式

作用：简化你们内部类的代码写法

格式：() -> {}

           () : 匿名内部类被重写方法的形参列表

           {} : 被重写方法的方法体代码

注意：Lambda表达式，只允许操作函数式变成接口：即有且仅有一个抽象方法的接口！

下面的代码示例，能让我们更好地了解Lambda表达式

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
         * 利用Lambda表达式来简化匿名内部类
         * Lambda表达式格式： () -> {}
         * 
         */
        userInter(()->{ System.out.println("I'm a method of The Interface Inter!");});
    }
​
​
    public static void userInter(Inter i){
        i.show();
    }
}
interface Inter{
    void show();
}
​
控制台输出：
I'm a method of The Interface Inter!

2、Lambda表达式的省略写法

(1)参数类型可以省略不写

下面是代码示例：

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
         * 省略参数类型
         */
        userCalculator(new Inter() {
            @Override
            public int calculate(int a, int b) {
                return a + b;
            }
        });
        System.out.println("---------------------------------");
        //省略参数类型
        userCalculator((a,b)->a+b);
    }
​
​
    public static void userCalculator(Inter i){
         int result= i.calculate(10,20);
         System.out.println(result);
    }
}
interface Inter{
    int calculate(int a,int b);
}
​
控制台输出：
30
---------------------------------
30

(2)如果只有一个参数，参数类型可以省略，同时()也可以省略。

下面是代码示例：

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
         * 如果只有一个参数，参数类型可以省略，同时()  也可以省略
         *
         */
        userInter(s->{ System.out.println("I'm a method of The Interface Inter!"+s);});
    }


    public static void userInter(Inter i){
         String s = "GOOD";
        i.show(s);
    }
}
interface Inter{
    void show(String s);
}

控制台输出：
I'm a method of The Interface Inter!GOOD

(3)如果Lambda表达式的方法体代码只有一行代码时

     1.可以省略大括号不写，同时要省略分号

下面是代码示例：

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
             可以省略代码的大括号，同时省略分号
             
         */
        userInter(s-> System.out.println("I'm a method of The Interface Inter!"+s));
    }
​
​
    public static void userInter(Inter i){
         String s = "GOOD";
        i.show(s);
    }
}
interface Inter{
    void show(String s);
}
​
控制台输出：
I'm a method of The Interface Inter!GOOD

     2.此时，如果这行代码是return语句，必须省略return，同时也必须省略一个;

/**
 * @author Tweek
 */
public class NCTest3 {
    public static void main(String[] args) {
        /**
         * 如果一行代码是return语句，那么必须省略return与;
         */
        userRandom(new Inter() {
            @Override
            public int getNumber() {
                return new Random().nextInt(100)+1;
            }
        });
        System.out.println("---------------------------------");
        userRandom(()->new Random().nextInt(100)+1);
    }
​
​
    public static void userRandom(Inter i){
         int result= i.getNumber();
         System.out.println(result);
    }
}
interface Inter{
    int getNumber();
}
​
控制台输出：
41
---------------------------------
93

3、Lambda表达式和匿名内部类的区别

(1)使用限制不同

    1.匿名内部类：可以操作类，接口

    2.Lambda表达式：只能操作函数式接口

(2)实现原理不同

    1.匿名内部类：编译之后，产生一个单独的.class字节码文件

    2.Lambda表达式：编译之后，没有一个单独的.class字节码文件

Tweek_
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Java嵌套类和内部类
08-30
Java 嵌套类（nested classes）是指在一个类的内部定义另一个类，这种类有两种类型：静态嵌套类和非静态嵌套类。非静态嵌套类也称为内部类（inner classes）。在Java中，嵌套类从JDK1.1开始引入。 一、什么是嵌套类...
java内部类的讲解
03-22
1. **嵌套顶级类（Nested Top-Level Classes）**：这种内部类类似于普通的类，但它们被定义在另一个类的内部。它们没有访问外部类的实例变量或方法的能力，除非它们是静态的。嵌套顶级类可以通过外部类名访问。 2. ...
Nested Classes(内部类)
qq_28801753的博客
11-17 91
使用内部类的好处 It is a way of logically grouping classes that are only used in one place: If a class is useful to only one other class, then it is logical to embed it in that class and keep the two together. Nesting such “helper classes” makes their package mor
java nested classes,Java 嵌套种(Nested Classes)
weixin_42512613的博客
03-13 172
Java 嵌套类(Nested Classes)官方定义：A class defined within another class is called a nested class. Like other members of a class, a nested class can be declared static or not. A nonstatic nested class is cal...
java nested_java嵌套类(Nested Classes)总结
weixin_39774490的博客
02-12 328
Nested Classes定义在java语言规范里面，嵌套类(Nested Classes)定义是：A nested class isany class whose declaration occurs within the body of another class orinterface. A top level class is a class that is not a nested c...
Nested Classes（嵌套类） - Java™ Tutorials 翻译
Turnhead的专栏
01-17 396
一、原文地址： https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html 二、原文翻译： 1、嵌套类 java编程语言允许在另一个类内部定义一个类。这样的类被叫做嵌套类，这里举例说明： /** 外部类 **/ public class OuterClass { /** 嵌套类 **/ ...
java nested classes_Java中的Nested Classes和Inner Classes
weixin_29523709的博客
02-13 106
Java中的Nested Classes和Inner ClassesJava有嵌套类(Nested Classes)和内部类(Inner Classes)的概念。嵌套类(Nested Classes)分为两种：static and non-static。即静态的和非静态的，静态的嵌套类我们称之静态嵌套类(static nested classes)，非静态的嵌套类我们称之为内部类(inner cl...
java 嵌套类 map_java嵌套类(Nested Classes)总结
weixin_39623050的博客
02-13 158
Nested Classes定义在java语言规范里面，嵌套类(Nested Classes)定义是：A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested...
java 内部类(nested class)
06-13 819
内部类（nested class)详解
java嵌套类(Nested Classes)总结
yangstarss的专栏
03-16 5869
Nested Classes定义在java语言规范里面，嵌套类(Nested Classes)定义是：A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested...
JavaTutorials之Nested Classes
qq_39199850的博客
01-11 143
Nested class格式： class OuterClass { ... class InnerClass { ... } static class StaticNestedClass { ... } } 不加static的可以访问类内成员，加了的不可以访问。从内存的角度来说，static直接放在内存里了，对象得new出来才能使用，你不能访问一个还不存在得到对象。 Why Use Nested Classes? 1.如果一个类
day11_static、内部类、权限、参数传递、复习.pdf
11-02
- 静态内部类（Static Nested Class）：类似于普通的顶级类，但仍然与外部类有联系。它们不能直接访问外部类的非静态成员，但可以通过实例化外部类对象来访问。 - 非静态内部类（Member Inner Class）：可以直接...
Java-Docs-3.zip_nested
09-23
这个主题涵盖了内部类（inner classes）、静态嵌套类（static nested classes）以及其他相关的概念，这些都是理解和编写复杂Java代码的关键部分。 首先，让我们来理解什么是内部类。内部类是定义在另一个类的内部的...
Java 深入理解嵌套类和内部类
01-13
Java 中的嵌套类和内部类是指在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）。嵌套类有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，非静态嵌套类也即被称作为内部类（inner）。嵌套...
golang 接口
m0_70982551的博客
07-24 869
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 456
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 547
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 539
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
kotlin 嵌套类 内部类
02-25
Kotlin中的嵌套类（Nested Classes）和内部类（Inner Classes）是非常相似的概念，但有一些细微的区别。以下是对它们的一些基本介绍： 1. **嵌套类（Nested Classes）**：在Kotlin中，嵌套类是一种类，它包含在另一个类的内部。它可以是静态的（static）、非静态的（inner）或者局部的（local）。嵌套类可以从任何访问它的外部类访问字段、方法、构造器和嵌套类。这允许一个类的数据可以在嵌套类中被更细粒度地访问和控制。 ```kotlin class OuterClass { class NestedClass { // code inside } } ``` 2. **内部类（Inner Classes）**：内部类是定义在另一个类内部的类。它可以直接访问外部类的所有成员，包括字段、方法、构造器和嵌套类。内部类可以包含自己的构造函数，并且可以访问外部类的私有成员。内部类可以嵌套在其他内部类中，形成一个复杂的层次结构。 ```kotlin class OuterClass { inner class InnerClass { // code inside } } ``` 总的来说，内部类在实现接口、继承某个类或封装内部数据结构时特别有用。另一方面，嵌套类提供了一种更灵活的方式来访问外部类的数据和方法，即使外部类在不同的包或模块中。 需要注意的是，尽管Kotlin中的嵌套类和内部类非常相似，但在某些情况下，使用嵌套类的语法可能更清晰和直观。例如，使用嵌套类可以更清楚地表示一个类的嵌套结构，而内部类则更适合实现接口或封装内部数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值