看毕老师的视频发现，毕老师在创建纯种的时候都是用的实现Runnable的方法而非继承Thread方法。
是因为Runnable比Thread有优势？还是属于毕老师的个人用法习惯？
这2种方法的区别在哪里？

实现Runnable接口相对于继承Thread类来说，有几个优势：
1.适合多个相同程序代码的线程去处理同一资源的情况，较好的体现了面向对象的设计思想。
2.可以避免Java的单继承特性带来的局限性。如在开发中经常会碰到这样一种情况，即要将已经继承的某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能使用继承Thread类的方式，那么就只能采用Runnable接口的方式。
3.增强了程序的健壮性，代码能够被多个线程所共享，代码与数据是独立的。
在开发中，几乎所有的多线程应用都可以使用实现Runnable的方式。

这是我以前的总结，希望对你有帮助！
实现方式和继承方式的区别
实现方式好处：避免单继承的局限性；
JDK API中如是描述，Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。
区别：
继承Thread；线程代码存放在thread子类run方法中；
实现runnable，线程代码存放在接口子类的run方法。
总结：
创建线程的第一种方式：继承Thread类
优点：代码相对简单，访问当前线程即可以使用this，也可以使用Thread.currentThread()方法；
缺点：java只支持单继承，所以继承了Thread，就不能继承其他的父类，有一定的局限性。
创建线程的第二种方式：实现Runnable接口
优点：线程采用实现Runnable接口的方式，还可以继承其他类，因而多个线程可以共享一个对象资源；
缺点：代码相对复杂，访问当前线程只能使用Thread.currentThread()方法。

Runnable接口必须编写run方法来覆盖接口中的run方法，并只有一个run方法。用实现Runnable接口的类创建的对象只是带有线程体的目标对象，并不是真正的线程，由于有具体的线程体，可以直接调用Thread构造相应的线程。
毕老师的两个卖票程序可以说明。
继承Thread类的，我们相当于拿出四件事即四个卖票20张的任务分别分给四个窗口，他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建四个对象的同时创建了四个线程；
实现Runnable的， 相当于是拿出一个卖票20张得任务给四个人去共同完成，new MyThread相当于创建一个任务，然后实例化四个Thread，创建四个线程即安排四个窗口去执行。
代码如下;

1. //class MyThread implements Runnable
   
2. class MyThread extends Thread
   
3.         {  
   
4.                 private int ticket =20;
   
5.                 public void run()
   
6.                         {  
   
7.                for(int i =0;i<500;i++)
   
8.                        {  
   
9.                                if(this.ticket>0)
   
10.                                        {  
    
11.                                                System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));  
    
12.                                        }  
    
13.                             }  
    
14.              }  
    
15. }  
    
16. public class test
    
17. {  
    
18.         public static void main(String[] args)
    
19.                 {
    
20.                   /*MyThread thread = new MyThread();
    
21.           Thread t1 = new Thread(thread);  
    
22.           Thread t2 = new Thread(thread);  
    
23.           Thread t3 = new Thread(thread);  
    
24.           Thread t4 = new Thread(thread);
    
25.           */
    
26.                   MyThread t1 = new MyThread();
    
27.                   MyThread t2 = new MyThread();
    
28.                   MyThread t3 = new MyThread();
    
29.                   MyThread t4 = new MyThread();
    
30.           t1.start();  
    
31.           t2.start();  
    
32.           t3.start();  
    
33.           t4.start();
    
34.         }  
    
35. }  
    

复制代码

1. 实现Runnable接口相对于继承Thread类来说，有几个优势：
   
2. 1.适合多个相同程序代码的线程去处理同一资源的情况，较好的体现了面向对象的设计思想。
   
3. 2.可以避免Java的单继承特性带来的局限性。如在开发中经常会碰到这样一种情况，即要将已经继承的某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能使用继承Thread类的方式，那么就只能采用Runnable接口的方式。
   
4. 3.增强了程序的健壮性，代码能够被多个线程所共享，代码与数据是独立的。
   
5. 在开发中，几乎所有的多线程应用都可以使用实现Runnable的方式。

复制代码

它是这样的定义的：public class Thread estends Object implements Runable
从定义可以看出，Thread 类也是Runable接口的子类，但在Thread类中并没有完全的实现Runable接口中的run方法。
在Thread类中德run方法调用的是Runable接口中德run方法，也就是说此方法是有Runable子类完成的，所以如果要通过Thread类实现多线程，则必须腹写run方法。如果一个类继承Thread类，则不适合于多个线程共享资源，而实现了Runable接口，就可以方便地实现资源的共享。
Runable接口相对于继承Thread类来说，有如下优势：
1、适合多个相同程序代码的线程去处理同一资源的情况。
2、可以避免有java的单继承特性带来的局限
3、增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

有不小的收获，交流万岁:D

这两种创建类的方法时有不同的，不是毕老师的习惯问题。首先继承Thread创建的方法是继承Thread类，并复写run方法，然后创建对象，用start方法启动线程并调用run方法。但是Runnable方法时实现Runnable类并复写run方法，然后在主函数中创建Thread对象并把Runnable的子类对象作为参数传到Thread的构造函数中，让Thread对象调用start方法启动线程调用Runnable子类对象中的run方法。由此可以看出实现的方式避免了单继承的局限性，建议使用实现的方式。并且区别还有Thread的线程存放在Thread的run方法中，而实现方式的线程存放在Runnable的子类run方法中。

定义线程的方法   1.继承Thread类，重写run方法。创建继承Thread的类对象，就是创建一个线程。 调用start方法，就是启动线程并调用run方法。 代码如下：   class Demo extends Thread {         public void run()         {                 for(int x=0;x<60;x++)                 System.out.println("run Demo"+"........"+x);         } } public class ThreadDemo {         public static void main(String[] args)         {                 Demo d=new Demo();//创建线程                 d.start();//启动线程并调用run方法                 for(int x=0;x<60;x++)                 {                         System.out.println("hello world"+"......."+x);                 }         }  }  步骤：  1.定义类继承Thread。  2.复写Thread类中的run方法。   目的：将自定义代码存储在run方法中，让线程运行。Thread类中的run方法，          用于存储，线程要运行的代码。    3.调用线程的start方法   该方法两个作用：启动线程，调用run方法。 实现Runnable接口，复写run方法 代码如下：售票的例子 class Ticket implements Runnable {         private  int tick=100;//static 静态的   存储在方法区  是共享数据         public void run()         {                                  while(true)                 {                         if(tick>0)                         {                                 System.out.println(Thread.currentThread().getName()+"sale:"+tick--);                         }                 }                                  } } public class TicketDemo {         public static void main(String[] args)         {                 Ticket t=new Ticket();                 Thread t1=new Thread(t);                 Thread t2=new Thread(t);                 Thread t3=new Thread(t);                 Thread t4=new Thread(t);                 t1.start();                 t2.start();                 t3.start();                 t4.start();                          }  }  步骤：  1.定义类实现Runnable接口  2.覆盖Runnable接口中的run方法。   将线程要运行的代码存放在该run方法中。  3.通过Thread类建立线程对象。  4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。         为什么要将Runnable接口的子类对象传递给Thread的构造函数。         因为，自定义的run方法所属的对象是Runnable接口的子类对象。         所以要让线程去执行指定对象的run方法。就必须明确该run方法所属对象。  5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。  实现方式和继承方式有什么区别呢？ 实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。 两种方式区别： 继承Thread:线程代码存放Thread子类run方法中。 实现Runnable，线程代码存在接口的子类的run方法。这是我的学习笔记 你可以借鉴一下