Was ist der bevorzugte Weg, Rückrufe zu organisieren? [geschlossen]

Question

In meinem Android-Projekt definiere ich ein paar Rückrufe auf die Schaltfläche klickt, Konnektivität Ereignisse oder UI-Ereignisse zu bedienen wie Dilaog.onShow (). Für Demozwecke habe ich eine Runnable Schnittstelle ausgewählt, die von einem Aktivitätscode gestartet werden muss. Mit Java habe ich verschiedene Möglichkeiten, um mich auszudrücken.

würde ein Muster seiner anonyme Klasse zu verwenden,

runOnUiThread(new Runnable() { 
    public void run() { 
        doSomething(); 
    }
});

private void doSomething() {
}

eine andere - eine interne private Klasse zu definieren, das heißt

private DoSomething implements Runnable {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(new DoSomething());

noch eine andere - ein eigenes Element zu verwenden, wie folgt aus:

private final Runnable doSomething = new Runnable() {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(doSomething);

Hier ist eine andere, die ich am besten gefällt, denn einerseits ist es nicht eigentlich Objekte konstruieren, es sei denn jemand wirklich verwendet, weil es zusätzliche Klassen vermeidet, weil es Parameter übernehmen können, wenn nötig.

private Runnable doSomething() { 
    return new Runnable() {
        public void run() { 
            // do something; 
        }
    }
}
...
runOnUiThread(doSomething());

Ich bin nicht auf der Suche für die Argumente des Geschmacks oder religiösen Glaubens, sondern der Code Wartbarkeit und Performance. Ich mag Hinweise und Ratschläge erhalten, die ich meine eigenen Vorlieben entwickeln könnte helfen, möglicherweise -. Unterschiedliche Präferenzen nach den gegebenen Umständen

Spoiler:

Fortschritt von Java hat sich diese Frage obsolet, die akzeptierte Antwort sehen.

Answer 1

Heute, wo Java 8 fast für Android verfügbar ist, und Android Studio automagically gibt vor, dass Lambda-Ausdrücke sind bereits die anonyme Klasse unterstützt (# 1) Lösung scheint die offensichtliche Wahl zu sein:

Answer 2

Ich glaube nicht, es gibt jeden idiomatischen Weg zum Griff Rückrufen.

ich in der Regel eine anonyme Klasse Inline zuerst. Wenn das Verfahren zu groß wird, extrahiere ich die Klasse Schöpfung in eine separate Funktion. Wenn die Klasse zu groß wird, ich eine eigene Datei extrahieren.

Wenn Sie eine IDE wie Eclipse verwenden, können Sie alle diese Refactorings automatisch und sicher durchführen.

Answer 3

Wie @Manuel Silva und @Toby Meister, mag ich anonyme innere Klassen. Sie sind etwas schwer zu lesen, sind nicht sehr „OO“, dass sie nicht verlängert werden können, kann nicht DIP, Einrichter hat oder was auch immer Verhalten zu optimieren, etc ..., und sie am Ende oft das DRY-Prinzip zu verletzen wenn Sie den gleichen Code in 27 verschiedenen Orten hinzufügen.

neige ich dazu, private Mitglieder (Ihre Option # 3) oder eine private Funktion (Ihr 4. Stil) in der Regel genannt getAsRunnable () zu verwenden.

Answer 4

Ich bin sehr neu für Android, aber anonyme Klassen machen mir übel und es scheint, dass Sie eine Alternative zu runOnUiThread haben sowieso: AsyncTask, die hier beschrieben: runOnUIThread Frage

Answer 5

Aus meiner Sicht anonyme Klasse verringert wirklich die Lesbarkeit. Da Ui Code oft sehr ausführlich ist, das Hinzufügen anonyme Rückrufe für jede Taste kann sehr sehr große Klassen führen. Als Folge bin ich mit internen privaten Klassen.