Java 从实例调用方法

假设我有两个类，

A

和

B

，它们依次有一些方法，

something（）

和

nothing（）

，在

A

中创建了

B

的一个实例，如下所示：

public class A {

    public A() {
        B b = new B();
        b.nothing();
    }

    public void something() {
        ...
    }
}

调用

b.nothing（）

都是标准的东西，但是有没有什么方法可以通过实例

b

调用

A.something（）

，假设

A

的实例被调用

A

。如果不是，为什么这在概念上是错误的

有什么方法可以通过实例b调用a.something（）

您无法在方法中找到调用方，因此，否，无法做到这一点

如果不是，为什么这在概念上是错误的？

我立刻想到两个问题：

• 来电者的类型是什么？因为任何人都可以调用

  b.nothing（）

  ，所以你只能假设它是一个

  对象

  ，这会导致很多难看的向下转换

• b.nothing（）

  的实现不应该关心谁在呼叫他。如果重构

  A

  并将调用移动到

  b.nothing（）

  到其他类，会发生什么？如果

  b.nothing（）

  突然停止工作，那将非常令人惊讶

---

唯一的方法

b.nothing（）

可以调用

a.something（）

就是告诉

b

的实例关于

a

的实例。例如：

b.nothing(this);

其中B.没有什么看起来像：

public void nothing(A a)
{
    // Do other stuff
    a.something();
}

或者，您可以将构造函数中的

此

传递到

B

，这将保留引用：

B b = new B(this);
b.nothing();

---

请注意，在构造函数调用期间让

this

转义通常是一个坏主意-您让

B.nothing（）

对尚未完全初始化的对象调用

a.something（）

-其构造函数尚未完成执行。这有时会导致不良和难以诊断的行为。

我不认为这在概念上有任何问题

但是，为了使机制工作，

b

需要知道调用

A

的哪个实例

something（）

。为此，

B

的构造函数或其

nothing（）

方法需要将

A

引用作为参数

示例1:

public class B {
  public void nothing(A a) {
    ...
    a.something();
    ...
  }
}

public class B {
  private final A a;
  public B(A a) {
    this.a = a;
  }
  public void nothing() {
    ...
    this.a.something();
    ...
  }
}

示例2:

public class B {
  public void nothing(A a) {
    ...
    a.something();
    ...
  }
}

public class B {
  private final A a;
  public B(A a) {
    this.a = a;
  }
  public void nothing() {
    ...
    this.a.something();
    ...
  }
}

示例3:

public class B {
  public void nothing(A a) {
    ...
    a.something();
    ...
  }
}

public class B {
  private final A a;
  public B(A a) {
    this.a = a;
  }
  public void nothing() {
    ...
    this.a.something();
    ...
  }
}

还有第三种方法，适用于某些情况。如果

B

是

A

的一个内部类，则它有一个对其关联的

A

实例的隐式引用

public class A {
  public void something() { ... }
  public class B {
      public void nothing() {
        ...
        something();
        ...
      }
  }

---

}为此，

b

需要引用

a

。有两种方法可以提供：

在

B

的构造函数中传递这样一个引用，或者给

B

一个合适的setter

如果

B

是

A

的内部类，那么它隐式地具有这样一个引用

---

为什么不尝试向

B

中的方法添加代码

newa（）.something（）

？查看编译器是否抱怨，或者您是否有任何奇怪的运行时行为。@RayToal-这是假设某物（）是静态的。在这种情况下，它不是。不，我没有做那个假设。我知道

something（）

是一种实例方法。我想你误解了我的建议