Java 内部类（局部内部类、匿名内部类、成员内部类、静态内部类）

已于 2024-01-31 11:30:06 修改
阅读量597 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 后端
于 2022-02-05 15:05:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44895385/article/details/122775711
版权

文章目录

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
内部类最大的特点就是可以直接访问私有属性，并且可以体现类的包含关系。

内部类的本质还是一个类。

基本语法：

class 外部类类名 { 
    class 内部类类名{
    }
}

class 外部其他类类名{
}

局部位置（比如方法内）

一、局部内部类

定义在外部类的局部位置，比如方法中，并且有类名。

语法格式：

class 外部类名 {

    public 返回值 方法名(参数列表) {
        // 局部内部类是定义在外部类的局部位置，通常是方法
        class 内部类名 {
        }
        
    }
}

① 可以直接访问外部类中的所有成员，包含私有的的成员。

class Outher {
    private int n1 = 100;

    public void m1() {
    	// 内部类
        class Inner {	
        	// 内部类的方法
            public void f1() {
            	// 内部类可以直接访问外部类的私有成员
                System.out.println("n1 = " + n1);
            }
        }
    }

}

② 不能添加访问修饰符，本质是一个局部变量，局部变量是不能使用访问修饰符的，可以使用final

因为final修饰符局部变量也可以使用

class Outher {
    public void m1() {
        // public class Inner {}  编译不能通过
        // final class Inner {}  编译可以通过，但是此内部类不能被继承
        class Inner{}    // 编译可以通过，此内部类可以被继承
        class InnerZi extends Inner {}  // 内部类的继承内部类
    }

}

③ 作用域：只有在定义该内部类的方法中或代码块中可以访问。

class Outher {

    {
        class Inner{}   // 代码块中也可以定义内部类 
    }

    public void m1() {
        class Inner{}
        Inner inner = new Inner();  // 使用内部类，创建内部类对象，注意代码顺序

    }

    public void m2() {
        // Inner inner = new Inner(); 另一个方法就不能访问其他方法中的内部类
    }
}

④ 局部内部类可以直接访问外部类的成员

class Outher {
    private int n1 = 100;
    
    public void m1() {
        class Inner{
            public void f1() {
                System.out.println("n1 = " + n1);   // 访问外部类的成员变量
                m2();   // 访问外部类的成员方法
            }
        }
    }

    public void m2() {}
}

⑤ 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，可以使用：外部类名.this.成员 进行访问

如果不加this关键字的话调用的是静态的成员，外部类名.this的本质是外部类对象，谁调用就是谁

class Outher {
	// 外部类的n1成员变量
    private int n1 = 100;

    public void m1() {
        class Inner{
        	// 内部类的n1成员变量
            private int n1 = 200;
            
            public void f1() {
            	// 方法同理
                System.out.println("n1 = " + n1);   // 访问内部类的成员变量
                System.out.println("n1 = " + Outher.this.n1);   // 访问外部类的成员变量
            }
        }
    }
}

二、匿名内部类【超重要】

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

匿名内部类没有名字，但是系统会分配一个名字，匿名内部类同时还是一个对象。

语法格式：

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

举个例子：
正常的接口实现方式：

interface A {   // 一个接口
    public void eat();
}

class B implements A {  // 接口的实现类
    @Override
    public void eat() {
        System.out.println("我就喜欢吃吃吃");
    }
}

class Outher02 {
    public void method() {
        // 创建接口实现类对象
        A a = new B();
        // 调用接口中的方法
        a.eat();
    }
}

匿名内部类实现方式：
如果实现类只使用一次的话，这样会方便很多。

interface A {   // 一个接口
    public void eat();
}

class Fa {  // 一个普通的类
    public Fa(String name) {}
    public void test() {}
}

class Outher02 {    // 外部类
    public void method() {
        // 创建接口实现类对象
        A a = new A(){	// 匿名内部类
            @Override
            public void eat() {
                System.out.println("我就喜欢吃吃吃");
            }
        };
        // 调用接口中的方法
        a.eat();
    }
}

① 匿名内部类的底层是系统创建一个类实现了接口或继承了父类，系统会分配类名

