从Inner类的实例访问外部类属性
从Inner类的实例访问外部类属性，可以使用外部类的实例来访问。
在Java中，可以使用外部类的实例来访问外部类的属性，例如：
public class Outer {
private int value;
public class Inner {
public void accessOuterValue() {
System.out.println("Outer value: " + value);
}
}
}在这个例子中，可以使用Outer类的实例来访问value属性，例如：
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.accessOuterValue();在这个例子中，Outer类的实例outer被传递给Inner类的实例inner，然后inner可以使用outer来访问value属性。
在Python中，可以使用类方法或类变量来访问外部类的属性，例如：
class Outer:
def __init__(self):
self.value = 42
class Inner:
def access_outer_value(self, outer):
print("Outer value:", outer.value)在这个例子中，可以使用Outer类的实例来访问value属性，例如：
outer = Outer()
inner = Outer.Inner()
inner.access_outer_value(outer)在这个例子中，Outer类的实例outer被传递给Inner类的实例inner，然后inner可以使用outer来访问value属性。
相关·内容
如何从Python 3中的内部类访问外部类成员？
下面是我的代码片段。
class Outer:
def __init__(self):
self.__x = 20
self.__str = "Outer Class"
def show(self):
self.i1 = self.Inner(Outer())
self.i1.display()
def fn(self):
print("Hello from fn() of Outer Class"
浏览 0提问于2018-12-09得票数 1
回答已采纳
2回答
我有过
class outer: public base
{
public:
class inner
{
foo();
}
}
如何初始化这些嵌套类？可以从外部类调用foo()吗？，请告诉我嵌套类和访问成员时应该知道的经验规则是什么？谢谢
浏览 2提问于2011-11-01得票数 2
回答已采纳
5回答
如果这个问题很愚蠢，请原谅我，因为我对JAVA程序完全陌生。我正在研究嵌套类的概念，并看到下面的程序。
// Demonstrate an inner class.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class
class Inner {
void display() {
System.out.
浏览 8提问于2013-12-12得票数 2
回答已采纳
我不太明白在这个实例中如何使用关键字this。
private void checkForComodification() {
// The this I'm concerned about is the first one
if (CyclicArrayList.this.modCount != this.modCount)
throw new ConcurrentModificationException();
}
浏览 4提问于2014-12-16得票数 3
回答已采纳
2回答
这是我的班级：
public class T {
public int num = 100;
private int num2 = -1;
//inner class
public static class Inner {
private int num2 = 250;
public void method() {
System.out.println(num2);//calls inner class num
System.out.println(...);//should
浏览 1提问于2012-11-30得票数 0
回答已采纳
2回答
我试图从外部类访问内部类中的私有val，而不创建内部类的实例。
这是否可以从the outer class访问private inner class值？
提前谢谢。
浏览 3提问于2013-04-13得票数 2
回答已采纳
4回答
class Outer {
class Inner {
}
}
public class Demo {
public static void main(String args[]) {
Outer o = new Outer();
Outer.Inner inner = o.new Inner();
}
}
我为Inner类对象创建引用的方式类似于访问Outer类中的static成员？
你能解释一下背后的机制吗？
浏览 6提问于2014-04-04得票数 11
回答已采纳
2回答
我正在为内部类的属性寻找可见性修饰符，它允许外部类修改/设置值，但外部类只能获取/读取值。
public class Outer {
public class Inner {
// I want this to be editable by Outer instances
// but read-only to other external classes.
public string attribute;
}
}
浏览 1提问于2011-11-24得票数 2
回答已采纳
1回答
我知道我可以从内部类中访问外部类的方法。就像下面的课：
class outer {
void outerMethod() {}
class inner {
void innerMethod() {
outerMethod();
}
}
}
如果我扩展了内部类，我想知道如何做到这一点？
我想做以下几点：
class newClass extends outer.inner {
void innerMethod() {
outerMethod();
}
}
我希望能够从metho
浏览 1提问于2015-07-09得票数 2
回答已采纳
1回答
我声明了一个静态的内部类，我在外部类的方法中创建了一个新的实例。但是，我得到的结果表明，在我的方法中每次都使用内部类的相同实例。下面的例子，
public class Outer{
public method m(){
Inner n = new Inner(); //Creating local instance of Nested class
n.something();
}
public static class Inner{
Map<K,V> cache = new Map<K,V>();
浏览 1提问于2013-01-23得票数 1
4回答
我在类中创建了一个对象：
private class Viscosity{
float magnitude;
private Viscosity(float Magnitude){
magnitude = Magnitude;
}
}
在我的主要函数中，我尝试从文本文件中提取数据并创建一个新的粘滞对象，但似乎无法访问这个私有对象。
例如，我想将它添加到对象列表中：
listofObjects.add(new Viscosity(50.0f));
但我收到了一个错误：
无法访问类型的封闭实例。必须用ClassName类型的封闭实例来限定分配(例如，x.n
浏览 1提问于2013-09-15得票数 0
我正在学习java的内部类。我已经看到，如果内部类是非静态的，那么它可以很容易地访问外部类变量。但是，如果内部类是静态的，那么我们如何使用静态的类对象来访问外部类的变量呢？
下面是我的代码，其中我从内部类访问外部类变量
package org;
public class Outerclass {
String name = "Europe";
public String getname() {
return name;
}
public void setname(String name) {
this
浏览 7提问于2017-10-29得票数 1
我有一个来自教科书的代码：
public class Question_3_4 {
public static class Inner {
private void doIt() {
System.out.println("doIt()");
}
}
public static void main(String[] args) {
Question_3_4.Inner i = new Inner();
i.doIt();
}
}
内部类是静态的，所以我假设上面的代码隐式地实例化了Inner _3_4的实例？
Quest
浏览 3提问于2017-08-04得票数 4
5回答
我知道如果我想扩展内部类，我应该这样做：
class Outer{
class Inner{}
}
class My extends Outer.Inner{
My(Outer outer){
outer.super();
}
}
但在这种情况下，我不知道该怎么办？如何获取内部对象的封闭实例？
class My extends Outer.Inner{
My(Inner inner){
// how to get enclosing instance of inner here
}
}
这个变体不能编译：
class O
浏览 0提问于2014-06-24得票数 3
2回答
如何将变量从外部类赋给内部？以下是我最好的尝试：
in [1]: class one:
...: x = 1
...: class two:
...: y = x
...:
---------------------------------------------------------------------------
NameError: name 'x' is not defined
我不明白为什么这不起作用，但是Python在这个语法上没有问题：
In [1]: x = 1
In [2]: c
浏览 2提问于2016-01-28得票数 0
回答已采纳
我试图通过在调试模式下运行一个名为的，并在测试执行时逐步遍历代码，来理解函数反应性Java库。
上面的快照显示有一个奇怪的名为this$0的变量。
这个名字是从哪里来的？
这个名字是什么意思？
为什么这个变量有这个名字？
给它起这个名字的理由是什么？
当然，这个名称不是来自代码本身，它是由IntelliJ或javac/java生成的。但为什么？
如果我用标签Mystery Object标记这个对象，这也是很有趣的。
浏览 3提问于2015-02-11得票数 10
回答已采纳
3回答
我读到了关于从内部类继承的文章，我一直试图理解下面的代码是如何工作的：
class Outer{
class Inner{
}
}
class Derived extends Outer.Inner{
Derived(Outer o){
o.super();
}
}
据我所知，关键字Super指的是超类，super()指的不是参数构造函数。对于外部类，超类是对象类。
我想了解，这段代码是如何工作的。
为什么对象类的实例化使得扩展内部类成为可能？
创建对象类实例与创建外部类对象有什么关系？
删除包含“o.super()”的行，导致错误：
java:
浏览 4提问于2016-09-05得票数 0
回答已采纳
1回答
我有两个关于内部课程的问题。首先是扩展和重写子类中内部类的方法和属性。
假设我有一个包含派生属性的内部类的超类。
class ASuper implements Serializable {
// Attributes, methods
int a;
int b;
class Inner {
// Derived attributes, methods
int c;
int d;
public calculate() {
c = a + b;
浏览 3提问于2015-07-28得票数 0
5回答
只是想确认一下。
public class Indeed{
public static class Inner implements Runnable{
public void run()
{
System.out.println("Indeed");
}
}
public static void main (String []args)
{
Indeed.Inner inner = new Indeed.Inner();
inner.run();
}
}
正如您在上面的代码中所看到
浏览 1提问于2013-05-28得票数 0
回答已采纳
2回答
C++软件体系结构与设计
、、、
在我的C++程序中，我想创建一个具有宽度、高度、面积等属性的对象。我还想声明使用和更新这些属性的方法。
我希望“设置”和“获取”属性“宽度”的方法以某种方式列在一个名为WidthManipulator的头、命名空间或子类(无论如何都是可能的)中。
我想以这种方式创建我的结构的原因是，我想对另一个类的另一个方法使用"get“名称，比如HeightManipulator。
但是对于嵌套类，我得到了Rectangle::WidthManipulator:: get ()的“非法调用非静态成员函数”错误。我也不想创建操纵器对象，因为这些类没有属性，只有使用和更新父属性的方法……还有一件事，我想
浏览 0提问于2013-06-26得票数 1
回答已采纳
我没有在我搜索的问题中找到答案，这就是我问这个问题的原因。
class outer
{
class inner // non static .
{
}
}
For creating object of inner class I am unable to understand the logic of the part to the right of assignment operator .
outer o = new outer () ;
outer.inner y = o. new inner () ; // I have doubt in this line .
在这里，ou
浏览 5提问于2017-04-02得票数 2
回答已采纳
1回答
内部嵌套类的XML视图异常
、、、、
如果视图类(JavaCameraImageView)作为外部类在XML布局中膨胀，那么我有一些代码工作得很好，没有错误；如果类包含在主活动类外部的同一个.java文件中，那么它也能工作。但是，当我尝试使用JavaCameraImageView类作为主类的内部类时，我会得到这里显示的错误和logcat输出。如何使它作为嵌套的内部类工作？
Logcat结果
01-14 15:17:37.486: E/AndroidRuntime(8347): FATAL EXCEPTION: main
01-14 15:17:37.486: E/AndroidRuntime(8347): java.lang.
浏览 2提问于2014-01-14得票数 1
回答已采纳
3回答
据我所知，通常在Java中，静态的东西意味着你不能创建它的实例。但是如果是这样的话，为什么可以创建静态嵌套类的实例呢？这不是违背了静态的目的吗？
浏览 0提问于2019-01-11得票数 0
我有一个类在一个类内。
外部类执行一些处理来生成一个值数组。
我希望内部类能够访问外部类的数组。
是否有一个干净的方法来实现这一点？
我想在外部类中有一个方法，它调用内部类中的一个方法，向他发送数组的地址，内部类需要在其私有成员部分中保存一个指针，以便稍后通过从接收地址的方法赋值来指向它。但这感觉有点笨重。
浏览 2提问于2019-05-29得票数 0
回答已采纳
我在Java中遇到以下问题，如果内部类在外部类的方法中声明，如何初始化内部类的实例？在下面的例子中我遇到了一个编译错误。非常感谢。
class Outer {
public int a = 1;
private int b = 2;
public void method(final int c){
int d = 3;
class Inner{
private void iMethod(int e){
System.out.println("a = " + a);
浏览 4提问于2013-10-20得票数 5
很抱歉标题不好，但我想不出更好的标题了。
我有一个A类和一个B类，B类是A的子类，就像这样：
(它实际上有一个正确的名称吗？"sub“不是为继承而保留的吗？)
class A {
int i = 0;
class B {
int j = 1;
}
}
class Test {
public static void main() {
A a = new A();
B b = a.new B();
A c = ??? b ??? // get "a" back
}
}
浏览 0提问于2008-12-04得票数 6
回答已采纳
4回答
我知道要实例化一个成员内部类，您有两个不同的构造函数：
第一：
Outer out = new Outer();
Outer.Inner in = out.new Inner();
第二：
Outer.Inner in = new Outer().new Inner();
现在，我不知道为什么这段代码会编译：
public class Outer {
private String greeting="Hi";
protected class Inner {
public int repeat=3;
public void g
浏览 0提问于2018-11-13得票数 3
回答已采纳
1回答
我正在学习嵌套类。我只想知道为什么不能使用外部类的实例从静态内部类访问外部类的静态变量。
class MyListner {
static String name = "StaticApple";
String nonStaticName = "NonStaticApple";
static class InnerMyListner {
void display(){
System.out.println("Static variable of outer class: " + n
浏览 0提问于2019-02-10得票数 0
3回答
如果s1是指f1.switch()创建的新对象，那么(1)变量runningStatus是如何传递给为内部类创建的新对象的？(2)变量runningStatus是如何在内部类的对象(由s1引用)中进行更改的，反映在f1引用的扇对象中？
interface Switch
{
void on();
void off();
}
class Fan
{
private boolean runningStatus;
public Switch getSwitch()
{
return new Switch()
{
浏览 3提问于2015-10-28得票数 2
回答已采纳
2回答
我希望在某个地方接受内部类类型的参数，但我不确定如何做到这一点，例如，
class Outer(...) {
class Inner(...) { }
}
object Outer {...}
....
someFunc(arg : Outer.Inner) = {...}
但是Scala在对象外部寻找的是内部类型，而不是外部类。所以我得到“类型内部不是对象外部的成员”
如果可能的话，我不想改变外部/内部的定义。
浏览 13提问于2017-06-19得票数 0
回答已采纳
1回答
下面有一些迭代器的代码，但是我很难理解它是如何工作的。特别让我困惑的是public Node<T> front;和for语句。
前台是对静态嵌套类的引用，在for循环中有LinkedList.Node<String> ptr = list.front。操作的左侧只是访问外部类，然后访问静态嵌套类，我们将对该类进行ptr引用。操作的右侧使用外部类的对象来访问前端引用，这也是静态嵌套类。
所以左边和右边不是一回事吗？为什么代码设置一边等于另一边？我知道提供的代码不是满的-不是我写的。我只是想了解一下。
public class LinkedList<T> {
浏览 2提问于2014-04-25得票数 0
回答已采纳
2回答
package generics;
public class InnerClassGenerics{
class Innerclasss{
}
public static void main(String[] args) {
InnerClassGenerics icg=new InnerClassGenerics();
Innerclasss innerclass=icg.new Innerclasss();
}
}
上面的代码是可能的，而且编译得很好！
为什么下面的代码没有编译，并且可以参数化内部类？
package g
浏览 2提问于2014-10-19得票数 2
回答已采纳
13回答
如何从内部类访问外部类？
、、、
我的情况是这样的。
class Outer(object):
def some_method(self):
# do something
class Inner(object):
def __init__(self):
self.Outer.some_method() # <-- this is the line in question
如何从Inner类访问Outer类的方法？
浏览 6提问于2010-01-08得票数 143
回答已采纳
我想在一个伴生对象中访问传递给类构造函数的参数： class Home(private val activity: String) {
companion object {
fun doSomething() {
println(activity)
}
}
}
fun main() {
Home("Hello World").doSomething() 但是，当我运行此代码时，出现一个错误，指出activity是未解析的引用
浏览 11提问于2021-04-29得票数 1
回答已采纳
2回答
我试图从“内部”(本地)类的方法中访问“外部”类的属性，但失败了。
这不能编译
class outer
{
public:
std::string name;
class inner
{
public:
void hello();
};
void dostuff();
};
void outer::inner::hello(){std::cout << "Hello " << name << "
浏览 3提问于2017-04-16得票数 2
回答已采纳
可能重复：
public class DemoJava {
public class Hello {
void fun()
{
System.out.println("This is static fun man!!");
}
}
public static void main(String[] args) {
Hello hello = new Hello();
hello.fun();
}
}
在本例中，它将给出一
浏览 7提问于2013-01-30得票数 1
回答已采纳
4回答
今天我读了一些关于静态嵌套类的文章，因为下面的代码我有点困惑。
class testOuter {
int x;
static class inner {
int innerVar;
public void testFunct() {
x = 0; // Error : cannot make static reference to non static field
innerVar = 10;
outerFunc(this);
}
}
static void o
浏览 4提问于2013-02-09得票数 0
回答已采纳
我有A班，B班和C班。
B类是A类的内部类，如下所示：
public class A {
public class B {
String day;
HashMap<String, ArrayList<Date>> locationTimes;
public B() {
locationTimes = new HashMap<String, ArrayList<Date>>();}
}
**
浏览 5提问于2016-04-07得票数 1
回答已采纳
考虑下面的代码：
class abstract Normal1 extends Something
{
}
class Outer
{
class abstract Inner extends Normal1
{
}
}
class General extends Outer.Inner // Problem occurs at this
{
}
我得到的错误是“由于某些中间构造函数调用，没有PerfHelper类型的封闭实例可用”
我的问题是，我可以像上面那样扩展内部类吗？
浏览 0提问于2011-11-18得票数 25
已关闭。这个问题需要细节或清晰度。它目前不接受答案。 想要改进这个问题吗？添加详细信息并通过以下方式澄清问题 编辑这篇文章8天前就关门了。改进这个问题 public class OuterMain {
public static void main(String[] args) {
Outer outer = new Outer();
outer.m2();
}
}
class Outer {
public void m1() {
class Inner {
void display() {
浏览 97提问于2021-02-21得票数 -1
回答已采纳
我知道如何创建内部类的实例。但我想知道为什么我们不能这样做：
class outerclass{
public static void main(String[] args){
innerclass in=new innerclass();
}
class innerclass{
}
}
如果我这样做，我会得到以下错误：
No enclosing instance of type outerclass is accessible. Must qualify the allocation with an enc
浏览 2提问于2016-09-05得票数 1
2回答
我正在学习Java的内部和外部课程。我知道什么是内类和外部类，以及为什么要使用它们。我遇到了关于这个话题的以下问题，却找不到答案。
假设给出了以下代码：
class outer{
class inner{
}
}
class SubClass extends outer.inner{
}
问题：如何定义最小的子类构造函数？为什么？
Option 1-
Subclass () {
//reason: bacause the default constructor must always be provided
}
Option 2-
Subclass (Outer o
浏览 9提问于2017-07-18得票数 4
回答已采纳
今天，我了解到您可以在分隔符(.，或“点运算符”)旁边使用.运算符。这让我怀疑Java是否对新操作符的所有出现都隐式地使用了相同的技术。
下面的语句创建一个新的"InnerClass对象“。它使用一个新的ParentClass对象(使用.new )来实现这一点。但是，该语句中的第一个new操作符之前没有构造函数(或对象)。那么，Java在编译时添加了一个吗？我尝试在这个语句中显式地添加一个(Main())，但是代码无法编译。
ParentClass.InnerClass ic = new ParentClass().new InnerClass();
浏览 1提问于2013-12-23得票数 1
回答已采纳
下面是我用静态变量x更新OuterClass的实例变量StaticInner的代码。我理解静态内部类不能直接引用外部类的实例变量。我使用一个outerclass实例来引用它的实例变量'x‘并更新它。这会导致堆栈溢出错误。代码符合很好。代码中的最后一行没有编译，我将其注释掉。我不明白这句话有什么问题。
public class OuterClass {
private int x = 10;
private static int y = 15;
private static StaticInner si=null;
public OuterClass()
浏览 2提问于2013-11-06得票数 0
回答已采纳
以下是合法的(据我所知)：
class Outer {
void someMethod() {
// do something
}
class Inner {
void innerMethod() {
Outer.this.someMethod();
}
}
}
虽然我理解正在发生什么和结果是什么，但我不明白为什么这是好的。
我很困惑外部类的实例是如何通过静态成员语法访问的：Outer.this不应该this (对外部的一个特定实例的引用)不是静态的吗？语法是相同的，但功能是不同的，还是t
浏览 6提问于2015-07-01得票数 1
回答已采纳
1回答
默认包中定义了以下类。
Outer.java：
public class Outer {
public class Inner {
}
}
Main.java：
import Outer.Inner;
public class Main {
public static void main(String[] args) {
Outer.Inner inner = new Inner();
}
}
我得到：
内部不能解析为类型。
我知道从同一个包中实例化内部类是可能的。
怎么了，怎么解决的？
谢谢。
浏览 2提问于2014-07-02得票数 0
回答已采纳
我用blueJ制作了两个类-一个叫User，另一个叫UserGroup。我的用户类如下所示：
public class User{
public enum UserType{
ADMIN, EDITOR, USER;
}
public String id;
public UserType userPermissions;
public String actualName;
浏览 3提问于2013-11-09得票数 0
回答已采纳
1回答
我正在尝试更好地理解如何使用基于的非常简单的测试用例来使用子类。
class Outer():
def __init__(self, x):
self.x = super(Inner, self).__init__
# self.x = Inner(**kwargs)
def add_two(self):
""" """
return self.x + 2
class Inner():
def __init__(self, x=2):
浏览 6提问于2018-02-21得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
