Est-il un moyen de garantir une interface étend une classe en Java?

Supposons que j'ai la situation suivante:

public abstract class Vehicle {
  public void turnOn() { ... }
}

public interface Flier {
  public void fly();
}

Est-il un moyen que je peux garantir que toute classe qui implémente Flier doit également s'étendre Vehicle? Je ne veux pas faire Flier une classe abstraite parce que je veux être en mesure de mélanger un peu d'autres interfaces de la même manière.

Par exemple:

//I also want to guarantee any class that implements Car must also implement Vehicle
public interface Car {
  public void honk();
}

//I want the compiler to either give me an error saying
//MySpecialMachine must extend Vehicle, or implicitly make
//it a subclass of Vehicle. Either way, I want it to be
//impossible to implement Car or Flier without also being
//a subclass of Vehicle.
public class MySpecialMachine implements Car, Flier {
  public void honk() { ... }
  public void fly() { ... }
}

Les Interfaces d'étendre les Interfaces. (Abstrait) Classes (partiellement) de mettre en œuvre des Interfaces et de l'étendre à d'autres classes.
Essayez ma suggestion, tu ne peux pas compiler MySpecialMachine sans s'étend de Véhicule!

InformationsquelleAutor math4tots | 2013-01-01

29

Interfaces Java ne peut pas étendre des classes, ce qui est logique étant donné que les classes contiennent des détails de mise en œuvre qui ne peut pas être spécifié dans une interface..

La bonne façon de traiter ce problème est de séparer l'interface de l'application complètement en tournant Vehicle dans une interface. Le Car e.t.c. pouvez étendre la Vehicle interface pour forcer le programmeur à mettre en œuvre les méthodes correspondantes. Si vous souhaitez partager du code entre tous les Vehicle cas, vous pouvez ensuite utiliser (éventuellement abrégé) de la classe en tant que parent de toutes les classes doivent implémenter cette interface.
- si il ne peux pas mettre en œuvre la correspondimg méthodes? si seulement le Véhicule peut mettre en œuvre les méthodes correspondantes? penser.
- Je ne comprends pas ce que vous prenez sur. Il a déjà mis en œuvre les méthodes de Vehicle. Tout ce qu'il faudrait faire le tour Vehicle dans une interface et déplacer les détails d'implémentation d'une classe de base abstraite si nécessaire...
- De la sorte? Soit Vehicle sera transformée en et interface et son code déménagé dans une autre classe de base, ou Vehicle devra mettre en place une nouvelle interface, permet de dire VehicleInterface',qui sera ensuite prolongée par toutes les autres interfaces. Le résultat final est techniquement la même chose...
- L'OP a pas demandé à propos de la bonne façon. L'Op a demandé comment mettre en œuvre une contrainte à s'étend de Véhicule de trop si la classe est volable. Votre chemin automatiquement faire l'inverse que tous les Véhicules doivent être des instances de Flier trop. Eh bien, je prends ma voiture en ce moment et rentrer à la maison ;D
- sur la terre parlez-vous? Comment interface Car extends Vehicle faire tous les Vehicle s'étendent souvent Car ainsi?
- laissez-nous continuer cette discussion dans le chat
- ce n'est PAS toujours possible. Par exemple, si je suis en utilisant un cadre de la troisième partie de la bibliothèque de l'exposer Véhicule et j'ai besoin de créer l'interface de Voiture et je veux faire en sorte de toujours étendre Véhicule je ne peux pas réécrire Véhicule. Exemple concret: RecyclerView.Adapter classe à partir d'Android. Je veux définir une interface pour manipuler le RecyclerView mais je veux aussi que le réalisateur de cette interface pour toujours étendre RecyclerView.Adapter. Je ne pense pas que Java permet de le faire, mais elle le suce.
InformationsquelleAutor thkala
9

