class Test extends Thread
{
        Test(String name)
        {
          super(name);//super不是调用父类中的名字吗？为什么main函数中会出现one two？
        }
        public void run()
        {
           for (int x=0;x<50 ;x++ )
           {
                   System.out.println(this.getName()+"run--"+x);
           }
        }
}
class ThreadTest
{
        public static void main(String[] args)
        {
                Test t1=new Test("one--");//这哪是父类？不就是创建线程吗？
                Test t2=new Test("two--");
                t1.start();
                t2.start();
                for(int x=0;x<50;x++)
                {
                     System.out.println("main--"+x);
                 }
        }
}

这个类继承自Thread，super()确实是调用父类的构造方法，但是父类的构造方法也是给线程起名字，new Thread（“。。。”）的时候，就是创建线程传的参数也就是线程的名字。就算你把构造函数去掉，也能传递参数，传递的参数也还是线程的名字。

class Test extends Thread //Test 继承了 Thread 也就具备了Thread的方法。

{
        Test(String name)
        {
          super(name);//这里是将参数 name  传递给父类Thread的构造函数Thread（String name），也就相当于给线程起名字。不然默认名字是Thread_X (X从0开始）
     }
        public void run()
        {
           for (int x=0;x<50 ;x++ )
           {
                   System.out.println(this.getName()+"run--"+x);//在Test 类里面没有定义这个函数，所以这里的getName（）函数是从父类继承过来的，而父类中这个函数返回的值又是从构造参数中获取，所以打印出来的名字就是你传入构造函数的参数了。
           }
        }
}

class Testx extends Thread
{
        Testx(String name)
        {
          super(name);//super不是调用父类中的名字吗？为什么main函数中会出现one two？
        }
        public void run()
        {
           for (int x=0;x<50 ;x++ )
           {
                   System.out.println(this.getName()+"run--"+x);
           }
        }
}

public class aa
{
        public static void main(String[] args)
        {
                Test t1=new Test("one--");//这哪是父类？不就是创建线程吗？        
                这地方还没有去启动线程，只是个普通类。那么就不会先去执行run()方法，而是Test类的构造方法。new 他时便去运行Test这个类的带参数的构造方法，
                你的Test构造方法又去调用父类的构造方法（也就是Thread的带一个参数的构造方法）， 这个方法就会以你传入的参数作为名字从新分配一个Thread对象，这个对象的名字就是你传入的名字
                所以又有一个线程对象了，所以你启动线程后看到的就有 one和two了
               
                Testt2=new Test("two--");---综上所诉。。
                t1.start();
                t2.start();
                for(int x=0;x<50;x++)
                {
                     System.out.println("main--"+x);
                 }
        }
}

1. class Test extends Thread
   
2. {
   
3.         Test(String name)
   
4.         {
   
5.           super(name);//super不是调用父类中的名字吗？为什么main函数中会出现one two？
   
6.         }
   
7.         public void run()
   
8.         {
   
9.            for (int x=0;x<50 ;x++ )
   
10.            {
    
11.                    System.out.println(this.getName()+"run--"+x);
    
12.            }
    
13.         }
    
14. }
    
15. class ThreadTest
    
16. {
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 Test t1=new Test("one--");//这哪是父类？不就是创建线程吗？
    
20.                 Test t2=new Test("two--");
    
21.                 t1.start();
    
22.                 t2.start();
    
23.                 for(int x=0;x<50;x++)
    
24.                 {
    
25.                      System.out.println("main--"+x);
    
26.                  }
    
27.         }
    
28. }

复制代码

你的Test t1=new Test("one--")调用
Test(String name)
        {
          super(name);// 而这儿会调用Test的父类的Thread的 public Thread(String name)方法，该方法会分配一个新的线程对象，name是该线程的名字。
      }
你的主函数中Test t1=new Test("one--"); Test t2=new Test("two--");就创建了名字为one--和two--的两个线程，调用的是Thread的
public Thread(String name)方法，所以主函数自然后打印one--run,two--run,main--run。

因为Test t1=new Test("one--")调用了子类中构造函数，this.name()返回来的就是one--

因为Test t1=new Test("one--")调用了子类中构造函数，this.name()返回来的就是one--