接口，类，以及构造函数的问题，好复杂！

Question

类A实现了Runnable 接口，而且拥有和Thread相同的方法，比如join,sleep，Thread threadA = new Thread(A);那么threadA的join,sleep方法倒底是Thread类的还是A的？
为什么有这样的疑问呢？这涉及到接口，类，以及构造函数的问题了，就是说一个接口IA，有两个实现类CA和CB. CB有一个构造函数是利用IA来创建，而CA可以做为参数传入。那最终创建的CB与CA存在方法冲突怎么办呢？CB还是保留自己方法，还是使用CA的方法呢？

Answer 1

真受不了你,new 的命名是Thread
A只不过是作为一个构造函数的参数而已,怎么可能混淆?

Answer 2

类A实现了Runnable 接口，而且拥有和Thread相同的方法，比如join,sleep，
Thread threadA = new Thread(A);
那么threadA的join,sleep方法倒底是Thread类的还是A的？我的理解是 threadA是新线程 A是参数 跟你写的构造函数有关,如果你的构造函数不带参数,那这个A就不需要了
threadA的join sleep方法是threadA的 ,从runnable接口继承下来的

Answer 3

1、当然是ThreadA的，A不过是它内部的一个成员而已
2、当然不可能是CA的任何方法，同样它仅仅是CB的一个成员而已，所有CB的方法都绝不可能被CA所覆盖

Answer 4

threadA是新线程 A是参数 跟你写的构造函数有关,如果你的构造函数不带参数,那这个A就不需要了
threadA的join sleep方法是threadA的 ,从runnable接口继承下来的

Answer 5

还是不太明白，
threadA的join sleep方法是threadA的 ,从runnable接口继承下来的
这句话对吗？
ruunable接口只有一个方法，那就是run,join,sleep这些方法是Thread类的，类A实现了Runnable 接口，而且拥有和Thread相同的方法，比如join,sleep，
Thread threadA = new Thread(A);
那么threadA的join,sleep方法倒底是Thread类的还是A的？
你如何解释？

Answer 6

还是不太明白，
threadA的join sleep方法是threadA的 ,从runnable接口继承下来的
这句话对吗？
ruunable接口只有一个方法，那就是run,join,sleep这些方法是Thread类的，类A实现了Runnable 接口，而且拥有和Thread相同的方法，比如join,sleep，
Thread threadA = new Thread(A);
那么threadA的join,sleep方法倒底是Thread类的还是A的？
你如何解释？
－－－－－－－－－－－－－－－－－－－调用join,sleep时，当然是调用threadA本身的方法，根本不会是A的方法

Answer 7

你这么写，意味着A实现了Runnable接口，而不是继承Thread类
如果继承Thread类，则每start一次，是启动了一个新的线程实例，最后是多个线程实例；
如果实现了Runnable接口，则每start一次，是启动了一个线程的一个子应用，最后依然是一个线程实例；因此，我觉得是 传进的参数的 而不是 Thread的

Answer 8

唉，真是受不了。
这个和A到底是Runnable或者继承Thread都没有关系，JVM见到的就是threadA。所以你调用threadA的join,sleep方法根本不可能是A的，因为JVM根本见不到AA只是threadA中的一个变量而已，请你看看JDK的源代码！！
Thread的源代码中    public void run() {
if (target != null) {//这个target就是Thread(Runnable)传入的变量
    target.run();
}
    }所以绝对不是传入的参数，而是Thread类的方法！

Answer 9

一种是继承自Thread类.Thread 类是一个具体的类,即不是抽象类,该类封装了线程的行为.要创建一个线程,程序员必须创建一个从 Thread 类导出的新类.程序员通过覆盖 Thread 的 run() 函数来完成有用的工作.用户并不直接调用此函数;而是通过调用 Thread 的 start() 函数,该函数再调用 run().
    
    例如:     public class Test extends Thread{
      public Test(){
      }
      public static void main(String args[]){
        Test t1 = new Test();
        Test t2 = new Test();
        t1.start();
        t2.start();
      }
      public void run(){
        //do thread's things
      }
    }--------------------------------------------------------------------------------    
    另一种是实现Runnable接口,此接口只有一个函数,run(),此函数必须由实现了此接口的类实现.
    
    例如:     public class Test implements Runnable{
      Thread thread1;
      Thread thread2;
      public Test(){
        thread1 = new Thread(this,"1");
        thread2 = new Thread(this,"2");
      }
      public static void main(String args[]){
        Test t = new Test();
        t.startThreads();
      }
      public void run(){
        //do thread's things
      }
      public void startThreads(){
        thread1.start();
        thread2.start();
      }
    }
第一种因为继承自Thread,只创建了自身对象,但是在数量上,需要几个线程,就得创建几个自身对象;
第二种只创建一个自身对象,却创建几个Thread对象.最后不得不仰慕ChDw(米)一把，好一个受不了，让我也反思了一把，呵呵

Answer 10

to ChDw(米) ( ) ;
你说：这个和A到底是Runnable或者继承Thread都没有关系，JVM见到的就是threadA。所以你调用threadA的join,sleep方法根本不可能是A的，因为JVM根本见不到A试问一下：你怎么知道JVM根本就不到A的？
Thread threadA = new Thread(A)，
threadA是通过A来创建的，为什么JVM看到A呢？new Thread(Runnable a)这个构造函数倒底发生了什么事情？

Answer 11

这相当与.NET中的委托机制

Answer 12

JVM当然不可能直接看到Anew Thread(Runnable a)的代码是将a保存为Thread的一个类成员中而已，没有做其它任何事情！更加不可能覆盖threadA的方法

Answer 13

唉，请首先看JDK源码，就知道A不会覆盖threadA的方法了

Answer 14

看看源码。
public
class Thread implements Runnable {
...
    private Runnable target;
...
    public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
    }
...
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
...
this.target = target;
...
    }
...
    public void run() {
if (target != null) {
    target.run();
}
    } 
...
}所以说其实是threadA的run()其实最终是调用了A的run()；
但是不是覆盖此方法，而是委托调用的。