java: Runnable 和 Thread 接口的关系

Question

我意识到必须声明方法run()，因为它是在Runnable 接口中声明的。但是当这个类运行时我的问题来了，如果没有对特定包的导入调用，Thread 对象是如何被允许的？ runnable 是如何知道 Thread 或其方法的？ Runnable 接口是否扩展了 Thread 类？显然我不太了解接口。提前致谢。

    class PrimeFinder implements Runnable{
         public long target;
         public long prime;
         public boolean finished = false;
         public Thread runner;
         PrimeFinder(long inTarget){
              target = inTarget;
              if(runner == null){
              runner = new Thread(this);
              runner.start()
         }
    }
    public void run(){

    }
}

Answer 1

在这种情况下，我喜欢将接口视为合约。通过说你的类实现了 Runnable，你明确声明你的类遵守 Runnable 契约。这意味着其他代码可以创建您的类的实例并分配给 Runnable 类型：

Runnable r = new PrimeFinder();

此外，通过遵守此合同，您可以保证调用您的类的其他代码可以期望找到 Runnable 实现的方法（在本例中为 run() ）。

Answer 2

不。线程在 lava.lang 包中，所以是隐式导入的。

并且：线程知道 Runnable。

这就是为什么 Thread 接收一个 Runnable（this 实现 Runnable）并在它自己的执行线程中调用它的方法 run()。

线程保持对您实现的 Runnable 的引用：

public Thread(Runnable runnable) {
   this.myRunnable = runnable;
}

private Runnable myRunnable;

Thread 类的 start 方法如下所示：

public void start() {
  // do weird stuff to create my own execution and...
  myRunnable.run();
}

Answer 3

是的，Thread 实现了Runnable。

正如 API 引用所述，可运行接口旨在为希望在活动时执行代码的对象提供通用协议。

您会感到困惑，因为在 Java 中有两种方法可以实现这种并发：

• 你可以扩展一个Thread类覆盖默认的run方法，然后以类似于new MyThread().start()的方式调用线程
• 你可以编写一个实现Runnable接口的类并以类似的方式启动它：new Thread(new MyRunnable()).start()

这些方法相同。事实上，Thread 类的run 方法通常调用附加到线程的Runnable 对象的run 方法，如果有，则返回。

拥有Runnable 接口有什么需要？它很有用，因为它声明了一个让类被视为具有特定特征的协议。

这与Comparable 接口或Serializable 接口相同，但在这里你实际上有一个方法可以覆盖（public void run()），而例如Serializable 只是你赋予你的类的一个特征。

最后一个例子是TimerTask 实现了Runnable。 TimerTask 与 Timer 类一起用于执行延迟或周期性任务，因此 timertask 也可以运行是有意义的，因此 Timer 可以使用该方法启动任务。

编辑：因为您似乎对接口的有用性感到困惑，所以您必须认为：Java 是一种静态类型语言。这是什么意思？这意味着它需要在编译期间了解有关类型的所有信息，才能保证不会抛出运行时类型错误。

好的，现在假设 Java API 支持一个 hipotetically 类来绘制形状。因此，您可以为形状编写自己的类，然后将它们提供给这个类（我们称之为ShapeDrawer）。

ShapeDrawer 需要知道如何绘制您传递给它的形状，唯一的方法是确定每个Shape 对象必须有一个名为@987654344 的方法@，以便ShapeDrawer 可以在您附加到它的每个Shape 上调用此方法，而无需了解更多信息。

所以你声明一个接口

public interface Shape
{
  public void drawMe();
}

这些类可以被视为Shape。如果一个类是Shape，您可以毫无问题地将它传递给您的ShapeDrawer 类：

class ShapeDrawer
{
  public void addShape(Shape shape) { ... }
  public void drawShapes()
  {
    for (Shape s : shapes)
      s.drawMe();
  }
}

所以编译器很高兴，因为在添加形状时，您添加了 implements Shape 的类，您的类确切地知道如何绘制这些形状，并且开发人员很高兴，因为您将对象的 通用协议 与他们的具体实现。

这是一种契约，如果你想要一个能够被ShapeManager 绘制的Triangle 类，你必须声明该方法，以便你可以调用例如

shapeDrawerInstance.addShape(new Triangle())

Answer 4

这与接口无关。相反，Thread 位于 java.lang 包中，并且由于 java.lang 是默认包，因此您无需导入它。即默认导入java.lang.*，不需要自己显式导入。

Answer 5

类 Thread 实现 Runnable。 Runnable 对 Thread 一无所知，但 Thread 对 Runnable 无所不知。

其他使用 Thread 的类都知道 Thread 实现了 Runnable 中指定的接口。

Answer 6

您编写的代码无法编译。你声明了PrimeFinder implements Runnable，但它实际上并没有@Override public void run()。

至于接口为何有用，是因为它们定义了您可以使用的类型，而不管实现如何。例如，如果您使用Closeable，您知道您可以使用close()。实际的类可能是实现它的众多类中的任何一个 (see full list)，但使用接口可以让您退后一步，只是说它们都是 Closeable。

使用接口，您不会继承实现；你继承了一个TYPE。如果有另一个代码适用于Closeable 类型（例如，它所做的只是在它们上调用close() 并进行异常检查），那么您可以将任何implements Closeable 传递给它。事实上，这个“请帮我关闭这个东西，好的，谢谢”的实用方法已经存在，而且它非常灵活，并且由于它与界面一起工作，因此具有高度的可重用性。

通过使用接口而不是特定的实现类，您可以更清晰地封装您的逻辑。例如，使用Set 接口的算法并不关心它实际上是TreeSet 还是HashSet。这种不依赖是一件好事，因为它允许算法非常灵活——例如，它还可以在将来使用SuperMagicalSet implements Set。

使用接口还可以确保正确封装，因为不知道实际的实现类是什么，您必须只使用接口提供的内容。

我推荐阅读 Josh Bloch 的Effective Java 2nd Edition：

• 第 18 条：优先选择接口而不是抽象类
• 第 19 条：使用接口定义类型