为什么内部类可以访问外部类的变量

最新推荐文章于 2021-02-21 09:49:33 发布
原创 最新推荐文章于 2021-02-21 09:49:33 发布 · 763 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文深入探讨了Java中内部类的概念及其实现方式。通过具体的代码示例，详细介绍了如何定义和使用内部类，并展示了如何通过javac和javap工具进行编译与反编译来观察内部类的具体结构。

先写一个Otter类

public class Otter {
    int outerField = 0;

    class Inner{
        void InnerMethod(){
            int i = outerField;
        }
    }
}

进入该类目录，通过javac Otter.java 编译得到Otter.class和Otter$Inner.class
这里写图片描述
然后通过javap -classpath . -v Otter.$Inner（其中.表示当前目录下寻找class文件，-v为-verbose输出信息较多）得到反编译文件：

Compiled from "Otter.java"
public class com.example.xiahangli.memoryleakeage.Otter extends java.lang.Object
  SourceFile: "Otter.java"
  InnerClass: 
   #6= #5 of #3; //Inner=class com/example/xiahangli/memoryleakeage/Otter$Inner of class com/example/xiahangli/memoryleakeage/Otter
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method   #4.#16; //  java/lang/Object."<init>":()V
const #2 = Field    #3.#17; //  com/example/xiahangli/memoryleakeage/Otter.outerField:I
const #3 = class    #18;    //  com/example/xiahangli/memoryleakeage/Otter
const #4 = class    #19;    //  java/lang/Object
const #5 = class    #20;    //  com/example/xiahangli/memoryleakeage/Otter$Inner
const #6 = Asciz    Inner;
const #7 = Asciz    InnerClasses;
const #8 = Asciz    outerField;
const #9 = Asciz    I;
const #10 = Asciz   <init>;
const #11 = Asciz   ()V;
const #12 = Asciz   Code;
const #13 = Asciz   LineNumberTable;
const #14 = Asciz   SourceFile;
const #15 = Asciz   Otter.java;
const #16 = NameAndType #10:#11;//  "<init>":()V
const #17 = NameAndType #8:#9;//  outerField:I
const #18 = Asciz   com/example/xiahangli/memoryleakeage/Otter;
const #19 = Asciz   java/lang/Object;
const #20 = Asciz   com/example/xiahangli/memoryleakeage/Otter$Inner;

{
int outerField;

public com.example.xiahangli.memoryleakeage.Otter();
  Code:
   Stack=2, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
      5:    iconst_0
   6:   putfield    #2; //Field outerField:I
   9:   return
  LineNumberTable: 
   line 6: 0
   line 7: 4
   line 9: 9


}

忽略一些常量池信息，分析内部类文件
其中：