在上面的例子中，编译时会生成一个新的类，实现了A接口，这个类的类名是外部类类名 + $ + 编号，比如这里就是Outher02$1

class Outher02 {    // 外部类
    public void method() {
        // 创建接口实现类对象
        A a = new A(){	// 匿名内部类
            @Override
            public void eat() {
                System.out.println("我就喜欢吃吃吃");
            }
        };
        // 调用接口中的方法
        a.eat();
       // 查看变量a的运行类型
        System.out.println(a.getClass());
    }
}

通过以上代码，可以看到以下结果
在这里插入图片描述

所以在底层，会分配一个匿名类，这个类的名字是Outher02$1，类的方法体就是匿名内部类的方法体，应该是下面这样：

class Outher02$1 implements A {  // 系统底层创建的接口的实现类
    @Override
    public void eat() {
        System.out.println("我就喜欢吃吃吃");
    }
}

然后创建对象的时候将该对象的引用返回给给变量a，这是变量a的运行类型是A接口，编译类型实际上是Outher02$1实现类。

② 匿名内部类使用一次就不能再使用了，但是创建的这个对象是还可以继续使用的。

class Outher02 {    // 外部类
    public void method() {
        A a = new A(){ // 匿名内部类
            @Override
            public void eat() { 
                System.out.println("我就喜欢吃吃吃");
            }
        };
        a.eat();
        a.eat();
        a.eat();
    }
}

对象可以多次使用，但是匿名内部类就不能再创建对象了，就算new Outher02$1()也不行。

③ 匿名内部类可以实现接口，也可以继承类，原理是一样的。

这里创建的fu对象的运行类型和编译类型都是Fu这个类

class Fu {  // 一个普通的类
    public Fu(String name) {}
    public void test() {}
}

class Outher02 {    // 外部类
    private int n = 100;

    public void method() {
        Fu fu = new Fu("zhangsan");
    }
    
}

但是如果将创建的对象变成匿名内部类对象的话，这里的运行类型是Fu，而编译类型就是匿名内部类对象了，jdk底层也会为其创建一个一次性的类，类名可能就是Outher02$2

class Outher02 {    // 外部类
    private int n = 100;

    public void method() {
        Fu fu = new Fu("zhangsan") {
            
        };
    }

}

加上大括号之后就是匿名内部类，相当于继承了new的这个类，所以底层生成的这个类应该是：

class Outher02$2 extends Fu{
     public Outher02$2(String name) {
        super(name);
    }
}

如果在大括号中重写了父类的方法，则也是按照动态绑定机制使用编译类型的方法。

④ 基于抽象类或接口的匿名内部类必须实现抽象方法

abstract class Fu {  // 一个抽象类
    public abstract void test();
}

class Outher02 {    // 外部类
    private int n = 100;

    public void method() {
        // 匿名内部类
        Fu fu = new Fu() {
        	// 实现抽象方法
            @Override
            public void test() {
            }
        };
    }
}

⑤ 可以直接访问外部类的所有成员，包含私有的成员

同上局部内部类的第一条

⑥ 不能添加访问修饰符，他的本质是一个局部变量，作用域也是定义的方法体或代码块中

同上局部内部类的第二条和第三条

⑦ 如果外部类和匿名内部类的成员重名时，匿名内部类需要访问，则遵循就近原则，如果想访问外部类的成员，可以使用：外部类名.this.成员 进行访问

同上局部内部类第五条

成员位置（类成员位置）

三、成员内部类

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

语法格式：

class 外部类 { 
    访问修饰符 class 内部类{
    }
}

① 可以直接访问外部类的所有成员，包含私有的

成员内部类可以理解为类的一个成员，类中的成员是可以访问该类的其他成员的。

class Outher03 {
    
    private int n1 = 300;
    public String name = "zhangsan";
    
    // 成员内部类
    class Inner {
        public void say() {
            // 可以访问外部类的所有成员，包含私有的
            System.out.println(n1);
            System.out.println(name);
        }
    }
}

② 可以添加任意访问修饰符，成员内部类的本质是一个成员

class Outher03 {

    public class Inner01 {
    }

