What is the output of the above program?

class Num  {
      Num(double x ){
              System.out.println( x ) ;
      }   
}
public class  Test  extends  Num   {
       public static void main(String[] args){
                  Num num = new Num( 2 ) ;
       }     
}

In this code, the Test class extends the Num class, but the Num class does not have a default constructor (a constructor with no parameters). The Java compiler automatically inserts a call to the superclass constructor (super()) at the beginning of the Test class constructor. Since the Num class only has a constructor that takes a double argument and no default constructor, the compiler will throw an error because it cannot find a Num() constructor that takes no arguments.

As there is no parametrised constructor which is calling super(x) from the Test class, it is giving us error. We need to explicitely declare a super(x) in order to get 2.0 as answer,

C is correct Answer
The compile-time legality of a casting conversion is as follows:
1. An expression of a primitive type may undergo casting conversion to another primitive type, by an identity
conversion (if the types are the same), or by a widening primitive conversion, or by a narrowing primitive
conversion, or by a widening and narrowing primitive conversion.
2. An expression of a primitive type may undergo casting conversion to a reference type without error, by
boxing conversion.
3. An expression of a reference type may undergo casting conversion to a primitive type without error, by unboxing conversion.

thus you have to manually typecast value before passing to the constructor.
Ex :
1. Num num = new Num((double) 2); // this is right as passing primitive type to construtor accepting reference
type of same type. So you to do typecasting manually.
2. Num num = new Num(new Double(2)); // is right by Rule 2.

3. Num num = new Num(2); this is wrong as By Rule 1: as you are passing an integer value (primitive type ) to the constructor which accepts Double (reference type of different type).

Out put is 2.0
Because in java every number stored in double data type memory

main() class must be parent class but in this example test class inherits num class which is wrong
but if we do changes like num class inherit test class that will become right and will output 2.0

incorrect answer output is 2.0

You cannat call the constructor of base class directly without super key word.

It will work:
class Num{
Num(double x)
{
System.out.println("Hi");
}
Num(int x)
{
System.out.println("Hi2");
}

}
class Test extends Num {
Test(){
super(2.0);
}
public static void main(String args[]) {
Test b =new Test();

}
}

please explain why compile time error?

If Test class doesnot extends Num then it then ans is 2. otherwise it is compile time error

please read the question carefully......if Test class is not child class of Num then it is correct...

ans is b

Compile time error. becs it has not default constrcter

Is this correct answer???

Incorrect option c. correct ans is 2.0 as int will automatically converted to double data type.