1. public class ThreadDemo {
   
2.         public static void main(String[] args) {
   
3.                 Test t_1 = new Test("one");
   
4.                 Test t_2 = new Test("two");
   
5.                 t_1.start();
   
6.                 t_2.start();
   
7.         }
   
8. }
   
9. 
   
10. class Test extends Thread {
    
11.         private String name;
    
12.         Test (String name) {
    
13.                 this.name = name;
    
14.         }
    
15.         public void run() {
    
16.                 System.out.println(this.getName());
    
17.                 for (int i = 0; i < 60; i++) {
    
18.                         System.out.println(Thread.currentThread().getName() + "...run" + " " + i + " times.");
    
19.                 }
    
20.         }
    
21. }

复制代码

如上段代码所示，创建一个Test子类继承Thread，并有自己的构造方法。构造方法里有要传递的参数，参数即为该线程的名称
按理说，Test类创建对象并启动时，线程通过getName()方法获取的应该是往构造函数里面传递的name参数，但是打印出来的结果却是默认的Thread-0
视频里是用super(name)的方法直接继承父类的构造方法，这个可以理解。但是不使用super方法应该也能达到同样的目的啊，为什么却是默认的线程名称呢？
求解。

1. public class ThreadDemo {
   
2.         public static void main(String[] args) {
   
3.                 Thread t_1 = new Test("one");
   
4.                 Thread t_2 = new Test("two");
   
5.                 t_1.start();
   
6.                 t_2.start();
   
7.         }
   
8. }
   
9. 
   
10. class Test extends Thread {
    
11.         private String name;
    
12.         Test (String name) {
    
13.                 super.setName(name);
    
14.         }
    
15.         public void run() {
    
16.                 System.out.println(this.getName());
    
17.                 for (int i = 0; i < 60; i++) {
    
18.                         System.out.println(Thread.currentThread().getName() + "...run" + " " + i + " times.");
    
19.                 }
    
20.         }
    
21. }

复制代码

你继承创建的是自己name…… 有没给父类的构造传什么

我把打印语句的Thread.currentThread().getName()换成this.getName()结果还是默认的Thread-0

1. 
   
2. <P>public class ThreadDemo {
   
3.         public static void main(String[] args) {
   
4.                
   
5.                  Test t_1 = new Test("one");
   
6.                 Test t_2 = new Test("two");
   
7.                 t_1.start();
   
8.                 t_2.start();
   
9.         }
   
10. }
    
11. 
    
12. class Test extends Thread {
    
13.       
    
14.                
    
15.                 private String name;   
    
16.                 Test (String name) {
    
17.                 this.name = name;
    
18.                                 /*第二种方式
    
19.                                         super(name);
    
20.                                 */
    
21.         }
    
22.                
    
23.         public void run() {
    
24.                 System.out.println(this.getName());
    
25.                 for (int i = 0; i < 60; i++) {
    
26. 
    
27.      /*第一种方式
    
28.         System.out.println(name + "...run" + " " + i + " times.");
    
29.         System.out.println(Thread.currentThread().getName() + "...run" + " " + i + " times.");
    
30.         */
    
31.          System.out.println(Thread.currentThread().getName() + "...run" + " " + i + " times.");
    
32.                 }
    
33.         }
    
34. }
    
35. </P>

复制代码

/*
第一种方式：通过构造函数传入一个字符串，在输出时将字符串加在一起输出。这种方式并不是真的给线程命名，
                        只是给主观的给线程一个标识，实际上线程名称还是默认的Thread-0...等。

第二种方式：因为线程在构造时可以直接传入名称，同样通过构造函数传入字符串，但是在构造函数里，要调用父类Thread
                        的构造方法才行。子类调用父类构造函数通过super();因为是调用带参数的构造函数所以采用super(name);

第三种方式：通过setName方法。在主函数里通过以下四句话
                                Test t_1 = new Test();
                                Test t_2 = new Test();
                                t_1.setName("one");
                                t_2.setName("two");
                        这时记得把下面的话注释掉，因为通过这种方法，就没必要再用到构造函数了。
/*               
                private String name;
                Test (String name)
                        {
                             this.name = name;                                
                        }
               
*/

Test继承自Thread，可是在Test构造函数中，你没有显示调用Thread有参数构造函数，这样在构造子类对象的时候，系统将会首先调用Thread的无参构造函数，

1. public Thread() {
   
2.         init(null, null, "Thread-" + nextThreadNum(), 0);
   
3.     }

复制代码

在init函数中，"Thread-" + nextThreadNum()赋值给name属性，所以调用getName()函数时返回Thread-0

1. public final String getName() {
   
2.         return String.valueOf(name);
   
3.     }

复制代码

发表个人观点：
我觉得了解问题要本质，我个人认为是楼主没有理解好继承的相关知识点，运行如下代码：

1. class Demo {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Zi zi = new Zi();
   
5.                 System.out.println(zi.getName());  // 输出结果是:   Fu
   
6.         }
   
7. }
   
8. 
   
9. class Fu {
   
10.         public String name = "Fu";
    
11.         
    
12.         public String getName() {
    
13.                 return name;
    
14.         }
    
15. }
    
16. 
    
17. class Zi extends Fu {
    
18.         public String name = "Zi";
    
19. }

复制代码

从上面代码的输出结果可知，子类调用父类的getName方法，访问的是父类的name，而不是子类的name，所以你应该知道问题所在了吧！
你想调用子类的getName来获取子类的name的话，你可以覆盖 父类的getName方法，这样获取name就是子类的name了，如下：

1. class Zi extends Fu {
   
2.         public String name = "Zi";
   
3.         
   
4.         public String getName() {
   
5.                 return name;
   
6.         }
   
7. }

复制代码

但这个覆盖 对于你的Thread的子类不管用，为什么呢？查看Thread的getName方法的源代码如下：

1. public final String getName() {
   
2.             return String.valueOf(name);
   
3.     }

复制代码

我们看到 Thread的getName方法是final的，也就是说是最终的，是不能覆盖的不知道我的这个答案是否比上面的要正确，给点技术分吧！

多谢楼上各位，我看了源码，差不多都明白了