Question

假设我们有一个类似这样的课程：

class XCopy {
    public static void main(String[] args) {
        int orig = 42;
        XCopy x = new XCopy();
        int y = x.go(orig);
        System.out.println(orig + " " + " y);
    }
}

我知道go方法丢失了，但没关系。这有用吗？它看起来是这样，但我无法在脑海中描绘出课堂内的自我引用是如何起作用的;它有任何副作用吗？为什么这样做？这不是某种无限的递归循环吗？

无论如何，我只是无法弄清楚它是如何工作的;提前谢谢。

Answer 1

致电

XCopy x = new XCopy();

你实际上是在调用XCopy的空构造函数，而不是主函数。

所以，这些电话看起来像是：

JVM calls XCopy.main();
main method creates new instance of XCopy by calling XCopy's empty constructor
XCopy constructor ends
main method ends -> program ends

Answer 2

我知道你正在看这个，并认为这是一个鸡和鸡蛋类型的问题，但它根本不是。

如果这是您的第一个OO语言，您可能会对Java的术语感到困惑。 Java有一种称为“静态方法”的东西。你是main（String []）方法是一个静态方法。这些静态方法实际上只是普通的旧函数。另一方面，面向对象的方法称为“实例方法”或仅称为“方法”。人们常常对术语不屑一顾。

在Java中，必须在与类相同的位置定义函数（即静态方法），并使用该类的名称来标识它。但是，它仍然只是一个普通的旧功能。有时一个类只有一堆松散相关的函数/静态方法。就像Math类有一堆关于数学的函数。有时候像字符串这样的更多OO类会使用OO方法抛出一些静态方法/函数。

在你的程序中，你的主要功能与你的班级无关。但是把它放在那里只是一个小例子仍然是完美的。

当Java启动时ALWAYS在某个主函数中启动（你可以告诉它主要函数在哪个类中）。

因此，当程序运行时，JVM会选择主函数作为有效的主函数。它运行该功能。它只是一个功能，它不需要任何对象。调用main不会创建任何对象。

现在，当你在main（String []）时，你碰巧在这里创建一个Object：

XCopy x = new XCopy();

现在，您在主函数的本地范围内有一个XCopy类型的新对象，该对象由引用（对象指针）x指向。如果XCopy有一个构造函数，它就会被调用。

所以，如果你想在头脑中描绘它，那么让我用一种虚构的语言为你写一个更清晰，更直观的语法！

这里是：

Namespace XCopy 
{
  function void main(String[]) 
  { 
    int orig = 42;
    XCopy x = new XCopy();
    int y = x.go(orig);
    System.out.println(orig + " " + " y);
  }
}

Class XCopy
{
   method int go(int i) 
   {
      ....
      return whatever;
   }
}

在这个其他语言的语法中，你可以看到你有一个函数，一个类有一个方法，你有一个该类的实例。

希望有所帮助!!

Answer 3

为什么会递减？ main()本身不会被调用，因此它不会递归。类在其自己的成员范围内，因此您可以创建它的实例。

以makeCopy()方法为例;它需要创建一个自己类型的另一个对象的实例。

不要认为方法是一个类/对象的“内部”，而是将一个方法从内部调用为任何尴尬的行为;方法只是一个带有隐式this参数的函数。

Answer 4

main方法是静态的，这意味着可以独立于存在Xcopy实例的事实访问其代码。因此，没有冲突或递归循环。它有自己的内存空间，与为每个类实例分配的内存空间不同。

Answer 5

main（）是静态的，因此您可以将其视为类的一部分，而不是实例的一部分。它由OS + JVM调用并创建一个类的实例。该类碰巧是定义了main（）的类，但这确实无关紧要。

Answer 6

想象一下不同的课程：

public class Person {
  private String name;
  private Person favorite;
  public Person(String name) { setName(name); }
  public void setFavorite(Person favorite) {this.favorite = favorite;}
  public Person getFavorite() { return favorite; }
  public void setName(String name) {this.name = name;}
  public String getName() { return name; }
  public static void main(String args[]) {
    Person a = new Person("Alex");
    Person b = new Person("Becky");
    Person c = new Person("Chris");
    Person d = new Person("David");
    a.setFavorite(b);
    b.setFavorite(c);
    c.setFavorite(c);
  }
}

所以，Alex最喜欢的人是Becky。贝基最喜欢的人是克里斯。但克里斯是个自恋者;他最喜欢的人是他自己。大卫没有一个喜欢的人。可悲的是，没有人认为大卫是他们最喜欢的人。

当你将自引用的概念应用于具有真实世界语义的东西时，这样的结构是否可行是否有意义？请注意，设置自引用不会创建副本。该计划中只有一名克里斯。

只要你不动摇说：“我会问每个人他们最喜欢的人是谁。然后我会问那个人他们最喜欢的人。我不是在我找到大卫之前一直停下来。因为那样，你确实有机会永远循环。

引用自身的类如何工作？

6 个答案: