new Thread(new Runnable() {

                        @Override
                        public void run() {
                                while(true) {
                                        try {
                                                Thread.sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }

                                        System.out.println("runnable---" + Thread.currentThread().getName());
                                }
                               
                        }
                       
                }) {
                        public void run() {
                                while(true) {
                                        try {
                                                Thread.sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }

                                        System.out.println("thread---" + Thread.currentThread().getName());
                                }
                        };
                }.start();

因为你只创建一个线程，实现Runnable（）接口的线程没有调用怎么可能打印，你只调用了thread的run()方法并start()

楼主，我觉得你这种写法是即实现了Thread的子类又实现了Runnable接口。
但是肯定只会执行一种run（）方法。从执行的结果来看是执行了Thread子类的方法。
我觉得类似下面这种写法

1. package Test;
   
2. 
   
3. public class TestMain {
   
4. 
   
5.         public static void main(String[] args) {
   
6. 
   
7.                 /*
   
8.                  * String str=" main"; str = str.substring(1); //通过对象调用 //str =
   
9.                  * substring(1); 这样直接调用是不行的 System.out.println(str);
   
10.                  */
    
11. 
    
12.                 /*
    
13.                 new Thread(new Runnable() {
    
14. 
    
15.                         @Override
    
16.                         public void run() {
    
17.                                 while (true) {
    
18.                                         try {
    
19.                                                 Thread.sleep(1000);
    
20.                                         } catch (InterruptedException e) {
    
21.                                                 e.printStackTrace();
    
22.                                         }
    
23. 
    
24.                                         System.out.println("runnable---"
    
25.                                                         + Thread.currentThread().getName());
    
26.                                 }
    
27. 
    
28.                         }
    
29. 
    
30.                 }) {
    
31.                         public void run() {
    
32.                                 while (true) {
    
33.                                         try {
    
34.                                                 Thread.sleep(1000);
    
35.                                         } catch (InterruptedException e) {
    
36.                                                 e.printStackTrace();
    
37.                                         }
    
38. 
    
39.                                         System.out.println("thread---"
    
40.                                                         + Thread.currentThread().getName());
    
41.                                 }
    
42.                         };
    
43.                 }.start();
    
44.                 */
    
45.                
    
46.                 new TestThread().start();
    
47.         }
    
48. 
    
49. }
    
50. 
    
51. class TestThread extends Thread implements Runnable
    
52. {
    
53.         public void run() {
    
54.                 while (true) {
    
55.                         try {
    
56.                                 Thread.sleep(1000);
    
57.                         } catch (InterruptedException e) {
    
58.                                 e.printStackTrace();
    
59.                         }
    
60. 
    
61.                         System.out.println("thread---"
    
62.                                         + Thread.currentThread().getName());
    
63.                 }
    
64.         };
    
65. }
    

复制代码

leon_hm 发表于 2014-3-19 21:10
楼主，我觉得你这种写法是即实现了Thread的子类又实现了Runnable接口。
但是肯定只会执行一种run（）方法。 ...

恩恩，我想明白了，谢谢。因为这里即实现了Thread的子类，又实现了Runnable接口的话，thread去调用start方法，start会先去子类找有没有run方法，如果找到，则使用子类的run方法，如果没有则到父类去找，应该选用实现Runnable接口的方法，因为这样更能体现面向接口编程的实现，更能体现面向对象。