Differences between the two ways of creating a Thread instance? [duplicate]

This question already has an answer here:

• “implements Runnable” vs. “extends Thread” 39 answers

From http://ift.tt/2chDr9v

There are two ways to create a new thread of execution.

One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started. For example, a thread that computes primes larger than a stated value could be written as follows:

 class PrimeThread extends Thread {
     long minPrime;
     PrimeThread(long minPrime) {
         this.minPrime = minPrime;
     }

     public void run() {
         // compute primes larger than minPrime
          . . .
     }
 }   The following code would then create a thread and start it running:

 PrimeThread p = new PrimeThread(143);
 p.start();

The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started. The same example in this other style looks like the following:

 class PrimeRun implements Runnable {
     long minPrime;
     PrimeRun(long minPrime) {
         this.minPrime = minPrime;
     }

     public void run() {
         // compute primes larger than minPrime
          . . .
     }
 }   

The following code would then create a thread and start it running:

 PrimeRun p = new PrimeRun(143);
 new Thread(p).start();

• Is it correct that the thread instances created by the two ways don't have exactly the same type? The first way creates an instance of a subclass of Thread, while the second way creates directly an instance of Thread.

• Is there some design pattern involved in the second way of creating a thread? Or what kind of design principle is involved? I haven't seen this kind of object creation way before, and don't know when to use this way to create objects.

Thanks.