Vous pourriez les réorganiser vos classes et interfaces comme ceci:
```
public interface IVehicle {
  public void turnOn();
}

public abstract class Vehicle implements IVehicle {
  public void turnOn() { ... }
}

public interface Flier extends IVehicle {
  public void fly();
}
```
De cette façon, toutes les implémentations de Flier sont garantis pour mettre en œuvre les protocole d'un véhicule, à savoir IVehicle.
- Un peu pinailler - si le I* convention doit être utilisé (qui, d'ailleurs, ne semblait jamais tout ce que Java-y pour moi), puis il doit être utilisé pour tous interfaces...
- Oui, le I* convention est principalement un .NET chose. Je l'ai utilisé parce que j'étais dans le besoin des dénominations différentes, mais liées à Vehicle. Nettoyage les noms pour avoir un ensemble cohérent de nommage sera certainement aider.
InformationsquelleAutor Codo
2

C'est une exigence de l'étrange, mais vous pouvez accomplir quelque chose de la sorte avec les Génériques:
```
<T extends MyInterface & MyAbstractClass>
```
InformationsquelleAutor user207421
2

Si vous avez le contrôle sur la Vehicle classes il suffit d'extraire Vehicle comme une interface et une implémentation de base.

Si vous n'avez aucun contrôle sur Vehicle classe, par exemple parce qu'il fait partie d'un framework que vous utilisez ou d'un tiers de la bibliothèque, il n'est pas possible de le faire en Java.

La chose la plus proche que vous pouvez faire est de l'utilisation de Génériques de plusieurs caractères génériques notation.
```
<T extends Vehicle & Car>
```
Mais vous ne pouvez pas vraiment l'appliquer directement à la Voiture, sauf si vous faites quelque chose comme cela:
```
public interface Car<T extends Vehicle & Car>() {
    T self();
}
```
Qui est bot bizarre et ne pas appliquer l'auto fait de méthode de retour de soi, c'est juste une forte pointe/proposition.

Vous pouvez implémenter un Car comme ceci:
```
public class CitroenC3 extends Vehicle implements Car<CitroenC3> {
    @Override
    public CitroenC3 self() {
        return this;
    }
}
```
on peut utiliser un Car<?> comme ceci:
```
Car<?> car = obtainCarInSomeWay();
Vehicle v = car.self();
Car c = car.self();
```
ils doivent être à la fois une syntaxe valide.

Ce que le compilateur appliquer ici, c'est que ce que vous spécifiez dans Car<WHICH> QUI doit à la fois d'étendre Vehicle et de mettre en œuvre Car. Et en ajoutant self() que vous dites pour le programmeur que le T objet est censé être l'objet lui-même, forçant ainsi le caractère générique de l'instance pour correspondre à la classe s'il veulent être conformes à la spécification.

dans Java 8, vous pouvez même définir une implémentation par défaut pour la méthode d'auto.

Je souhaite aussi qu'il y a une meilleure façon de gérer quelque chose comme ça.

InformationsquelleAutor Daniele Segato
1

Cette question montre que vous n'avez pas compris l'essence de interface et class. Oublier le béton de la syntaxe Java droit maintenant, tout ce que vous devez comprendre, c'est que: l'interface est un ensemble de protocole, qui devrait être mise en œuvre agnostique. Il ne fait aucun sens de laisser une interface d'étendre une classe(ce qui est concret de mise en œuvre).

Revenir à votre question concrète, si vous voulez vous assurer qu'un Flier est toujours une sorte de Vehicle, il suffit de modifier ce dernier à un interface et laissez ancien étend(Il est logique d'étendre un protocole de l'autre protocole). Après cela, vous pouvez créer n'importe quel classe(abstraite ou concrète) qui implémente Vehicle ou Flier.
- Cela peut être le cas, mais l'Op peut-être l'aide d'un cadre dans lequel Vehicle est une classe (même si elle devrait être une interface).
InformationsquelleAutor Hui Zheng
0
1. Définir un nouveau Paquet
2. Créer une nouvelle interface (ie. HiddenOne) avec une portée "par défaut" avec une méthode "implementMe(HiddenOne)"
3. Déplacer le Véhicule et Dépliant pour le nouveau Package.
4. Hériter du Véhicule et Flier de HiddenOne
5. Mettre en œuvre la méthode implementMe dans le Véhicule.
Maintenant: Chaque fois que vous le souhaitez à mettre en œuvre à partir de "Tract" vous devez s'étend de Véhicule !
(parce que le Véhicule peut mettre en œuvre implementMe).

C'est délicat, mais fonctionne très bien.
- Il est également de plus en plus complexe de la solution à l'aide protégé inner-classes.
- Que faire si quelqu'un crée un Submarine classe au sein de ce nouveau paquet? Ensuite, ils pourraient mettre en œuvre HiddenOne directement, sans passer par Vehicle...
- Vous pouvez protéger votre package de sécurité-règles. Mais ... ok, la protégée à l'intérieur de la classe peut être plus facile.
InformationsquelleAutor Peter Rader

Vous devez vous connecter pour publier un commentaire.