黑马程序员技术交流社区

标题: 关于线程的疑惑 [打印本页]
作者: 李文帅    时间: 2013-10-29 16:40
标题: 关于线程的疑惑
本帖最后由 李文帅 于 2013-10-29 20:43 编辑

这是公开课上付老师写的代码，那天没有听，对以下代码不怎么理解
  1. public class Demo03_StartThread {

  3.         public static void main(String[] args) {
  4.                
  5.                 new Thread(new Runnable() {
  6.                         public void run() {
  7.                                 System.out.println("B");
  8.                         }
  9.                 }) {
  10.                         public void run() {
  11.                                 System.out.println("A");
  12.                         }
  13.                 }.start();
  14.                
  15.                 // 定义了一个Thread类的子类, 重写run()方法, 创建该类对象, 传入了一个Runnable的实现类对象, 调用start()
  16.         }

  18. }
复制代码
执行结果为什么会是“A”，而不是“B”？
希望听了那天课的师兄师姐帮忙解答~
作者: 帅气的冬瓜    时间: 2013-10-29 17:50
好像是内部类
作者: 零下五度的水    时间: 2013-10-29 19:01
除非是强制调用父类方法，否则只要是被重写的方法都会调用辈分最小的类的啊
作者: 卜弦    时间: 2013-10-29 19:26
  1. /*
  2. 查阅API你会发现，Thread类是继承了Runnable接口的：public class Thread implements Runnable
  3. 我们都知道接口中的都是抽象方法，如果类继承了某一个接口，那么该类中的同名函数一定会重写该接口中的方法。

  5. 首先你的程序使用的匿名内部类来书写的，不便于观看。其等价为下面的程序：
  6. */
  7. class runnable implements Runnable
  8. {       
  9.         public void run()
  10.                 {
  11.                         System.out.println("B");
  12.                 }       
  13. }
  14. public class ThreadDemo {

  16.         public static void main(String[] args) {

  18.                         runnable r = new runnable();
  19.                         Thread t = new Thread(r)
  20.                                 {
  21.                                         public void run()
  22.                                         {
  23.                                           System.out.println("A");
  24.                                         }
  25.                                 };               
  26.             t.start();
  27.         }

  29. }
  30. /*
  31. 该程序里出现了两次重写。
  32. 第一次：定义一个新的类继承了Runnable接口，这时用
  33.                 public void run()
  34.                 {
  35.                         System.out.println("B");
  36.                 }
  37.         覆盖了Runnable接口中的run()方法。此时Runnable接口中的run输出的是“B”。
  38. 第二次：建了一个新的线程实体，并指定线程目标为实现了Runnable接口的runnable类的实例r：new Thread(r)，
  39. 由于Thread类实现了Runnable接口，所以新的Thread类实体中的run()方法必然要再一次覆盖Runnable接口中的run().
  40. 此时输出“B”的run方法被覆盖。所以输出“A”。

  42. */
复制代码
作者: 阿里策    时间: 2013-10-29 19:43
本帖最后由 阿里策 于 2013-10-29 19:45 编辑

    这个我也很疑惑，但是我查找API时，发现Thread类是Runnable接口的子类，其run方法也是实现了Runnable的run方法。所以是不是这样：楼主的new Thread（Runnable r）的参数是一个实现了Runnable接口的匿名内部类，实现了Runnable接口的run方法。而紧接着楼主又创造了一个继承Thread类的匿名内部类，复写了Thread的run方法。这样以来，是不是后一个匿名内部类的run方法，覆盖了前一个匿名内部类的run方法呢？？？
    这个只是我的猜想，不知道对不对
作者: 雨过丶天已晴    时间: 2013-10-29 20:24
先分析一下你的这段代码，其实就是new Thread(new Runnable(){}){}
用通俗一点表示就是创建两个类，一个实现Runnable类，一个继承Thread,然后将Runnable的实现类的匿名对象
以参数传递给Thread的子类对象，然后开启线程，因此可以改写代码：
  1. class A implements Runnable{

  3. @Override
  4. public void run() {
  5. System.out.println("A");
  6. }
  7. }

  9. class B extends Thread{
  10. public B(Runnable target) {
  11. super(target);
  12. }

  14. public void run(){
  15. System.out.println("B");
  16. }
  17. }
  18. public class Demo03_StartThread {
  19. public static void main(String[] args) {
  20. A a = new A();
  21. Thread t = new B(a);
  22. t.start();
  23. }
复制代码
因此，答案就出来了，这就是多态的问题，所以打印的是B
没听课，不知道对不对，大家多多指教


作者: 黄炳期    时间: 2013-10-29 20:30
new Runnable(){}是以参数的形式传递给Thread对象的，既然new Thread(){run()}有run方法，而且也实现了Runnable接口，他就自己运行了，不论有没有传递new Runnable(){}，他都会打印A，除非不在new Thread(){}重写run方法~

如果问题已经解决请及时修改主题为“提问结束”

作者: wenbaoxing    时间: 2013-10-30 00:35
本帖最后由 wenbaoxing 于 2013-10-30 00:37 编辑

这是我的想法，分享交流一下


  3. class Demo03_StartThread {

  5.         public static void main(String[] args) {
  6.                                                
  7.                         // 这个是定义了一个Thread类的匿名子类对象, 重写run()方法, 又调用了父类的含有一个参数的构造方法，子类会覆盖父类的run方法（自己想的不知道对不对）
  8.                         new Thread(new Runnable() {
  9.                                         public void run() {
  10.                                                         System.out.println("B");
  11.                                         }
  12.                                 }) {
  13.                                                 public void run() {
  14.                                                         System.out.println("A");                                                       
  15.                                                 }
  16.                         }.start();

  18.                         /*
  19. 创建线程的第一种方式：继承Thread ，由子类复写run方法。
  20. 步骤：
  21. 1，定义类继承Thread类；
  22. 2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；
  23. 3，通过创建Thread类的子类对象，创建线程对象；
  24. 4，调用线程的start方法，开启线程，并执行run方法。
  25.                         */
  26.                         //这个是通过上面的方法创建线程，这种方法因为继承了Thread类，所以自己有了start方法
  27.                         new A().start();

  29.                         //这个其实也是上面的方法，只不过是Thread的匿名子类，所以也有了start方法
  30.                         new Thread(){
  31.                                 public void run()
  32.                                 {
  33.                                         System.out.println("hello");
  34.                                
  35.                                 }
  36.                         }.start();

  38.                         /*
  39. 创建线程的第二种方式：实现一个接口Runnable。
  40. 步骤：
  41. 1，定义类实现Runnable接口。
  42. 2，覆盖接口中的run方法（用于封装线程要运行的代码）。
  43. 3，通过Thread类创建线程对象；
  44. 4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
  45. 为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
  46. 5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。
  47.                         */
  48.                         //通过以上方法创建线程，这种方法为什么一定要放在Thread类中呢？因为A只是实现了Runnable接口，里面没有start方法
  49.                         new Thread (new B()).start();

  51.                         //new B().start();        这样就不行，因为没有start方法

  53.                        
  54.         }

  56. }

  58. class A extends Thread
  59. {
  60.         public void run()
  61.         {
  62.                 System.out.println("A");
  63.         }
  64. }

  66. class B implements Runnable
  67. {
  68.         public void run()
  69.         {
  70.                 System.out.println("B");
  71.        
  72.         }
  73. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2