Scenario of extending Thread class and implementing Runnable interface [duplicate]

extending Thread and implementing Runnable is useless (Thread already implements Runnable). You pretty much always want to implement Runnable (and not extend Thread). That gives you the flexibility of using a Thread directly (not recommended) or using one of the newer ThreadPool implementations in java.util.concurrent (recommended).

No, There is no advantage of using this approach, because, Thread class implements Runnable interface. So, if your class extends Thread class. It means, it's also implementing Runnable interface.

IN this specific situation it's not very useful, as other posters have explained it's fairly obvious that Thread already implements Runnable.

In some cases, "stating the obvious" can be useful though, just as a "reminder" to the user of your class: if you have a fairly large hierarchy of super-classes and interfaces, with several levels of inheritance (some of them in 3rd-party libraries), it could be useful as a helper to declare a class as implementing a specific interface, even though it implements it by definition because its superclass already implements it or implements one of the sub-class of that interface.

It's specially useful with marker interfaces (some people might object they should not be used at all, and they are bad practices - well sometimes you don't control the environment fully), i.e. interfaces with no actual implementation and just designed to mark your object eligible for a special function (e.g. Cloneable). In such a case, marking each of the allowed classes even though their parents are already eligible can be more explicit, so more useful.