Q:

super() behaviour in java when calling parent constructor explicitly

class NewThread1 extends Thread{

    NewThread1(String name){

    super(name); //this line replaced by 'new Thread(name);'

    System.out.println("child Thread:"+this);

    }
}

public class ThreadCreationExtend {
   public static void main(String[] args) {
        new NewThread1("Thread1");
        new NewThread1("Thread2");
    }
}

output:child Thread:Thread[Thread1,5,main]
       child Thread:Thread[Thread2,5,main]

output after replacement: 
                          child Thread:Thread[Thread-0,5,main]
                          child Thread:Thread[Thread-1,5,main]

I'm trying to call the Thread class constructor, Thread(String name) instead of using super(name) but when i use new Thread(String name) output is coming different. Please explain the different output.
Is it because of the default super constructor? If so then how do i use the parent constructor Thread(String name) without super()?

A:

super(name) and new Thread(name); do not, remotely, do the same thing.
super(name) calls the parent constructor for the current instance, giving it its chance to initialize its part of the instance before the subclass starts the process of initializing its parts of the instance.
new Thread(name) creates an entirely separate, new Thread, and then throws it away (as you never save the result anywhere). It's exactly like any other time you use new: You're creating a new object, not calling your superclass constructor.

If so then how do i use the parent constructor Thread(String name) without super()?

Your subclass needs to give the superclass a chance to do its initialization. If you don't code a call to super(...), the Java compiler will insert a call to super() (no parameters) for you. So the question doesn't really make sense: In a Thread subclass, you give the Thread its chance to initialize by using super(...). You do not use new Thread(...) for that.
You can use new Thread in that code to create an entirely new, separate, independent thread, just like you can use new HashMap to create a new HashMap. But I very much doubt you want to. It would have nothing to do with the fact your class's superclass is Thread.

A:

If you call new Thread(String name) instead of super(name), you are creating a new Thread object (which is not related to the NewThread1 instance you just constructed), and pass to it the name parameter. Therefore your NewThread1 instance has a default name in this case (since the compiler implicitly adds super() to call the Thread parameterless constructor.
NewThread1 (String name) {
    new Thread(name);
    System.out.println("child Thread:"+this);
}

is the same as
NewThread1 (String name) {
    super(); // name is not passed to the super class constructor
    new Thread(name);
    System.out.println("child Thread:"+this);
}

