Java Équivalent à C#Délégués/Événements: la Modification de l'Événement Invoqué Dynamiquement le Code

J'ai un simple Screen classe en C# qui a un tas d'événements (avec le correspondant délégués) comme le FadeOutEvent.

Je veux le port de ma bibliothèque en Java, et je trouve que le mécanisme pour les évènements et les délégués est vraiment cludgey. Plus précisément, je ne peux écrire du code comme:

if (someVar == someVal) {
  this.FadeOutComplete += () => {
    this.ShowScreen(new SomeScreen());
  };
} else {
  this.FadeOutComplete += () => {
    this.ShowScreen(new SomeOtherScreen());
  };
}

Pour tout ce que vous Java-seulement les gars, essentiellement, ce que je suis whinging, c'est l'incapacité à réaffecter la méthode de gestion d'événements dans la classe actuelle de quelque chose d'autre, de façon dynamique, sans créer de nouvelles classes; il semble que, si j'utilise les interfaces, la classe actuelle doit implémenter l'interface, et je ne peux pas changer le code appelé plus tard.

En C#, il est fréquent que vous avez le code qui:

Dans un constructeur /affecter à un certain code de gestionnaire d'événements pour un événement
Plus tard au cours de l'exécution, supprimez-le code entièrement
Souvent, de changer de gestionnaire d'origine à l'autre gestionnaire de code

Modèle de stratégie peut résoudre ce (et le fait), mais que j'ai besoin de plus de classes et d'interfaces pour le faire; en C#, c'est juste un delcarative événement/délégué et je suis fait.

Est-il un moyen de le faire sans intérieure/anonyme classes?

Edit: j'ai juste vu cette SORTE de question, ce qui pourrait aider.

Il suffit de chercher DONC pour [java] strategy pattern et vous trouverez de nombreux de nombreux exemples.
Je l'ai fait. La plupart d'entre eux ont besoin de beaucoup de classes supplémentaires (même anonyme classes), qui vraiment, je n'aime vraiment pas. En tant que développeur C#, c'est trivial et ne nécessite pas de classes. Bien sûr, je peux le faire avec privé/classes internes, mais pourquoi dois-je le faire de cette façon?
Umn comment mettre en place votre événement sans un lambda - qui est fondamentalement la même que celle d'un anonyme intérieur de la classe (en fait à peu près identiques, de ses contraintes et tout et tout) en c#? La plus grande différence en dehors de Javas maladroit de la syntaxe, c'est que vous avez besoin d'une interface pour définir le délégué/l'événement. Et il n'y a pas moyen de contourner cela car les fonctions ne sont pas des objets de première classe en Java.
les lambdas sont équivalentes à une méthode anonyme, pas une classe anonyme. L'interface supplémentaire, en plus de la plomberie pour l'ajout/la suppression des instances de votre événement observateurs, semble très maladroit.
Ouais, et la différence entre une classe anonyme et une méthode à partir d'une mise en œuvre point de vue est.. minimale pour dire le moins. Le C# de la mise en œuvre est fondamentalement juste un déjà mis en œuvre "interface" (que vous faire pour Java assez souvent, ActionListeners, etc.; vous pouvez définir propres événements un peu plus court oui - l'avantage habituel de la première classe de fonctions) et des peaux de la tenue de la comptabilité. Ce qui n'est évidemment pas possible, si vous n'avez pas trouvé un moyen de surcharger les opérateurs en Java. Comme je l'ai dit un peu maladroit, mais bon la chaudière plaque de code est 2 lignes de code, ce n'est pas trop mauvais.

OriginalL'auteur ashes999 | 2011-10-01

c#event-handling java

La plupart du temps, c'est fait dans l'autre sens:

this.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        if (someVar == someVal) {
            showSomeScreen();
        }
        else {
            showSomeOtherScreen();
        }
    }
});

Mais vous pourriez faire quelque chose de similaire à votre code C# en déléguant à deux autres objets:

private Runnable delegate;

//...
this.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        delegate.run();
    }
});

//...
if (someVar == someVal) {
    this.delegate = new Runnable() {
        @Override
        public void run() {
            showSomeScreen();
        }
    };
}
else {
    this.delegate = new Runnable() {
        @Override
        public void run() {
            showSomeOtherScreen();
        }
    };
}

Les délégués ont été proposées par Microsoft pour Java il y a très longtemps, et a été refusé par le Soleil. Je ne me souviens pas si anonyme classes internes existaient déjà à l'époque, ou si elles ont été choisies comme alternative.

+1 c'est la conclusion à laquelle j'en suis venu à trop. Peut-être que nous pouvons faire encore mieux en quelque sorte, mais je crains que ce soit aussi bon qu'il l'obtiendra.
Aussi, mon exemple était un peu superficielle; ce que je reçois à est ajout/suppression/modification de délégués souvent. Qui semble difficile en Java.

OriginalL'auteur JB Nizet

Vous devez vous connecter pour publier un commentaire.