Comment déclarer une méthode abstraite, de sorte que le paramètre type (classe) est toujours les Enfants de la classe?
EDIT : voir en bas de
Tout d'abord j'ai cherché une réponse avant de poser celui-ci, mais comme vous pouvez le voir avec le titre, je n'ai aucune idée de comment cela s'appelle et je vais modifier la question à chaque fois que je le peux.
S'il vous plaît pardonnez-moi.
J'ai le texte suivant classe abstraite :
public abstract class ValidableDTO implements Serializable {
public abstract boolean isValid();
public abstract boolean equals(ValidableDTO compared);
//EDIT : new solution
public abstract <T extends ValidableDTO> boolean equals(T compared);
}
Je voudrais obtenir une mise en œuvre similaire :
public class MyDTO extends ValidableDTO {
private String myValue; //With a getter and setter of course
public MyDTO() {
//...
}
@Override
public boolean isValid() {
return true; //Validation
}
//__________ LOOK AT THE FOLLOWING PARAMETER TYPE __________
@Override
public boolean equals(MyDTO compared) {
return true; //Comparison
}
}
Le plus proche que j'ai pu obtenir est
@Override
public boolean equals(ValidableDTO compared) {
boolean isEqual = false;
if (compared instanceof MyDTO) {
isEqual = getValue().equals(compared.getValue());
}
return isEqual;
}
J'ai essayé d'utiliser public abstract boolean equals(<? extends ValidableDTO> compared);
mais cela ne fonctionne pas.
Est que même possible (il devrait être OMI) ? Je vous remercie pour votre temps et ... je ne sais toujours pas comment décrire ce en 1 phrase... (lol)
Sincèrement.
- moi
Un pas de plus, grâce à l'utilisateur : aps !
les ouvrages suivants, dans l'Abstrait, la définition de la classe (ValidableDTO)
public abstract <T extends ValidableDTO> boolean equals(T compared);
__MAIS__
la mise en œuvre dans MyDTO n'est toujours pas à l'amende et à la fin, c'est exactement la même que l'aide de mon "si instanceof" solution car ValidableDTO est une classe abstraite et doit être héritée.
À quoi ça ressemble pour l'instant à l'aide de l'Aps solution :
public <T extends ValidableDTO> boolean equals(T compared) { ... }
Je dois encore vérifier si c'est un MyDTO exemple...
SUR UNE NOTE de CÔTÉ, google ne semble pas savoir si "Validable" ou "traitement pouvant être validé" sont de vrais mots.. ce qui est correct?
OriginalL'auteur dominicbri7 | 2011-06-28
Vous devez vous connecter pour publier un commentaire.
Vous pouvez le faire à l'aide de médicaments génériques sur la déclaration de votre signature de la méthode à la classe abstraite:
[MODIFIER]
Résumé des commentaires de la discussion ci-dessous:
Concernant Java style de codage et de principes, il serait plus raisonnable de remplacer la valeur par défaut
public boolean equals(Object other)
méthode au lieu d'utiliser un des génériques de la construction pour tenter de contraindre le type du paramètre. La norme de pratique pour la equals(...) est d'utiliser la instaceof opérateur pour vérifier les paramètre de compatibilité, d'effectuer une distribution et une utilisation plus fine granularité des comparaisons au niveau de l'objet spécifique de la structure. C'est similaire à la proposition d'alternatives de mise en œuvre dans le post original.Cette approche a pour avantage supplémentaire de la valeur de la prise de la classe de prêt pour une utilisation dans une collection, qui est un cas très commun pour les DTO classes (par exemple,
List<UserDTO>
)concernant le style de codage, je m'interroge sur la nécessité de votre classe abstraite pour remplacer (spécialisés) de l'Objet.equals(Object autres). Les conditions générales du contrat d'égal à égal vous oblige à vérifier l'égalité fondée sur le type de l'autre objet. Une implémentation typique de equals(Object) pourront utiliser instanceof et à le regarder comme l'alternative que vous avez présentés dans votre question initiale. Sauf si vous avez une bonne raison de mettre cela dans votre classe abstraite, je préfère laisser tomber et de garder les choses simples.
donner un plus à la conception, je serais certainement goutte d'égal à égal et, sauf si vous êtes à la mise en œuvre de certaines communes de code réutilisable dans ValidableDTO, je voudrais faire une interface au lieu d'une classe abstraite. À partir d'un composabilité point de vue, il est logique qu'une classe de mise en œuvre ValidableDTO a une méthode de validation. Mais comment puis-je lire des égaux? ValidableAndComparableDTO? Juste de la nourriture pour la pensée.
J'ai voulu faire en sorte que chaque et chaque de la mise en œuvre de ValidableDTO (par exemple: MyDTO) pourrait se comparer à une autre instance de la même mise en œuvre (un autre MyDTO) parce que chaque mise en oeuvre devra être comparé de manière différente, mais toujours par rapport à une autre instance du même type. De Plus, vous ne peut pas le comparer à l'aide opérateur==, même si c'est un simple wrapper. Je suppose que si jamais j'ai besoin de les comparer, je vais définir directement dans la mise en place de la super-classe Abstraite car elle ne semble pas être possible
dans un schéma d'utilisation standard pour un DTO, vous aurez des collections d'objets à un certain point. Une Liste, Ensemble ou d'une Carte à l'aide de <MyDTO> nécessitera une mise en œuvre correcte de l'Objet.equals(). Ce que je veux dire, c'est que vous pouvez tuer les 2 (en colère)oiseaux avec une seule pierre par la mise en œuvre de @override public boolean equals(Object autres) { if (autres instanceof MyDTO) { MyDTO otherDTO = (MyDTO) d'autres; de retour cette.getValue().equals(otherDTO.getValue())} return false; } // l'esprit des valeurs null
OriginalL'auteur maasg