什么时候可以在该类方法中创建类的对象

public class TestClass(){
    public static void main(String []args) {
        TestClass t1 = new TestClass();
        t1.anything();
    }
}

在同一类的定义中创建对象并不奇怪？因为在响应中 - 此对象创建一个新对象，然后这个新对象会创建另一个对象，而无限循环开始永不结束。blockquote>

在同一类的定义中创建对象并不奇怪比响应对象创建一个新对象，然后是这个新对象创建另一个，无限循环开始

不，主要方法仅在运行程序时运行一次。它不会再次执行。因此，该对象只能创建一次。

想想您的主要方法在班上。创建类的实例，并使用创建的实例。因此，当您从main方法创建一个实例时，调用构造函数以初始化实例的状态，然后当构造函数返回时，执行主方法的下一个语句。

实际上，您可以考虑main方法不作为类实例的一部分。

但是，如果您在构造函数（例如0-arg）中创建了类的实例，并且作为实例参考变量的引用，则会变成无限的递归。

public class A {
    private A obj;
    public A() {
        obj = new A();  // This will become recursive creation of object.
                        // Thus resulting in StackOverflow 
    }
}

如果您尝试执行以下操作，则只会有一个无限循环（堆栈溢出错误）：

public class TestClass {
    public TestClass() {
        TestClass t = new TestClass();
    }
}

和其他地方，您尝试创建类TestClass的对象。

public class TestClass{
  public static void main(String []args) {
    TestClass t1 = new TestClass();
    t1.anything();
  }
}

这是一个完全有效的代码。当调用main方法时，不存在TestClass的事先实例（不需要main方法是static）。

public class Test2{
  public Test2 clone(){
    return new Test2();
  }
}

这也是完全有效的。创建test2的新实例时，它包含clone方法，但该方法未自动执行。只有在调用clone方法时，创建了test2的另一个实例。

public class MyLinkedList{
  MyLinkedList next;
  MyLinkedList(int elems){
    if(elems>0){
      next = new MyLinkedList(elems-1);
    }else{
      next = null;
    }
  }
}

也是完全有效的，即使构造函数使用同一构造函数创建新实例，因为创建是由有条件的，因此创建一个实例有时触发了新的创建。

public class Fail{
  public Fail(){
    new Fail();
  }
}

是这里唯一有问题的例子。编译器不抱怨。它可以将其翻译成字节代码，并执行可以执行。但是，在运行时，您会导致堆栈溢出：

分配了新的失败
它的no-arg构造函数称为
构造函数试图创建新的失败
分配了新的失败
它的no-arg构造函数称为
...

编译器允许这样做，因为通常，编译器无法防止所有无限递归。编译器允许任何可以翻译成bytecode 的内容。

编译器，但是， May 发行A 警告，如果它检测到方法或方法链

这并不是很奇怪。我知道的所有面向对象的语言都允许这样做。该代码在对象定义上是语义上的一部分，但实际上可以将其视为与任何给定对象的实际状态分开的。因此，没有循环，因为对象构造没有调用您的方法（当然，除非确实如此 - 然后您有问题）。

当您使用新来创建对象构造函数时，该启动了该实例变量，直到调用超级类的所有构造函数为止。如果您将某些代码内部构造函数放置，该代码每次创建对象

当程序启动时，则执行主方法。在Java中，您无法在类外部创建一种方法。所有方法必须封装在类中。因此，作为程序的入口点的主要方法必须在类中。当您运行此程序时，主方法将运行一次，并将执行其中的代码。在您的情况下，它会创建一个封闭类TestClass的对象。这不必发生。它也可以在此类之外创建对象。您只会按照 @adarshr的答案中的解释。

这一点都不奇怪。您会看到，main()方法是执行的起点。因此，象征性的Java是"盲目的"（没有看到您告诉它执行/运行的内容）除非它具有" Seed"main()方法。这是在"看到"之后main()方法现在具有执行以下其他指令的能力，因此，作为外卖，main()方法实际上不属于其自己的类中的对象。

对于递归，只有在您做@RoHit Jain所说的事情时才发生。或根据您的代码，您不调用anything，而宁愿调用main()本身。

    public static void main(String []args) {
        TestClass t1 = new TestClass();
        main(String[] args);
    }
}

参考变量t1实际上没有调用main，因为它是静态的。好事是，您的代码不是" jvm＆quot"，因此， main并不是sensu stricto，您无法从那里删除静态。这将导致一些良好的错误消息明确地告诉您静态应该在那里。这就是为什么您会在上面的片段中看到对象未调用main()。

如果您这样做这些，则会发生递归，除了您可以在其自己的类中创建一个对象。尽管我不建议这样做。让一个类具有main()方法，并在该主类中实例化（创建对象）其他类（包含主方法的类）。这样，您可以一次运行代码。

相关内容

最新更新

热门标签：