    protected class Inner02 {
    }

    class Inner03 {
    }

    private class Inner04 {
    }
}

③ 成员内部类的作用域和其他成员一样，可以在外部类中创建对象，如果有权限则也可以在其他外部类中可以使用。

// 定义类：
public class Person {
    private boolean live = true;
    // 如果成员内部类是私有的，则其他外部类无法创建该内部类的对象
    public class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
            }
    	}
	}
	
	public void m1() {
		// 成员内部类可以类外部类中直接创建对象调用并使用
		Heart heart = new Heart();
		heart.jump();
	}
}

// 定义测试类：
class InnerDemo {
    public static void main(String[] args) { 
    	// 成员内部类在其他外部类中，需要先创建外部类的对象，通过外部类的对象再创建内部类的对象，才可调用并使用
        // 创建外部类对象
        Person p = new Person();
        // 创建内部类对象
        Person.Heart heart = p.new Heart();
        // 调用内部类方法
        heart.jump();
    }
}
// 输出结果:
// 心脏在跳动

④ 成员内部类在其他外部类创建对象的三种方式

第一种： 外部类名.内部类名 变量名 = new 外部类().new 成员内部类();

class Outher03 {
    // 成员内部类
    public class Inner01 {
    }
}

class Test {
    // 创建成员内部类对象的测试方法
    public void test() {
        Outher03.Inner01 inner01 = new Outher03().new Inner01();
    }
}

第二种： 外部类名 外部类变量名 = new 外部类();
外部类名.内部类名 内部类变量名 = 外部类变量名.new 内部类();

class Outher03 {
    // 成员内部类
    public class Inner01 {
    }
}

class Test {
    // 创建成员内部类对象的测试方法
    public void test() {
        Outher03 outher03 = new Outher03();
        Outher03.Inner01 inner01 = outher03.new Inner01();
    }
}

第三种： 使用get方法

class Outher03 {
    // 成员内部类
    public class Inner01 {
    }
    
    // get方法
    public Inner01 getInner() {
        return new Inner01();
    }
    
}

class Test {
    // 创建成员内部类对象的测试方法
    public void test() {
        Outher03 outher03 = new Outher03();
        Outher03.Inner01 inner = outher03.getInner();
    }
}

⑤ 如果外部类和内部类成员重名时，内部类访问则按照就近原则，如果想访问外部类成员，可以使用：外部类名.this.成员

同上局部内部类第五条

四、静态内部类

静态内部类是定义在外部类的成员位置，并且有static修饰

class 外部类 {
    访问修饰符 static class 内部类 {
    }
}

① 可以访问外部类的所有静态成员，但是不能直接访问非静态成员

class Outher04 {
    
    private static String name = "lisi";
    private int age = 10;
    
    static class Inner04 {
        // 静态内部类访问外部类的静态成员，非静态成员无法直接访问
        public void m1() {
            System.out.println(name);
        }
        
    }
}

② 可以添加任意访问修饰符，静态内部类本质是一个静态成员。

同上成员内部类的第二条

③ 作用域：同其他成员，为类的整体

class Outher04 {
    private static String name = "lisi";

    static class Inner04 {
        public void m1() {
            System.out.println(name);
        }
    }
    
    public void say() {
        // 外部类访问静态内部类的非静态成员方法
        Inner04 inner04 = new Inner04();
        inner04.m1();
    }
}

class Outher04 {
    private static String name = "lisi";

    static class Inner04 {
        public static void m2() {
            System.out.println(name);
        }
    }

    public void say02() {
        // 外部类访问静态内部类的静态成员方法
        Inner04.m2();
    }
}

④ 其他外部类访问静态内部类的方式：

第一种： 外部类名.静态内部类名 变量名 = new 外部类.内部类();
跟成员内部类是不一样

class Outher04 {
    static class Inner04 {
        public void m1() {
        }
    }
}

class Test02 {
    public void test() {
        Outher04.Inner04 inner04 = new Outher04.Inner04();
    }
}

第二种： 使用get方法
get方法也可以设计成静态的，或许会更方便一些。

class Outher04 {
    static class Inner04 {
        public void m1() {
        }
    }
    
