In een eenvoudig te begrijpen uitleg, wat is Runnable in Java?

Wat is “uitvoerbaar” in Java, in termen van leken? Ik ben een AP-programmeerstudent op de middelbare school, wiens opdracht het is om onderzoek te doen, of van anderen op te zoeken wat “uitvoerbaar” is (we beginnen net met OOP en hebben nog geen threads aangeraakt).

Antwoord 1, autoriteit 100%

Een Runnable is in feite een type klasse (Runnable is een interface) die in een thread kan worden geplaatst en beschrijft wat de thread zou moeten doen.

De Uitvoerbare interfacevereist dat de klasse de methode implementeert run()zoals zo:

public class MyRunnableTask implements Runnable {
     public void run() {
         // do stuff here
     }
}

En gebruik het dan als volgt:

Thread t = new Thread(new MyRunnableTask());
t.start();

Als je de interface Runnableniet had, zou de klasse Thread, die verantwoordelijk is voor het uitvoeren van je spullen in de andere thread, niet de belofte hebben om een ​​run()-methode in uw klasse, zodat u fouten kunt krijgen. Daarom moet je de interface implementeren.

Geavanceerd: Anoniem type

Houd er rekening mee dat je niet zoals gewoonlijk een klas hoeft te definiëren, je kunt dat allemaal inline doen:

Thread t = new Thread(new Runnable() {
    public void run() {
        // stuff here
    }
});
t.start();

Dit is vergelijkbaar met het bovenstaande, alleen maak je geen andere benoemde klas aan.

Antwoord 2, autoriteit 5%

Runnableis een interface die als volgt is gedefinieerd:

interface Runnable {
    public void run();
}

Om een ​​klasse te maken die deze gebruikt, definieert u de klasse als (public) class MyRunnable implements Runnable {

Het kan worden gebruikt zonder zelfs maar een nieuwe thread te maken. Het is eigenlijk je basisinterface met een enkele methode, run, die kan worden aangeroepen.

Als je een nieuwe thread maakt met runnable als parameter, wordt de run-methode in een nieuwe thread aangeroepen.

Er moet ook worden opgemerkt dat Threads Runnableimplementeren, en dat wordt aangeroepen wanneer de nieuwe thread wordt gemaakt (in de nieuwe thread). De standaardimplementatie roept gewoon de Runnable aan die je de constructor hebt ingeleverd, daarom kun je gewoon new Thread(someRunnable)doen zonder de run-methode van Thread te negeren.