Quelle est la meilleure façon d'organiser callbacks? [fermé]

Question

Dans mon projet Android, je définir quelques callbacks de fonctionner sur les clics des boutons, des événements de connectivité ou d'événements tels que l'interface utilisateur Dilaog.onShow (). Pour démonstration fins, j'ai choisi une interface Runnable qui doit être lancé à partir du code d'activité. Avec Java, j'ai différentes façons de me exprimer.

Un modèle serait d'utiliser la classe anonyme

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

private void doSomething() {
}

autre - pour définir une classe interne privée, à savoir

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

autre - d'utiliser un parlementaire, comme ceci:

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

Voici une autre, ce qui me plaît le plus, parce que d'une part, il ne construit pas en fait des objets à moins que quelqu'un utilise vraiment, car elle évite les classes supplémentaires, car il peut prendre des paramètres en cas de besoin.

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

Je ne cherche pas les arguments du goût ou de croyance religieuse, mais le code maintenabilité et la performance. Je souhaite recevoir des conseils et des conseils qui pourraient aider à me développer ma propre préférence, peut-être -. Différentes préférences en fonction des circonstances données

Spoiler:

Les progrès de Java a rendu obsolète cette question, voir la réponse acceptée.

Answer 1

Aujourd'hui, alors que Java 8 est presque disponible pour Android et Android studio automagiquement prétend que lambdas sont déjà pris en charge, la solution classe anonyme (# 1) semble être le choix évident:

Answer 2

Je ne crois pas qu'il y ait aucune façon idiomatiques à callbacks poignée.

J'inline généralement une classe anonyme d'abord. Lorsque la méthode est trop grande, j'extrais la création de classe en une fonction distincte. Lorsque la classe est trop grand, j'extrait pour son propre fichier.

Si vous utilisez un IDE comme Eclipse, vous pouvez effectuer toutes ces refactorisations automatiquement et en toute sécurité.

Answer 3

Comme @Manuel Silva et Champion @Toby, je n'aiment pas les classes internes anonymes. Ils sont un peu difficiles à lire, ne sont pas très « OO » en ce sens qu'ils ne peuvent pas être étendues, ne peut pas avoir DIP, setters ou tout Tweak comportement, etc ..., et ils finissent souvent par violer le principe DRY lorsque vous ajoutez le même code dans 27 endroits différents.

J'ai tendance à utiliser des membres privés (votre option n ° 3), ou une fonction privée (votre 4ème style) généralement nommé getAsRunnable ().

Answer 4

Je suis très nouveau pour Android, mais les classes anonymes me font nauséeux et il semble que vous avez une alternative à runOnUiThread de toute façon: AsyncTask, discuté ici: runOnUIThread question

Answer 5

De mon point de vue, classe anonyme diminue vraiment la lisibilité. Parce que le code Ui est souvent très bavard, en ajoutant des callbacks anonymes pour chaque bouton peut conduire à des classes très très grands. En conséquence, je me sers des cours privés internes.