This program run successfully . What is use of blank return in constructor as we know it return this implicitly . Is it is a bug in java or have some use .
class Demo
{
int salary;
Demo()
{
salary =11500;
//return this;(implicitly)
return;
}
public static void main(String... s)
{
System.out.println(new Demo().salary);
}
}
Return in a void function is used to escape the control flow before the natural end of a function. As such, it needs to be a valid statement.
Going out of your way to explicitly forbid it as the final statement in a function serves no purpose except to break existing code.
You may want to lint for it, but you cannot make it an error or ill-formed.
return statement is unreachable.
Putting a single return at the end of the constructor doesn't change anything but it isn't harmful and is no different than putting a return at the end of a void method. However, you put a return at another point in the constructor like in a guard condition, it very much does make a difference. Since this is allowable, the value of restrict the use of return to only those situations where it isn't redundant isn't really worth the effort. It would complicate the language for no good reason.
For the caller a constructor behaves similar to a static method that returns an instance. But from the inside a constructor behaves like a void returning instance method, so not being able to specify a value on the return statement is only consistent.
You could mentally model it as new XYZ() first creating an instance initialized to zero in compiler-generated-code and then calling the user-written constructor on that instance, just like a normal instance method.
Something like:
public static T create() // Compiler generated
{
T instance = AllocateZeroed<T>();
instance.field1 = ABC; // field initializers
instance.field2 = DEF; // field initializers
...
instance.constructor(); // user-written constructor chain
return instance;
}
new is an instance method of the Class class (which, in other words, makes it a "class method"). new first calls allocate (which is also an instance method of the Class, thus a "class method"), which creates a new empty instance of self (i.e. the class it was called upon), then it calls initialize (which is an instance method in the class) on that newly allocated empty object.
new convenience helper method, and you usually call [[Foo alloc] init] manually.
if(something == true)to me. Note that, just because someone wrote it, doesn't necessarily mean that it's good.