    // get方法
    public Inner04 getInner04(){
        return new Inner04();
    }
}

class Test02 {
    public void test() {
        Outher04 outher04 = new Outher04();
        Outher04.Inner04 inner04 = outher04.getInner04();
    }
}

⑤ 如果外部类和静态内部类成员重名时，静态内部类访问则按照就近原则，如果想访问外部类成员，可以使用：外部类名.成员

同上局部内部类第五条，只不过这里是静态的，无需使用this

VincentHu_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java内部类详解
qq_43508801的博客
03-05 249
根据内部类定义的位置及关键字一共分为以下四种内部类：成员内部类/普通内部类，静态内部类，方法内部类/局部内部类，匿名内部类。 1. 成员内部类 – 类比普通属性或方法 定义：直接定义在外部类之中，不加static修饰符。 在成员内部类中要注意的点： ① 成员内部类中不能存在任何static的变量和方法。 ②成员内部类的创建需要依赖外部类对象，先有外部类对象才有成员内部类对象。 在外部类的外...
java炒冷饭系列11 方法和作用域内的内部类 与 匿名内部类
weixin_36210698的博客
06-21 526
在方法和作用域内的内部类到目前为止，读者所看到的只是内部类的典型用途。通常，如要所读、写的代码包含了内部类，那么它们都是“平凡的”内部类，简单并且容易理解。然而，内部类的语法覆盖了大量其他的更加难以理解的技术。例如，可以在一个方法里面或者在任意的作用域内定义内部类。这么做有两个理由： 如前所示，你实现了某类型的接口，于是可以创建并返回对其的引用。 你要解决一个复杂的问题，想创建一个类来辅助你的解决方
Java内部类（静态内部类、匿名内部类等）详解
最新发布
????
04-25 1205
总结了常见的四大内部类（成员内部类、静态内部类、局部内部类、匿名内部类）相关知识，通过写代码详细讲解了静态内部类和匿名内部类，成员内部类和局部内部类使用较少就没有写代码举例。
【Java|基础篇】内部类
云泽野の编程日记
05-29 9290
内部类就是在一个类中再定义一个类,内部类也是封装的体现.它可以被声明为public、protected、private 或默认访问控制符。内部类可以访问外部类的所有成员变量和方法，包括私有成员。内部类可以用来实现一些特殊的功能，比如实现回调函数、事件处理等。常见的内部类包括实例内部类(成员内部类)、静态内部类、本地内部类、匿名内部类等。内部类在Java中的一个重要特性,要重点掌握实例内部类,静态内部类和匿名内部类.希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
Java内部类
骑个小蜗牛的博客
02-14 6708
一、内部类的概念 二、内部类的分析 三、内部类的分类 1. 成员内部类 2. 静态内部类 3. 局部内部类 4. 匿名内部类 匿名内部类与Lambda表达式
Java枚举类
yu的博客
02-03 4573
Java的内部类详解（成员内部类、静态内部类、局部内部类、匿名内部类）
浅析Java内部类——成员内部类
08-24
内部类可以分为四种：成员内部类、静态内部类、局部内部类和匿名内部类。今天，我们将重点介绍成员内部类。 成员内部类 成员内部类是最简单的内部类，它是不能有static修饰的成员或者方法的，因为成员内部类是寄生...
详解Java内部类——匿名内部类
08-24
Java内部类是一种特殊的类，它可以定义在另一个类的内部，包括成员内部类、静态内部类、局部内部类和匿名内部类等。今天，我们主要来讲解Java中的匿名内部类。 匿名内部类是一种特殊的局部内部类，它没有类名，连...
java中的匿名内部类详细总结
09-04
- 匿名内部类可以访问外部类的所有非私有成员，包括静态成员和实例成员。 总之，Java的匿名内部类是一个强大的工具，它可以简化代码，提高代码的可读性和效率，特别是在处理一次性需求或实现特定接口方法时。然而...
老生常谈 java匿名内部类
09-01
- 匿名内部类可以直接访问外部类的成员变量，包括私有成员，但不能访问静态成员，除非通过外部类的引用。 - 匿名内部类可以访问和修改final的局部变量，这是因为这些变量在匿名内部类的生命周期内不可变。 5. **...
Java匿名类，匿名内部类实例分析
08-19
Java中的匿名类和匿名内部类是一种特殊的类，它们没有明确的名称，但它们可以继承父类的方法，访问外部类的成员变量和方法，并且可以重写父类的方法。下面将对Java中的匿名类和匿名内部类进行详细的分析。 一、内部...
Java4Android 35_内部类和匿名内部类
09-07
主要讲述了JAVA中内部类和匿名内部类的相关问题。
java高级之内部类（InnerClass)
m0_73370205的博客
10-31 131
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类（InnerClass），类B则称为外部类（OuterClass）。如果成员内部类中不使用外部类的非静态成员，那么通常将内部类声明为静态内部类，否则声明为非静态内部类。[修饰符] class 外部类{[其他修饰符] [static] class 内部类{成员内部类作为类的成员的角色和外部类不同，Inner class还可以声明为private或protected；可以调用外部类的结构。（注意：在静态内部类中不能使用外部类的非静态成员）
Java之内部类
y_k_j_c的博客
06-14 936
类的五大成员：属性，方法，构造器，代码块和内部类内部类字如其名就是在类的内部定义一个类这个类就叫做内部类内部类最大的特点是可以直接访问私有属性，并可以体现类与类之间的包含关系。从种类上说，内部类可以分为四类：首先是定义在外部类的成员位置上的普通内部类（没用static修饰）和静态内部类（使用static修饰）然后是定义在外部类的局部位置上（比如说方法体内）的匿名内部类（无类名）、局部内部类（有类名）我们来一个个看： 在这种定义方式下，成员内部类对象依赖外部类对象而存在，即在创建一个普通内部类对象时首先需
Java 内部类
我的博客
02-20 1367
当静态内部类对象存在时，并不存在一个被它寄生的外部类对象，静态内部类对象只持有外部类的类引用，没有持有外部类对象的引用。在非静态内部类里可以直接访问外部类的私有成员，是因为在非静态内部类的对象里保存了一个它所寄生外部类对象的引用。当调用非静态内部类的实例方法时，必须有一个非静态内部类的实例，非静态内部类实例必须寄生在外部类实例里。如果把一个内部类放在方法里定义，那这个内部类就是一个局部内部类，局部内部类仅在方法里有效。把 A 类定义在 B 类的内部，A——内部类（嵌套类），B——外部类（宿主类）。
一篇文章搞懂Java中的内部类，什么是内部类，内部类的概念和分类，静态内部类，局部内部类，匿名内部类，以及内部类代码图文演示，Java面试内部类
zhangfuping123456789的博客
12-18 415
内部类、java、java se
【Java基础篇】内部类(InnerClass)、局部内部类
输入技术、输出想法
08-24 1089
内部类(InnerClass）、局部内部类1 内部类1.1 内部类概述1.2 外部类访问内部类的属性1.3 成员内部类访问细节1.4 成员内部类注意的细节2. 局部内部类2.1 局部内部类概述3. 匿名内部类 1 内部类 1.1 内部类概述 在一个类的内部定义另外一个类，那么另外一个类则称作为内部类。 内部类的class文件名： 外部类$内部类.class 成员内部类的访问方式：（普通的访问方法） 方式一：在外部类提供一个方法创建内部类的对象进行访问。 方式二：在其他类中直接创建内部的对象进行访问。
java内部类详解（IT枫斗者）
Andrew_Chenwq的博客
05-07 460
（这种写法语法有错,只是为了方便理解才这样写）即，通过对象名.这样的方式调用类的成员，这里的成员内部类也是这个外部类的成员，也就考虑使用对象名.这样的方式进行调用且这里要获取的是成员内部类对象，所以通过new 成员内部类的构造函数获取成员内部类对象。局部内部类的成员方法访问局部内部类所在的外部类的成员方法中定义的局部变量，局部变量可以使用final修饰，也可以不使用final修饰 ，但是不论是否使用final修饰，对于局部内部类的成员方法均只能访问（读取），而不能设置（赋值）so/search?

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VincentHu_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值