class Demo extends Thread
{
        private String name;
        Demo(String name)
        {
//                super(name);
                this.name = name;
        }
        public void run()
        {
                int[] arr = new int[3];
                System.out.println(arr[3]);
                for(int x=0; x<10; x++)
                {
                        System.out.println("....x="+x+".....name="+Thread.currentThread().getName());
                }
        }
}




class ThreadDemo3
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo("旺财");
                Demo d2 = new Demo("xiaoqiang");
                d1.start();
               
                d2.start();

                System.out.println(4/0);//throw new ArithmeticException();

                for(int x=0; x<20; x++)
                {
                        System.out.println(x+"...."+Thread.currentThread().getName());
                }
        }
}

这段代码里面Demo 不是对象吗  怎么又出了个线程对象名 Thread-0  Thread-1 什么的？？？ 不是很理解？

Demo 表示线程类，线程的名字java中有自己的命名规则，

我把你的代码改简单点方便清晰的讲解
class Demo extends Thread   //继承Thread
{
        private String name;      
        Demo(String name)   //构造函数用于初始化 name
    {
         this.name = name;  
  }
        public void run()     //覆盖Thread中的run（），*必须
   {
              for(int x=0; x<10; x++)
                {
                        System.out.println(name+"      "+x);   
/*
name和x的值name你传的什么就打印什么，你可以理解成你给这个线程的命名
*/
           }
        }
}


class ThreadDemo3
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo("旺财");      
                Demo d2 = new Demo("大象");   
/*
这个就说一点，旺财传进去，去Demo(String name)  里面
/

               d1.start();
                d2.start();
        }
}

你说的那个结合你的代码，让我有点乱了，
Thread.currentThread().getName()
你的问题出现在这个上面
你可以这么理解开枪打鸟，开第一枪 开第二枪...
不过java是0，1，2，3
理解了吧

      呵呵，就是给线程自己起个名字嘛。如果同时开启了两个线程，你还能分清楚。如果是同时开了上百个线程呢？为了区分每个线程的作用，给他一个名分而已。当然，你也可以根据自己的喜好，取阿猫阿狗。

1. 
   
2. <DIV class=blockcode>
   
3. <BLOCKQUOTE>
   
4. <P>class Demo extends Thread//创建Demo类，并集成Thread类-------------创建线程
   
5. {
   
6. private String name;
   
7. Demo(String name)//构造函数
   
8. {
   
9. // super(name);
   
10. this.name = name;
    
11. }
    
12. public void run()//重写run方法
    
13. {
    
14. int[] arr = new int[3];
    
15. System.out.println(arr[3]);
    
16. for(int x=0; x<10; x++)
    
17. {
    
18. System.out.println("....x="+x+".....name="+Thread.currentThread().getName());
    
19. }
    
20. }
    
21. /*
    
22. static Thread CurrendThread():获取当前线程对象。
    
23. getName():获取线程名称
    
24. 如果用户不去设置就会有JVM默认设置好的线程命名方式命名
    
25. thread-0.。。。。。。。。
    
26. */
    
27. 
    
28. 
    
29. class ThreadDemo3
    
30. {
    
31. public static void main(String[] args)
    
32. {
    
33. Demo d1 = new Demo("旺财");
    
34. Demo d2 = new Demo("xiaoqiang");
    
35. d1.start();
    
36. 
    
37. d2.start();
    
38. 
    
39. System.out.println(4/0);//throw new ArithmeticException();
    
40. 
    
41. for(int x=0; x<20; x++)
    
42. {
    
43. System.out.println(x+"...."+Thread.currentThread().getName());
    
44. }
    
45. }
    
46. }
    
47. /*
    
48. 就像这个例子
    
49. Demo d1 = new Demo("旺财");
    
50. Demo d2 = new Demo("xiaoqiang");通过了构造函数为进程命名
    
51. 然后通过Thread.currentThread().getName()来获取进程名，这样在打印的就是自己取得名字了
    
52. 而不是thread-0...........
    
53. */
    

复制代码

Demo 只是线程这个类的名字，不是线程的名字，线程的名字是楼主所写的
        private String name;
        Demo(String name)
        {
//                super(name);
                this.name = name;
        }
中的name  是线程的一个属性。 以为Dome是继承了Thread类的，所以可以用父类的构造方法实现线程名字的赋值。
         Demo(String name)
        {
            super(name);
        }
Thread-0  Thread-1 是线程默认的名字，也就是说如果定义线程没有构造函数Demo（String name）
而是默认 Demo（） 且Demo d1 = new Demo();
则线程名字就会是默认线程名字

想为使用Demo的线程起名字吗？在run方法中加setName( )方法就O了，e.g.:setName(name)，就能看到旺财和小强了~