1、定义一个类Rrr实现Runnable()接口，重写run()方法；
2、定义一个类Ttt继承Thread类，重写构造方法Ttt(Runnable p)，重写run()方法；
3、创建Rrr类的对象r，利用r创建新线程t；
4、t.start()；
会运行哪个run呢？

1，必须实现run
2,Ttt重写构造方法，你是怎么实现构造方法的，如果你没有调用super(Runnable p),那么肯定不会运行Rrr中的run方法
   重写run方法，new Ttt后，start->run,所以必须执行到你重写的run方法中，然后如果你不调用super.run(),依然没法运行Rrr中的run方法
这是一条程序链，两个run并没有实质性的互斥性。

这个很好回答，
如果你覆写了Thread中的run和也写了个带runnable参数的构造函数，那你创建一个实现Runnable接口的实现类就没必要了，因为Thread的run方法中是调用传入的Runnable的run方法；

1. 
   
2. public class Demo1 {
   
3.         public static void main(String[] args) {
   
4.                 //new MyThread().start();
   
5.                 new MyThread(new MyRun()).start();
   
6.         }
   
7. }
   
8. class MyThread extends Thread{
   
9.         MyThread(Runnable r){
   
10.                 //代码略。。
    
11.         }
    
12.         public void run(){
    
13.                 System.out.println("MyThread....run");//原Thread的run方法是调用Runnable r的run方法；
    
14.         }
    
15.        
    
16. }
    
17. class MyRun implements Runnable{
    
18. 
    
19.         @Override
    
20.         public void run() {
    
21.                 System.out.println("MyRun.....run");
    
22.         }
    
23.        
    
24. }

复制代码

高彰谦 发表于 2012-4-26 11:20
1，必须实现run
2,Ttt重写构造方法，你是怎么实现构造方法的，如果你没有调用super(Runnable p),那么肯定不 ...

Ttt的构造方法是
Ttt(){
    super();
}
Ttt(Runnable r){
      super( r);
}
这样建了Rrr的对象r，用Ttt(r)创建新的Ttt对象t，
t.start();

早上出门匆忙，没表达清楚~

林德燚 发表于 2012-4-26 12:03
这个很好回答，
如果你覆写了Thread中的run和也写了个带runnable参数的构造函数，那你创建一个实现Runnable ...

就是这个意思，不过我设想的构造方法是
MyThread(Runnable r){
    super(r);
}
这样可行吗？

你这段代码写得真不错，我晚上回去试试。~谢谢！

岳伟伟 发表于 2012-4-26 12:47
Ttt的构造方法是
Ttt(){
    super();

还有一个关键的就是Ttt的run方法你是怎么重写的啊

岳伟伟 发表于 2012-4-26 12:49
就是这个意思，不过我设想的构造方法是
MyThread(Runnable r){
    super(r);

可以，都是调用MyThread的run方法，只要你run方法没有调用Runnable r的run方法就不会执行r的run方法；

高彰谦 发表于 2012-4-26 12:56
还有一个关键的就是Ttt的run方法你是怎么重写的啊

public void run(){

                System.out.println("Ttt....run");//原Thread的run方法是调用Runnable r的run方法；

        }

这样OK吗？

感觉这个程序很有意思，有兴趣的朋友看看，跟楼主的问题没有太大关系。
package test;
class MyThread extends Thread {
MyThread(Runnable r) {
  // 代码略。。
  r.run();
}
public MyThread() {
  // TODO Auto-generated constructor stub
  run();
}
public void run() {
  System.out.println("MyThread....run");// 原Thread的run方法是调用Runnable
            // r的run方法；
}
}
class MyRun implements Runnable {
@Override
public void run() {
  System.out.println("MyRun.....run");
}
}
public class Demo1 {
public static void main(String[] args) {
  new MyThread().start();
  new MyThread(new MyRun()).start();
}
}
运行结果：
MyThread....run
MyThread....run
MyRun.....run
MyThread....run