1. import java.io.*;
   
2. public class Demo extends Thread {
   
3.         public void run() throws Exception {
   
4.                 for(int x=0; x<5; x++) {
   
5.                         
   
6.                                 Thread.sleep(2000);  //不抛异常提示这方法需要抛出InterruptedException; 于是我抛出了它的父类Exception,结果错误是这样 ：Demo 中的 run() 无法实现 java.lang.Runnable 中的 run()；被覆盖的方法不抛出 java.lang.Exception
   
7. 我没有实现Runnable接口！
   
8. 这个异常只能处理不能抛出？
   
9.                                 System.out.println(x);
   
10.                 }
    
11.         }
    
12.         
    
13.         public static void main(String[] args) throws Exception {
    
14.                 Demo d = new Demo();
    
15.                 d.run();
    
16.         }
    
17. }
    
18. 
    
19. 
    
20. 答案：只能处理了
    
21.     可和Runnable接口有一毛钱的关系？
    

复制代码

public void run()  {

            for(int x=0; x<5; x++) {

              try
              {
                                Thread.sleep(2000);  
              }
              catch (Exception  e)  {   }
InterruptedException;当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常。
就是说Sleep如果直接执行会出这个异常，要你对他声明或处理一下,你可以不做具体处理办法，只要Try 然后catch抓一下就好

public class Demo extends Thread {

       public void run() {

                for(int x=0; x<5; x++) {
                        
                   try{Thread.sleep(2000);}catch(Exception e){}/*InterruptedException线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常。
Sleep直接执行会出这个异常，对他声明或处理一下;*/
                                                                                                                                
                                                                  
                               System.out.println(x);

                }

        }

       public static void main(String[] args) throws Exception {

               Demo d = new Demo();

                d.start();
                //d.run()直接调用run方法
        }

}

实现多线程方式有两种：继承Thread，或定义一个实现Runnable的类。

两种情况都需要重写在run方法中运行的线程代码。Run方法的声明如下：
public void run(){ }

从函数声明中可以看到，不能从一个独立线程中抛出任何可检测异常，您必须在run方法内部处理它们。
优点是：线程将从不会向应用程序的其他部分抛出可检测异常，可以确保异常不关闭当前正在运行的线程。缺点是：您必须在代码中处理更大的异常集。

楼主的run方法已经抛异常了，这样写是不正确的。

1. import java.io.*;
   
2. public class Demo extends Thread {
   
3.         public void run(){                // 这里不能写异常检测代码，需要在run方法中try
   
4.                 try{
   
5.                         for(int x=0; x<5; x++) {
   
6.                                 Thread.sleep(2000);
   
7.                                 System.out.println(x);
   
8.                         }
   
9.                 }
   
10.                 catch(Exception e)
    
11.                 {
    
12.                         // 处理异常
    
13.                 }
    
14.         }
    
15.         
    
16.         public static void main(String[] args) throws Exception {
    
17.                 Demo d = new Demo();
    
18.                 d.start();        // 这里是start不是run，否则不能实现多线程效果
    
19.         }
    
20. }

复制代码

老毕的视频中有特别说明过：
1.在子类覆盖父类的时候，子类抛出的异常必须是和父类异常一致，或者是父类异常的子类。
2.如果父类或者接口没有异常抛出，子类覆盖父类时出新异常，只能try不能throws。
在Thread类中的run()方法是没有申明抛出异常的，所以继承Thread类，只能自己处理异常，不可以抛出来。
（java友情提醒，我们不是各种“优秀”的二代，所以要自立自强，自力更生，有问题自己处理~）
子类继承父类是为了更优化的性能，所以不能产生比父类更多的问题吧~！

当子类重写父类的方法或实现某个接口中的方法时，必须抛出与父类或实现接口里方法抛出的异常相同，否则或出错。public void run();方法是没有申明有抛出异常的。

你后面是run(); 启动的知识普通的run方法  用线程得用start() 。 start()的作用是：启动线程，调用run()方法
我觉得你既然没启动线程 那么也无从说sleep了

另外你抛的异常应该和父类异常一样或者是父类异常的子类

而且你的父类无异常或者实现的接口的话 那么子类异常只能try不能抛

供参考{:soso_e121:}

这个方法如果有异常只能try不能抛，这个涉及到了异常在子父类覆盖中的体现：
1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类。
2、如果父类方法抛出多个异常，那么子类覆盖父类方法时，只能抛出父类的子集。
3、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常，如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。