Question related to Constructors

[shyam ramineni]

Hi All,

This is a question from javacertificate.com

public class PowerSupply
   {
      public PowerSupply(String voltage){
         System.out.println ("PowerSupply(String) executed");
      }
      public PowerSupply(Object voltage){
         System.out.println ("PowerSupply(Object) executed");
      }
      public PowerSupply(){
        System.out.println ("No argument constructor execute");
    }
     public static void main(String[] args) {
        PowerSupply ps = new PowerSupply(null);
     }
  }  

Question: which of the three constructors will be called.
Answer : public PowerSupply(String) will be called.

Can anyone please explain the answer.
Shyam Ramineni

[Marcelo Ortega]

The constructer which takes a string object will be chosen because it is more specific. If you receive it as an Object type and try to use it you will get a NullPointerException.

Bottom line: A null String object has more meaning than a null Object object.

[bhavesh bhanushali]

class GrandParent
{
}

class Parent extends GrandParent
{
}

class Child extends Parent
{
}

public class NullCheck
{
public void isOn ( GrandParent g )
{
System.out.println ( " GrandParent " ) ;
}

public void isOn ( Parent g )
{
System.out.println ( " Parent " ) ;
}

public void isOn ( Child g ) // ( 1 )
{
System.out.println ( " Child " ) ;
}

public static void main ( String args[] )
{
NullCheck nc = new NullCheck ( ) ;
GrandParent g = new GrandParent ( ) ;
Parent p = new Parent ( ) ;
Child c = new Child ( ) ;

nc.isOn ( g ) ;
nc.isOn ( p ) ;
nc.isOn ( c ) ;
nc.isOn ( null ) ; // ( 2 )
}
}
------------------------------------------------------------------

when this code is executed the line at ( 2 ) will call the method at ( 1 )
since the Child class is the smallest in the inheritance heirarchy , as a result of which it is chossen for execution hwen the method isOn ( ) is called with "null" as the formal parameter

since object --> string ( ie. the string class is derived form the object class ) , so when the method is called with the null parameter the method corresponding to the string is executed

iam including one more code whichh illustartes this issue more

regards,
bhavesh

[shyam ramineni]

Hi Bhavnesh,

Thanks for sample code.

Shyam Ramineni

[Georgy Bolyuba]

Originally posted by Marzo Kaahn:
If you receive it as an Object type and try to use it you will get a NullPointerException.

And what will happend if you receive it as an String type and try to use it? As you can guess, you will get a NullPointerException.

[Georgy Bolyuba]

Hi

That's what I've found in JLS

Widening Reference Conversions:

From any class type S to any class type T, provided that S is a subclass of T. (An important special case is that there is a widening conversion to the class type Object from any other class type.)

From the null type to any class type, interface type, or array type.

So, then a compiler see this code:

class A{}
class B extends A{}
class C extends B{}
 
class Test{
  void foo (A a);
  void foo (B b);
 
  public static void main (String[] args)
  {
    C c = new C();
 
    foo (c);     // Line 1
    foo (null);  // Line 2
  }
}

In Line 1 there are two methods which can be called. foo (A a) and foo (B b). The compiler will choose nearest widening reference conversion and foo (B b) will be called.

The same situation appears in Line 2. null can be "widened" to any class type. Once again, the compiler will choose nearest widening reference conversion and foo (B b) will be called.

As you can guess, this code will cause a compile time error (in Line 1):

class A{}
class B{}
 
class Test{
  void foo (A a);
  void foo (B b);
 
  public static void main (String[] args)
  {
    foo (null);     // Line 1
  }
}

That's all, folks.

[shyam ramineni]

Hi All,

This is a similar kind of question from Dan's Website.
Answer is it fails to compile.
I couldnot understand the reason stated in the website.
Can anyone explain the result.

class GFC211 {}  class GFC212 extends GFC211 {}
class GFC213 extends GFC212 {
  static void m(GFC211 x, GFC211 y) {System.out.print("GFC211,GFC211");}
  static void m(GFC211 x, GFC212 y) {System.out.print("GFC211,GFC212");}
  static void m(GFC212 x, GFC211 y) {System.out.print("GFC212,GFC211");}
  static void m(GFC212 x, GFC212 y) {System.out.print("GFC212,GFC212");}
  static void m(GFC211 x, GFC213 y) {System.out.print("GFC211,GFC213");}
  public static void main(String[] args) {
    GFC213 gfc213 = new GFC213(); m(gfc213, gfc213);

Thanks
Shyam Ramineni

[Devender Thareja]

Originally posted by shyam ramineni:
Hi All,

This is a similar kind of question from Dan's Website.
Answer is it fails to compile.
I couldnot understand the reason stated in the website.
Can anyone explain the result.

class GFC211 {}  class GFC212 extends GFC211 {}
class GFC213 extends GFC212 {
  static void m(GFC211 x, GFC211 y) {System.out.print("GFC211,GFC211");}
  static void m(GFC211 x, GFC212 y) {System.out.print("GFC211,GFC212");}
  static void m(GFC212 x, GFC211 y) {System.out.print("GFC212,GFC211");}
  static void m(GFC212 x, GFC212 y) {System.out.print("GFC212,GFC212");}
  static void m(GFC211 x, GFC213 y) {System.out.print("GFC211,GFC213");}
  public static void main(String[] args) {
    GFC213 gfc213 = new GFC213(); m(gfc213, gfc213);

Thanks
Shyam Ramineni

Could you please provide the answer given on web site?

[shyam ramineni]

Hi,

Answer(gives in website): Fails to Compile.

Shyam Ramineni

[Prasanta Chinara]

Mr George Bolyuba: that was a nice explanation.

Could any of you please explain the following:

class bas{}

class der extends bas{}

public class Main {
public void f1(String o){
System.out.println("String");
}
public void f1(der o){
System.out.println("der");
}
public static void main(String[] args){
new Main().f1(null); //----> AMBIGUOUS
}
}

Why is it ambiguous now?
Object->String
Object->bas->der

So (Mr George Bolyuba - beg your attention), it should not be ambiguous.

You can claim der also extends from object. OK .. but a given class has only one super class and der has bas as its super class bas.

[Marcos Vilela]

It's ambiguous because String and the other class are in different hierarchy so how the compile will know wich one is the most specific class? It's differet if you have one parameter as an OBject and another as a String. As we know String extends object, so String is more specific. If you pass null, the compiler will run the method that has a String as an argument.

[Prasanta Chinara]

Thanks Marcos. Thats neat :-)