Quand je vois de longues listes de paramètres, ma première question est de savoir si cette fonction ou cet objet en fait trop. Considérer:
EverythingInTheWorld earth=new EverythingInTheWorld(firstCustomerId,
lastCustomerId,
orderNumber, productCode, lastFileUpdateDate,
employeeOfTheMonthWinnerForLastMarch,
yearMyHometownWasIncorporated, greatGrandmothersBloodType,
planetName, planetSize, percentWater, ... etc ...);
Bien sûr, cet exemple est délibérément ridicule, mais j'ai vu beaucoup de programmes réels avec des exemples à peine moins ridicules, où une classe est utilisée pour contenir de nombreuses choses à peine liées ou non liées, apparemment simplement parce que le même programme appelant a besoin des deux ou parce que le le programmeur a pensé aux deux en même temps. Parfois, la solution la plus simple consiste simplement à diviser la classe en plusieurs morceaux dont chacun fait son propre travail.
Un peu plus compliqué, c'est quand une classe doit vraiment gérer plusieurs choses logiques, comme à la fois une commande client et des informations générales sur le client. Dans ces cas, créez une classe pour le client et une classe pour la commande, et laissez-les se parler si nécessaire. Donc au lieu de:
Order order=new Order(customerName, customerAddress, customerCity,
customerState, customerZip,
orderNumber, orderType, orderDate, deliveryDate);
Nous pourrions avoir:
Customer customer=new Customer(customerName, customerAddress,
customerCity, customerState, customerZip);
Order order=new Order(customer, orderNumber, orderType, orderDate, deliveryDate);
Bien que je préfère bien sûr les fonctions qui ne prennent que 1 ou 2 ou 3 paramètres, il faut parfois accepter que, de manière réaliste, cette fonction en prenne beaucoup et que le nombre en soi ne crée pas vraiment de complexité. Par exemple:
Employee employee=new Employee(employeeId, firstName, lastName,
socialSecurityNumber,
address, city, state, zip);
Oui, c'est un tas de champs, mais probablement tout ce que nous allons faire avec eux est de les enregistrer dans un enregistrement de base de données ou de les jeter sur un écran ou quelque chose du genre. Il n'y a pas vraiment beaucoup de traitement ici.
Lorsque mes listes de paramètres deviennent longues, je préfère de loin que je puisse donner aux champs différents types de données. Comme quand je vois une fonction comme:
void updateCustomer(String type, String status,
int lastOrderNumber, int pastDue, int deliveryCode, int birthYear,
int addressCode,
boolean newCustomer, boolean taxExempt, boolean creditWatch,
boolean foo, boolean bar);
Et puis je le vois appelé avec:
updateCustomer("A", "M", 42, 3, 1492, 1969, -7, true, false, false, true, false);
Je m'inquiète. En regardant l'appel, on ne sait pas du tout ce que signifient tous ces nombres, codes et drapeaux cryptiques. C'est juste demander des erreurs. Un programmeur pourrait facilement se perdre dans l'ordre des paramètres et en changer accidentellement deux, et s'ils sont du même type de données, le compilateur l'accepterait simplement. Je préfère de loin avoir une signature où toutes ces choses sont des énumérations, donc un appel passe par des choses comme Type.ACTIVE au lieu de "A" et CreditWatch.NO au lieu de "false", etc.