Il y a un exercice dans le livre "Le langage de programmation Java 4e édition":
Exercice 2.17: Ajoutez deux méthodes turn au Vehicle : une qui prend plusieurs degrés pour tourner et une
qui prend l'une des constantes Vehicle.TURN_LEFT ou Vehicle.TURN_RIGHT .
Il n'y a pas d'autres informations sur le type de données de ces constantes - la seule information est que la classe a l'attribut direction de type int représentant les degrés (sur un plan).
L'idée est d'utiliser la surcharge mais si on a: p>
public class Vehicle {
public final static int TURN_LEFT = -90;
public final static final int TURN_RIGHT = 90;
...
public void turn(int degrees) {
this.currentDirection = degrees;
}
public void turn (???) {
???
}
}
Quelle pourrait être la définition de la méthode turn surchargée prenant les 2 constantes? Ils sont également de type int donc quelle autre signature de méthode turn serait possible (une qui prend 1 des 2 constantes possibles)?
Y a-t-il un moyen de forcer une méthode à ne prendre que des paramètres constants particuliers?
Je sais que l'on peut utiliser un enum pour définir TURN_LEFT et TURN_RIGHT dans un type spécial, qui pourrait être utilisé comme paramètre (filtré) pour la méthode turn , mais les constantes sont déjà données en tant que membres de la classe Vehicle ... exercice ou y a-t-il une autre astuce ici?
3 Réponses :
Puisque les deux seules possibilités sont GAUCHE ou DROITE, j'associerais chacune d'elles à un booléen, par exemple LEFT -> true, RIGHT -> false et je passerai l'argument un booléen. Comme:
public void turn ( boolean leftOrRight ) { // do the checking on the value passed as a boolean
}
oui, il existe de nombreuses manières possibles en général. Mais la question concerne cet exercice spécifique - l'utilisation de la surcharge avec les constantes données en paramètres ... quelle autre signature de méthode turn serait possible?
La manière classique de gérer ce type de constantes en Java est en effet, comme vous l'avez mentionné, l'utilisation d'énumérations. Vous surchargez ensuite votre méthode turn () avec à la fois un entier et votre paramètre de type enum. L'avantage est une séparation de votre classe actuelle et des différentes directions (peut-être à venir) à suivre.
La question est de savoir si les énumérations ont été traités. Dans ce cas, une énumération est idéale:
public static final Object TURN_LEFT = new Object();
public static final Object TURN_RIGHT = new Object();
public void turn(Object direction) {
turn(direction == Vehicle.TURN_LEFT ? -90 : 90);
}
J'ai dupliqué les constantes d'énumération en tant que champs finaux afin d'avoir un Vehicle.TURN_LEFT.
Sans enum:
public enum Turn {
TURN_LEFT(-90),
TURN_RIGHT(90);
public final int degrees;
Turn(int degrees) {
this.degrees = degrees;
}
}
public static final Turn TURN_LEFT = Turn.TURN_LEFT;
public static final Turn TURN_RIGHT = Turn.TURN_RIGHT;
public void turn(Turn direction) {
turn(direction.degrees);
}
Mais ce n'est pas un type sûr, qui aurait besoin d'une classe / interface locale.
p>
aucun enum n'a été traité jusqu'à présent (ils viennent plus tard dans le livre) et surtout - TURN_LEFT et TURN_RIGHT sont membres de la classe < code> Vehicle - ils sont donnés comme Vehicle.TURN_LEFT et ainsi de suite ... seul leur type n'est pas donné - mais il est logique de supposer int je pense.
OK :) J'ai voté à cause de "J'ai dupliqué les constantes d'énumération comme fina ..." donc toutes les conditions sont remplies. Mais cela signifierait que l'exercice n'est tout simplement pas si bon. (s'il n'y a pas d'autre truc là-bas)
On pourrait créer deux constantes String ou boolean , donc turn pourrait être surchargé. Ou très sale un double . J'ajouterai du code.
Je pensais cela aussi, mais cela indique encore une fois une mauvaise formulation de l'exercice ...