1. class R implements Runnable
   
2. {
   
3.         public void run()
   
4.         {
   
5.                 System.out.println("Runnable...run");
   
6.         }
   
7. }
   
8. 
   
9. public class ThreadTest2
   
10. {
    
11. 
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 R r=new R();
    
15.                 new Thread(r)
    
16.                 {
    
17.                         public void run()
    
18.                         {
    
19.                                 System.out.println("subThread...run");
    
20.                         }
    
21.                 }.start();
    
22.         }        
    
23. }

复制代码

这段代码里的这个对象是个什么样的对象？

1. new Thread(r)
   
2. {
   
3. public void run()
   
4. {
   
5. System.out.println("subThread...run");
   
6. }
   
7. };

复制代码

求真正的大神教我，半桶水的就不要来误导我了

至于匿名内部类
因为只是用一次，所以不需要单独建一个类继承Thread接口，就产生了这种写法
new Thread(){};在花括号中重写Thread的run方法的话 ，相当于直接建立了一个Thread的子类，重写了run方法。new Thread() public void run(){  }; 这样创建的其实是一个对象 直接加   .start() 是在用对象调用方法

这段代码里面是在定义一个匿名内部类！

开启线程有两种方法一种就是R类继承Runnable，然后重写run方法，main函数启动时，需要先实例化R，即R r = new R（），然后创建Thread类即
Thread thread = new Thread(r),需要注意一点就是 把r传入Thread。然后利用 thread.start()，启动线程，其实start是在调用r对象的
run()方法

1. class R implements Runnable
   
2. {
   
3.         public void run()
   
4.         {
   
5.                 System.out.println("Runnable...run");
   
6.         }
   
7. }
   
8. public class ThreadTest2
   
9. {
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 R r=new R();
    
13.                 Thread thread = new Thread(r);
    
14.                 thread.start();            
    
15.         }        
    
16. }

复制代码

第二种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。

1. class PrimeThread extends Thread {
   
2.         public void run() {
   
3.       System.out.println("PrimeThread.....run");
   
4.     }
   
5. }
   
6. public class ThreadTest2
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 PrimeThread pt = new PrimeThread();
    
11.                 pt.start();            
    
12.         }        
    
13. }

复制代码

就只是一个匿名的线程类，重写了run方法，在线程thread调用start（）方法的时候自动调用run（）方法