Ho notato qualcosa nel mio codice in vari progetti che mi sembrano odore di codice e qualcosa di brutto da fare, ma non riesco a gestirlo.
Mentre provo a scrivere "codice pulito" tendo a sovra-usare i metodi privati per rendere il mio codice più facile da leggere. Il problema è che il codice è effettivamente più pulito ma è anche più difficile da testare (sì, so che posso testare metodi privati ...) e in generale mi sembra una cattiva abitudine.
Ecco un esempio di una classe che legge alcuni dati da un file .csv e restituisce un gruppo di clienti (un altro oggetto con vari campi e attributi).
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;
}
}
Come puoi vedere la classe ha solo un costruttore che chiama alcuni metodi privati per portare a termine il lavoro, so che è non sono una buona pratica in generale, ma preferisco incapsulare tutte le funzionalità nella classe invece di rendere pubblici i metodi, nel qual caso un client dovrebbe funzionare in questo modo:
GroupOfCustomersImporter importer = new GroupOfCustomersImporter(filepath)
importer.createCSVReader();
read();
GroupOfCustomer group = constructGoupOfCustomerInstance();
Lo preferisco perché non voglio mettere linee di codice inutili nel codice lato del client disturbando la classe client con i dettagli di implementazione.
Quindi, questa è una cattiva abitudine? Se sì, come posso evitarlo? Si prega di notare che quanto sopra è solo un semplice esempio. Immagina che la stessa situazione si verifichi in qualcosa di un po 'più complesso.