在 Java 中，为什么未将类的 New 实例分配给变量

Question

Total beginner in Java. I have seen the line below several times and cannot understand it ... new TestCode() - it SEEMS to be an instatiation but not assigned to anything - So how can it be referred to ?

class TestCode
{
   public TestCode()
   {
       System.out.println();
       System.out.println( "Welcome to the Program");
    }

    public static void main( String args[] ){new TestCode();}

}

Answer 1

It cannot be referred to. The new instance is created and immediately discarded.

However its constructor code gets invoked, therefore side-effects (if there are such - and in your example there are - it's printing to stdout) do occur. Doing stuff like this is however a bad practice.

See Zaki's answer about assigning it to variable though. Then you can refer to it, and do stuff.

Answer 2

When you instantiate an object via the new codeword, space on the heap (the part of the system memory used to store objects and their fields) is allocated, and the constructor gets executed. In this case, the constructor writes on the standard output, and this gets executed regardless whether a reference is created to the object or not.

Afterwards, you're right, the object can not be accessed as no references to it exist. Therefore the garbage collector eventually deallocates the memory space.

Just as Adam said, this is generally discouraged though, as it messes up your expectation that a constructor should initialize the object, and interactions with the outside world should be possible via its methods.

So, even if it is a bit longer, better structured code could for example look like this:

class TestCode {
   public TestCode() {}

   public void welcome() {
      System.out.println();
      System.out.println("Welcome to the Program");
   }

   public static void main( String args[] ){
      TestCode tc = new TestCode();
      tc.welcome();
   }
}

PS Of course, there are cases where you might want to do operations outside the instance upon every instantiation anyway, for example like keeping a static list of all the instances of the class, and therefore adding the particular instance to it each time it is constructed. Even then though, it is probably best to create a private init() method and invoke it from the constructor, as to better separate elements with different function.

As another example, here is a different, functionally identical way your code could be reformulated:

class TestCode {
   public TestCode() {
      init();
   }

   private void init() {
      System.out.println();
      System.out.println("Welcome to the Program");
   }

   public static void main( String args[] ){
      TestCode tc = new TestCode();
      // Or simply: new TestCode();
   }
}