这里写代码片
Java外部类可以访问内部类所有变量，包括private
土味儿
09-11 1273
// 外部类 class Outer{ // 私有内部类 private class Inner{ private int number=5; } // 调用内部类的私有变量 public int getNumber(){ return new Inner().number; } } public class Hello { public static void main(String[] args){
Java中匿名内部类与局部变量访问
m0_72352120的博客
08-07 638
在JAVA8以及更高的版本中，即使局部变量未被显示声明为final，但如果其在初始化之后并没有被修改过，那么JAVA会隐式的认为它是effectively final 的，当在内部类中访问该对象的时候，也是可以调用此对象的。也许当你对某段代码进行修改的时候会发现出现了一个警告，系统提醒某处代码的使用有问题，尽管你并没有做针对那段代码的修改。对于内部类访问外部方法的局部对象，只要对象的引用不变，只是对象内部的属性值修改，是被允许的。此时代码的运行是没有问题的，我们可以看到控制台打印了出了需要的结果。
深入理解Java中为什么内部类可以访问外部类的成员
热门推荐
昨夜星辰的博客
02-26 3万+
内部类简介 虽然Java是一门相对比较简单的编程语言，但是对于初学者， 还是有很多东西感觉云里雾里， 理解的不是很清晰。内部类就是一个经常让初学者感到迷惑的特性。 即使现在我自认为Java学的不错了， 但是依然不是很清楚。其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员（包括成员变量和成员方法）？ 早就想对内部类这个特性一探究竟了，今天终于抽出时间把它研究了一下。 内
方法中的内部类能不能访问方法中的局部变量？
Alex_zhuang的专栏
12-21 4261
内部类的生命周期和方法中的局部变量是不一样的，内部类是也是一个类，是存储在堆中，也只有当对该类的引用消失时，内部类才会消亡。而方法的局部变量是存储在堆栈中的，当调用结束时就会退栈，即在内存中这个属性就消失了。也就是说，内部类的生命周期超过了方法中局部变量的生命周期，内部类可能会调用到已经消失的属性，因此内部类不能访问方法中的局部变量。 解决方法就是在局部变量前加修饰符final ，此时局部变量就
JAVA问题分析——深入理解内部类（内部类为什么能够直接访问外部类的属性和方法）
CHB的博客
09-05 817
我们知道，写在类里面的类叫做内部类，内部类为什么能够直接访问外部类的属性和方法呢？ 内部类的基础知识可以参见我的上一篇博客： 特殊的方法和类 先看一下代码： public class Test { private int a; public class OutClass{ //定义一个成员内部类 private int b; } } 经过编译之后，我们发现生成了两个class文件。内部类OutClass也单独生成了一个字节码文件。 内部类会单独生成一个字节码文件
关于java内部类为什么能够访问外部类属性详解
ZytheMoon的博客
12-24 4348
    首先解释一下什么是内部类，内部类是定义在一个类内部的类。分为两种情况：一种是被static关键字修饰的， 叫做静态内部类， 另一种是不被static关键字修饰的， 即是普通内部类。 在下文中所提到的内部类都是指这种不被static关键字修饰的普通内部类。 静态内部类虽然也定义在外部类的里面， 但是它只是在形式上（写法上）和外部类有关系， 其实在逻辑上和外部类并没有直接的关系。而一般的内部类...
java外部类_Java里什么叫内部类什么叫外部类?
weixin_39883091的博客
02-15 749
内部类简介虽然Java是一门相对比较简单的编程语言，但是对于初学者， 还是有很多东西感觉云里雾里，理解的不是很清晰。内部类就是一个经常让初学者感到迷惑的特性。 即使现在我自认为Java学的不错了，但是依然不是很清楚。其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员(包括成员变量和成员方法)？早就想对内部类这个特性一探究竟了，今天终于抽出时间把它研究了一下。内部类就是定义在一个类内部的类。...
局部内部类和匿名内部类使用局部变量为什么要final1
08-08
2. **内部类的实现机制**：Java内部类的实现方式使得它们能够访问外部类的非静态成员，因为它们持有对外部类实例的引用（`Outer.this`）。对于局部变量，情况类似，Java实际上将这些变量作为参数传递给内部类的构造...
Java为什么匿名内部类参数引用需要用final进行修饰?
08-26
进一步解释，内部类中使用的外部变量需要是final的，这是因为内部类本身都会含有一个外围了的引用（外围类.this），这样在回调时一定可以访问到该变量。但是，如果内部类中使用的外部变量是方法中的局部变量，那么该...
java 利用反射获取内部类静态成员变量的值操作.docx
01-13
它可以访问外部类的所有成员（包括私有成员），同时也可以被外部类所访问。 2. **静态成员变量**：静态成员变量是类级别的变量，可以通过类名直接访问，不需要创建类的实例。 3. **反射**：反射是在运行时检查类、...
局部内部类如何访问外部类方法中变量
weixin_30276935的博客
06-04 620
public class Outer { public void inner(){ final int num = 5; class InnerClass{ private int num = 4; public void te...
Java内部类访问外部类的成员变量
xiaoxiao48的博客
03-14 288
代码： public class Out { public String name = "out"; public static void main(String[] args) { Inside inside = new Out().new Inside(); inside.getInside(); } class Inside{ String name = ...
内部类引用外部类的局部变量要用final修饰
zz276203200的博客
01-25 1557
为什么内部类引用外部类的局部变量时，此变量要用final修饰 代码 public void test() { final int i = 3; runOnUiThread(new Runnable() { @Override public void run() { mTvShow.s
java内部类访问外部变量_Java嵌套内部类访问外部类变量
weixin_29711757的博客
02-21 547
嵌套的内部类ABar和BBar可以访问主类的变量吗？例如：public class Foo {public ABar abar = new ABar();public BBar bbar = new BBar();public int someCounter = 0;public class ABar {public int i = 0;public void someMethod(){i++;s...
Java>内部类>>内部类如何访问外部类同名变量
越努力，越幸福！
07-30 3548
内部类的同名变量访问_解决方法： 格式：外部类名称.this.外部类成员变量名 如何创建内部类对象 格式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); 实例如下： 定义一个包含内部类的外部类： package NeiBuLei; //如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名 public class Outer...
内部类调用外部类变量
chuteng3602的博客
09-12 3064
要求：使用已知的变量，在控制台输出30，20，10。 class Outer { public int num = 10; class Inner { public int num = 20; public void show() { int num = 30; Sy...
java 内部类 外部变量_Java嵌套内部类访问外部类变量
weixin_36031304的博客
02-15 593
嵌套的内部类ABar和BBar可以访问主类的变量吗？例如：public class Foo {public ABar abar = new ABar();public BBar bbar = new BBar();public int someCounter = 0;public class ABar {public int i = 0;public void someMethod(){i++;s...
Java 内部类调用外部类方法的一个注意点
rainbow702的博客
08-10 882
今天在写代码的时候，涉及到使用一个内部类去调用外部类方法的问题，总是得不到我想要的结果，后经过DEBUG，才发现哪里出现了问题。现写了一个简单的代码，来重现这个问题。   打印出来的结果为： a: 20 a: 0 a: 20  为什么是这么一个结果呢？我想，对第一个 20，大家应该没有任何意见吧。那么第二个为什么是 0 呢？我一开始一直以为打印出来的应该是 20，所以一直没想通，但看了...
C++ 内部类访问外部类成员变量
最新发布
09-24
<think> 我们正在讨论C++中嵌套类（内部类）访问外部类成员的问题。根据引用[1]，嵌套类默认不是外部类的友元，因此不能直接访问外部类的非静态私有成员。我们需要遵循以下规则： 1. 静态成员：嵌套类可以直接访问外部类的所有静态成员（包括private）。 2. 非静态成员：必须通过外部类实例访问其公有或保护成员；若要访问私有成员，则需要在外部类中声明嵌套类为友元。 此外，引用[2]提到了一种封装多个成员变量的方法，但这里我们更关注如何让嵌套类访问外部类成员。 因此，实现嵌套类访问外部类成员变量的方法主要有两种： 方法一：通过外部类对象访问（仅限公有和保护成员） 方法二：在外部类中将嵌套类声明为友元，这样嵌套类就可以直接访问外部类的私有成员。 下面我们用代码示例来说明。 假设我们有一个外部类Outer和一个嵌套类Inner。 方法一：通过外部类对象访问（适合公有或保护成员） 在嵌套类中，如果我们需要访问外部类的非静态成员，必须有一个外部类的对象。通常，我们可以在嵌套类的成员函数中传递一个外部类的引用或指针。 方法二：使用友元声明（可以访问私有成员） 在外部类中声明嵌套类为友元，这样嵌套类就可以访问外部类的所有成员（包括私有成员）。 下面分别给出两个示例： 方法一示例（通过对象访问）： ```cpp class Outer { public: int publicVar; protected: int protectedVar; private: int privateVar; // 嵌套类不能直接访问，除非有友元声明 public: class Inner { public: void accessOuter(Outer& outer) { outer.publicVar = 10; // 可以访问公有成员 outer.protectedVar = 20; // 可以访问保护成员 // outer.privateVar = 30; // 错误：不能访问私有成员 } }; }; ``` 方法二示例（使用友元）： ```cpp class Outer { private: int privateVar; public: class Inner; // 前向声明（如果Inner的定义在Outer之后，则需要此声明） // 声明嵌套类Inner为友元 friend class Inner; class Inner { public: void accessOuter(Outer& outer) { outer.privateVar = 30; // 正确：因为Inner是Outer的友元 } }; }; ``` 注意：在方法二中，我们在外部类中声明了嵌套类为友元，这样嵌套类就可以访问外部类的私有成员。 但是，需要注意友元声明的位置。有时嵌套类的定义在外部类内部，我们可以直接在外部类内部声明友元，如上述示例。如果嵌套类定义在外部类外部，则需要在外部类中声明友元，并且嵌套类的定义需要放在外部类之后（此时可能需要前向声明）。 另外，还有一种常见场景：嵌套类作为外部类的成员，并且外部类可能希望嵌套类能够访问外部类的私有成员，但又不想将整个嵌套类暴露为友元（或者嵌套类中只有部分函数需要访问）。这时可以选择只将嵌套类的特定成员函数声明为友元。但请注意，嵌套类的成员函数在外部类中声明为友元时，需要完整的限定名。 例如： ```cpp class Outer { private: int privateVar; public: class Inner { public: void accessOuter(Outer& outer); void anotherFunction(Outer& outer); // 这个函数不能访问私有成员 }; // 声明Outer::Inner::accessOuter为友元 friend void Inner::accessOuter(Outer& outer); }; // 在外部定义Inner的成员函数 void Outer::Inner::accessOuter(Outer& outer) { outer.privateVar = 30; // 可以访问 } void Outer::Inner::anotherFunction(Outer& outer) { // outer.privateVar = 40; // 错误：不能访问私有成员 } ``` 总结： - 访问静态成员：嵌套类可以直接访问外部类的静态成员（包括私有静态成员）。 - 访问非静态成员： 1. 对于公有和保护成员：通过外部类对象访问。 2. 对于私有成员：需要将嵌套类（或嵌套类的特定成员函数）声明为外部类的友元。 以上就是C++中嵌套类访问外部类成员变量的实现方法。 注意：嵌套类（内部类）和外部类之间没有特殊的访问权限，除非显式声明友元关系。 §§相关问题§§ 1. C++中嵌套类可以访问外部类的私有静态成员吗？ 2. 除了友元声明，还有其他方法让嵌套类访问外部类的私有成员吗？ 3. 在嵌套类中如何访问外部类的非静态成员变量？ 4. 嵌套类与外部类之间的访问权限与继承有什么区别？ </think> ### C++内部类访问外部类成员变量的实现方法 在C++中，内部类（嵌套类）访问外部类成员需要遵循特定规则，以下是完整的实现方法： #### 1. **直接访问静态成员** 内部类可直接访问外部类的**所有静态成员**（包括private）： ```cpp class Outer { private: static int staticPrivateVar; public: class Inner { public: void accessStatic() { staticPrivateVar = 42; // 直接访问外部类私有静态成员 } }; }; ``` #### 2. **通过外部类实例访问公有/保护成员** 对于**非静态成员**，需通过外部类实例访问： ```cpp class Outer { public: int publicVar; protected: int protectedVar; private: int privateVar; // 无法直接访问 class Inner { public: void accessNonStatic(Outer& outer) { outer.publicVar = 10; // ✔ 访问公有成员 outer.protectedVar = 20; // ✔ 访问保护成员 // outer.privateVar = 30; // ❌ 错误：私有成员不可访问 } }; }; ``` #### 3. **友元声明访问私有成员** 需在外部类中声明内部类为`friend`： ```cpp class Outer { private: int privateVar; public: class Inner; // 前置声明 friend class Inner; // 关键：友元声明 class Inner { public: void accessPrivate(Outer& outer) { outer.privateVar = 30; // ✔ 直接访问私有成员 } }; }; ``` #### 4. **嵌套封装结构体** 通过结构体封装相关变量（引用[2]方法）： ```cpp class Outer { private: struct DataBundle { // 封装相关变量 int var1; int var2; } data; public: class Inner { public: void modifyBundle(Outer& outer) { outer.data.var1 = 100; // 通过单一接口访问 outer.data.var2 = 200; } }; // 可选：提供受控访问接口 DataBundle& getData() { return data; } }; ``` > **关键规则总结**： > 1. 静态成员：内部类可无条件访问外部类所有静态成员 > 2. 非静态公有/保护成员：需通过外部类实例访问 > 3. 非静态私有成员：必须在外部类中声明`friend class Inner;` > 4. 封装结构体：适用于逻辑关联紧密的变量组（但需注意封装性）[^2] ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值