在java中使用new关键字而不定义变量

Question

The following code is used to create an object of a class within a variable:

ClassName obj = new ClassName();

But what if we do not create any variable and just type the following?

new ClassName();

When I used it, there was no error. But what it actually does when no variable is created?

Answer 1

Both methods create an object, but the second method has no name for it.

When you create an instance of the ClassName, the difference between your first method and second method is that for your first method, you can actually access variables and methods within the class.

For example,

ClassName obj = new ClassName();
System.out.println(obj.x);

Where ClassName

class ClassName {
    public static int x = 2;
}

The benefit of this approach is you can access the variables within the class. If you used the second approach, then the instance would have no name, so you wouldn't be able to access the variables.

Answer 2

new ClassName() calls a special method called a constructor and, like any method, it returns a value ¹ . The value that it returns is an instance of ClassName . You can choose to assign that value to a variable, or not, just as you can do with the return value of any method. So you simply need to decide whether you need to assign the returned value to a variable, or not. If you do, then you need the first statement, namely:

ClassName obj = new ClassName();

And if you don't need to assign the returned value to a variable, then you can use:

new ClassName();

^{1 - a method can return void which means it doesn't actually return a value}

Answer 3

To answer to your question I think is useful to see how objects are managed by JVM during execution.

All java objects reside in a JVM area called heap and can ( note that this is not mandatory ) be pointed by one or more variables. The variables that hold references to objects reside on another area of JVM called stack .

Every time an instruction like new SomeClass();is executed a new object is allocated on that area. When the heap area becomes full, garbage is collected and during the garbage collection objects that are no longer pointed by a variable are cleared in order to free space on heap for new objects.

What is the difference between your two instructions?

1- ClassName obj = new ClassName();

It allocates a new object on heap that is pointed by the obj variable on stack.

2- new ClassName();

It just allocates a new object on heap with no variables on stack that point to it.

When can be useful to use the second approach?

According to this, using the second approach could be useful if you want just to allocate a new object on heap without using it through a variable for example to test memory management on your program. Actually the second approach is used when you want to create a "one-shot" object and use a method or a variable of it in the same instruction improving the garbage collector efficiency and avoiding unexpectedly get an OutOfMemoryError exception like:

• using once time an object variable:

System.out.println(new ClassName().x)

or

• executing once time an object method:

new ClassName().evaluateResult();

NOTE: In this specific case you probably could evaluate instead to make a static method on the class.

Another usage can be to put new elements on a collection as follow:

final List<ClassName> objectList = new ArrayList<>();
for(int i=0; i<10; i++){
  objectList.add(new ClassName());
}

---

You can may ask: What happens instead to objects that are pointed by at least one variable like ones created with first approach?

All references that are held in a variable are naturally dropped when the variable goes out of scope so they became eligible for garbage collection automatically ( according how their scope is managed on code ).