Почему абстрактное свойство теряется в подклассе интерфейса Runnable?

Question

Я действительно изучаю темы. Но застрял с очень простой проблемой. Я знаю, что если я наследую интерфейс в своем классе, я должен дать определения всех методов (упомянутых в этом интерфейсе) в моем унаследованном классе, иначе он должен быть объявлен как абстрактный. Теперь я попытался очень простой код ...

import java.util.*; 
import java.lang.*; 
import java.io.*; 


abstract class Code implements Runnable 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 

    } 
} 

не было никаких проблем при компиляции, а затем я удалил abstract ключевое слово из кода класса и показывал мне ошибку компиляции, говоря класс код не является абстрактным. ..

Должна быть ошибка. Но потом я сделал то, что, проверяя некоторые варианты, расширил класс Thread также из класса и перекомпилировал код. И у меня нет ошибки компиляции! Хотя я не дал определения метода run(), ни один из них не упоминал мой класс как абстрактный. там ...

class Code extends Thread implements Runnable 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 

    } 
} 

означает, что этот класс потерял абстрактное свойство. Как это было возможно? Кто-нибудь объяснит, пожалуйста.

Answer 1

Ну, вы знаете Runnable интерфейса, имеющий только один абстрактный метод. то есть,

abstract public void run(); 

Если вы реализуете Runnable вы должны обеспечить определение метода Run() в собственном конкретном классе или вы можете сделать свой класс абстрактным. Теперь вы можете предоставить определение метода run() в своем классе явно или неявно путем наследования любого другого класса, имеющего корректное определение метода run(). Класс Thread также имеет правильное определение метода run(). Итак, если вы наследуете как класс Thread, так и Runnable-интерфейс в своем классе, этот класс больше не несет абстрактного свойства. Именно поэтому вы не получили ошибку компиляции. Удостоверьтесь в спецификаторе доступа метода run(). Если вы наследование любого другого класса вместо Thread вы должны предоставить там конкретный пробег() метод как,

public void run() 
{ 
    //body 
} 

Answer 2

Абстрактному классу не нужно реализовывать все методы из интерфейса. При удалении «абстрактных» исполняемый класс имеет реализовать метод Run

@Override 
public void run() { 
    // TODO Auto-generated method stub 

} 

Answer 3

Runnable интерфейс, который требует какого-либо класса, который реализует его реализовать run() методы

public class A implements Runnable { 
    public void run() { 
     // implementation of run 
    } 
} 

Thread - это конкретный класс, который реализует интерфейс Runnable. Это означает, что он конкретно реализовал метод run().

public class Thread implements Runnable { 
    public void run() { 
     // Java's implementation of run 
     // for the Thread class 
    } 
} 

Когда вы определяете класс, который расширяет Thread это означает, что она будет расширить Thread класс, который уже реализован все необходимое для интерфейса Runnable. Поэтому вам не нужно применять метод run(). Однако вы можете использовать override реализацию от Thread и, при необходимости, позвонить ему, если вам нужно.

class A extends Thread { 
    @Override 
    public void run() { 
     // implementation of run 
     // optionally call super.run(); 
    } 
} 

Answer 4

java.lang.Thread уже реализует интерфейс Runnable и определяет run метод. Поэтому, когда вы расширяете Thread, у вас уже есть все, что требуется для реализации Runnable.Вы можете, если хотите, переопределить метод run с вашим собственным определением. Но вам не нужно, если бы его реализация соответствовала вашим потребностям.

Answer 5

Как уже указывалось, Runnable - это интерфейс, содержащий только один метод, run(), аннотация, как вы указали. Если бы реализовать интерфейс:

class A implements Runnable { 
    ... 
} 

Компилятор жалуется: Class A must be either declared abstract or implement abstract method 'run()' in 'Runnable', так как указано в сообщении об ошибке вы можете выбрать для реализации метода:

class A implements Runnable { 
    public void run() { 
    ... 
    } 
} 

или сделать класс Аннотация:

abstract class A implements Runnable { 
} 

любое решение удовлетворило бы компилятор. Другим решением было бы сделать A интерфейс, а также:

interface A extends Runnable { 
} 

Все зависит от того, что вы хотели бы достичь. Для более поздних предоставленных решений было бы полезно, если бы вы хотели расширить существующую иерархию, но вы не хотите, чтобы какое-либо состояние находилось в A.

Answer 6

Runnable - это интерфейс с нижеследующей декларацией.

public 
interface Runnable { 
    /** 
    * When an object implementing interface <code>Runnable</code> is used 
    * to create a thread, starting the thread causes the object's 
    * <code>run</code> method to be called in that separately executing 
    * thread. 
    * <p> 
    * The general contract of the method <code>run</code> is that it may 
    * take any action whatsoever. 
    * 
    * @see  java.lang.Thread#run() 
    */ 
    public abstract void run(); 
} 

Когда вы заявляете, что ваш класс с implements Runnable classue, либо вы должны реализовать метод Run() или объявить класс как абстрактный

Когда класс расширяет Thread с ниже заявлением

class Code extends Thread 

Класс Thread уже реализован run() метод a d поэтому вы не получаете ошибку компиляции. Вы можете удалить implements Runnable из инструкции ниже, что является избыточным.

class Code extends Thread implements Runnable 

Посмотрите Thread исходный код:

public 
class Thread implements Runnable { 

public Thread(Runnable target) { 
    init(null, target, "Thread-" + nextThreadNum(), 0); 
} 

public void run() { 
    if (target != null) { 
     target.run(); 
    } 
}