Constructeur dans une interface ?

Question

Je sais qu'il n'est pas possible de définir un constructeur dans une interface. Mais je me demande pourquoi, car je pense que cela pourrait être très utile.

Ainsi, vous pouvez être sûr que certains champs d'une classe sont définis pour chaque implémentation de cette interface.

Considérons par exemple la classe de messages suivante :

public class MyMessage {

   public MyMessage(String receiver) {
      this.receiver = receiver;
   }

   private String receiver;

   public void send() {
      //some implementation for sending the mssage to the receiver
   }
}

Si je définis une interface pour cette classe afin d'avoir d'autres classes qui mettent en œuvre l'interface de message, je ne peux définir que la méthode d'envoi et non le constructeur. Comment puis-je donc m'assurer que chaque implémentation de cette classe possède réellement un ensemble de récepteurs ? Si j'utilise une méthode comme setReceiver(String receiver) Je ne peux pas être sûr que cette méthode soit réellement appelée. Dans le constructeur, je pourrais m'en assurer.

Answer 1

Voici un exemple utilisant ce Technic. Dans cet exemple spécifique, le code fait un appel à Firebase en utilisant un objet fantaisie. MyCompletionListener c'est-à-dire une interface masquée comme une classe abstraite, une interface avec un constructeur

private interface Listener {
    void onComplete(databaseError, databaseReference);
}

public abstract class MyCompletionListener implements Listener{
    String id;
    String name;
    public MyCompletionListener(String id, String name) {
        this.id = id;
        this.name = name;
    }
}

private void removeUserPresenceOnCurrentItem() {
    mFirebase.removeValue(child("some_key"), new MyCompletionListener(UUID.randomUUID().toString(), "removeUserPresenceOnCurrentItem") {
        @Override
        public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {

        }
    });
    }
}

@Override
public void removeValue(DatabaseReference ref, final MyCompletionListener var1) {
    CompletionListener cListener = new CompletionListener() {
                @Override
                public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
                    if (var1 != null){
                        System.out.println("Im back and my id is: " var1.is + " and my name is: " var1.name);
                        var1.onComplete(databaseError, databaseReference);
                    }
                }
            };
    ref.removeValue(cListener);
}

Answer 2

En général, les constructeurs servent à initialiser les membres non statiques d'une classe particulière par rapport à l'objet.

Il n'y a pas de création d'objet pour une interface car il n'y a que des méthodes déclarées mais pas de méthodes définies. La raison pour laquelle nous ne pouvons pas créer d'objet pour les méthodes déclarées est que la création d'objet n'est rien d'autre que l'allocation de mémoire (dans la mémoire du tas) pour les membres non statiques.

La JVM crée de la mémoire pour les membres qui sont entièrement développés et prêts à être utilisés. Sur la base de ces membres, la JVM calcule la quantité de mémoire requise pour eux et crée de la mémoire.

Dans le cas des méthodes déclarées, la JVM n'est pas en mesure de calculer la quantité de mémoire nécessaire à ces méthodes déclarées, car la mise en œuvre se fera dans le futur, ce qui n'est pas encore fait à l'heure actuelle.

conclusion :

sans création d'objet, il n'y a aucune chance d'initialiser les membres non-statiques par le biais d'un constructeur. c'est pourquoi le constructeur n'est pas autorisé à l'intérieur d'une interface (car il n'y a aucune utilisation du constructeur à l'intérieur d'une interface).