J'ai remarqué quelque chose dans mon code dans divers projets qui me semble être une odeur de code et quelque chose de mal à faire, mais je ne peux pas y faire face.
En essayant d'écrire du "code propre", j'ai tendance à sur-utiliser des méthodes privées afin de rendre mon code plus facile à lire. Le problème est que le code est en effet plus propre mais il est aussi plus difficile à tester (ouais je sais que je peux tester des méthodes privées ...) et en général cela me semble une mauvaise habitude.
Voici un exemple de classe qui lit certaines données d'un fichier .csv et renvoie un groupe de clients (un autre objet avec divers champs et attributs).
public class GroupOfCustomersImporter {
//... Call fields ....
public GroupOfCustomersImporter(String filePath) {
this.filePath = filePath;
customers = new HashSet<Customer>();
createCSVReader();
read();
constructTTRP_Instance();
}
private void createCSVReader() {
//....
}
private void read() {
//.... Reades the file and initializes the class attributes
}
private void readFirstLine(String[] inputLine) {
//.... Method used by the read() method
}
private void readSecondLine(String[] inputLine) {
//.... Method used by the read() method
}
private void readCustomerLine(String[] inputLine) {
//.... Method used by the read() method
}
private void constructGroupOfCustomers() {
//this.groupOfCustomers = new GroupOfCustomers(**attributes of the class**);
}
public GroupOfCustomers getConstructedGroupOfCustomers() {
return this.GroupOfCustomers;
}
}
Comme vous pouvez le voir, la classe n'a qu'un constructeur qui appelle des méthodes privées pour faire le travail, je sais que ce n'est pas une bonne pratique en général, mais je préfère encapsuler toutes les fonctionnalités de la classe au lieu de rendre les méthodes publiques, auquel cas un client doit travailler de cette façon:
GroupOfCustomersImporter importer = new GroupOfCustomersImporter(filepath)
importer.createCSVReader();
read();
GroupOfCustomer group = constructGoupOfCustomerInstance();
Je préfère cela parce que je ne veux pas mettre de lignes de code inutiles dans le code côté client dérangeant la classe client avec des détails d'implémentation.
Alors, est-ce vraiment une mauvaise habitude? Si oui, comment puis-je l'éviter? Veuillez noter que ce qui précède n'est qu'un exemple simple. Imaginez la même situation se produisant dans quelque chose d'un peu plus complexe.