Bonjour à tous, cet article ne concerne pas une fonctionnalité ou un concept lié à Java, mais plus que cela. Fondamentalement, je vais expliquer toutes les erreurs qu'un développeur Java fait lors de l'écriture du code et donc comment vous pouvez le minimiser et vous n'avez pas à refactoriser votre code. Cet article porte donc sur les MEILLEURES PRATIQUES qu'un développeur doit toujours suivre.

1. Qu'y a-t-il dans le nom :

Un développeur doit toujours essayer de donner un nom significatif aux variables, méthodes et classes. Il devient trop facile de comprendre en quoi consiste la méthode, la classe ou la variable lorsque quelqu'un lit votre code tout en le révisant ou en le déboguant. Donner des noms comme a, b et c à la variable n'a aucune signification et devient moins pertinent lors du débogage du code.

1. Commencez toujours le nom d'une classe par une majuscule. Par exemple.

public class Employee {
}

2. Commencez toujours un nom de variable par une minuscule. Par exemple.

private int salary;

3. Commencez toujours le nom de la méthode par des minuscules et n'incluez pas les mots Et et Ou dans le nom de la méthode. Par exemple.

public int calculateSalary(int noOfDaysWorked , int baseSalary)

public final int RETIREMENT_AGE = 58;

2. Plus petites les méthodes sont mieux à gérer et à déboguer :

Écrire beaucoup de choses dans une seule fonction conduit à une mauvaise implémentation de la conception. De plus, il n'est pas conseillé d'écrire des méthodes trop volumineuses car il est difficile de déboguer si tant de choses sont faites dans une seule fonction. Par conséquent, écrivez votre fonction entre 10 et 15 lignes en vous concentrant sur une seule chose que fait la méthode.

3. Soyez malin pour réduire les lignes de code :

Essayez toujours de réfléchir avant même de commencer à écrire un morceau de code. Pensez également à la possibilité de réduire le nombre de lignes que vous souhaitez écrire. Généralement, les développeurs vérifient une condition booléenne dans le bloc if, puis renvoient la valeur. Ce n'est pas la bonne façon d'écrire le code. Permettez-moi d'expliquer le morceau de code pour une meilleure compréhension.

boolean isContractor(Employee employee) { 
     if(employee.isCtr) { 
        return true;
     } else {
        return false;
     }
}

boolean isContractor(Employee employee) {
       return employee.isCtr;
}

4. Les commentaires sont-ils nécessaires ?

Oui, les commentaires ajoutent du sens aux méthodes ou algorithmes complexes, mais ils ne sont pas nécessaires pour votre code. Si vous écrivez un morceau de code et que vous pensez que n'importe quel développeur peut comprendre en lisant simplement le code, il n'est pas nécessaire d'ajouter des commentaires au code explicite. Mais n'oubliez pas d'ajouter des commentaires là où vous pensez avoir expliqué ou écrit une logique ou un algorithme complexe afin que plus tard tout développeur puisse comprendre lors du débogage du code.

5. Tâche unique en une seule méthode :

Ajouter de nombreuses tâches/choses dans une seule méthode n'est pas une bonne conception. Les développeurs doivent donc toujours essayer de maintenir différentes fonctions pour les différentes tâches à effectuer. Par exemple.

public void addUser(String userName , String password) {
//perform user addition operation to DB
}

Écrivez toujours les fonctions dans l'ordre où elles sont appelées. En outre, écrivez toutes les variables en haut de toutes les méthodes, afin qu'elles soient plus faciles à localiser. Si certaines variables ne sont utilisées que dans une seule fonction, essayez de faire de ces variables des variables locales pour cette fonction.

7. Les examinateurs n'aiment pas le code en double :

Chaque fois que vous commencez à écrire du code, vous pouvez jeter un œil aux fonctions et classes associées dans la base de code pour vérifier si une fonctionnalité similaire existe déjà ou non. S'il existe une méthode qui effectue la même tâche que vous le souhaitez, réutilisez-la.

S'il existe une méthode qui a un code similaire à celui que vous souhaitez écrire, écrivez une seule fonction qui effectuera la tâche des deux fonctions, l'une qui est déjà présente dans la base de code et l'autre que vous vouliez écrire. Il s'agit de la meilleure pratique pour supprimer le code en double.

8. Vérifiez la fonctionnalité de votre code en écrivant des cas de test :

Une fois que vous avez terminé d'écrire vos méthodes et les classes associées, continuez et identifiez les scénarios de test et les cas particuliers pour la fonctionnalité de votre code.

Vous pouvez désormais inclure des cas de test pour tous ces scénarios identifiés et vérifier si votre code réussit ou non ces cas de test. Pendant le codage, si vous avez manqué certains cas particuliers, essayez de les inclure.

9. Ne codez pas en dur :

Le codage en dur est une mauvaise idée que je vois généralement de nombreux développeurs faire lors du codage. Si vous codez en dur certaines chaînes, il devient difficile de tester la fonctionnalité que vous implémentez. Cela peut introduire des bogues dans votre code si quelque chose est modifié en rapport avec votre code.

private static String serverIpAddress = "1.2.3.4";

10. La journalisation facilite le débogage du code :

Lors de l'écriture du code, chaque développeur doit essayer de consigner les points nécessaires sur la fonctionnalité pour avoir une idée du flux ou des informations importantes. Cela permet à un autre développeur de lire plus facilement les journaux, de vérifier le flux de code, de déboguer et de résoudre le problème.

Un code sans journaux ou des journaux incorrects n'aide pas les autres développeurs à comprendre facilement le code et le développeur lui-même doit déployer des efforts supplémentaires pour déboguer le problème.

Notez également que le développeur ne doit pas enregistrer chaque résultat d'instruction, car une journalisation excessive peut réduire les performances de l'application.

11. Réduire les paramètres de la méthode :

Passer de nombreux paramètres à une seule fonction n'est pas une bonne pratique. Au lieu de cela, vous devriez essayer de créer un objet, puis de passer cet objet en tant que paramètre à la fonction. Cela améliore la lisibilité du code et améliore donc la qualité du code.

Par exemple.

public void addUser(String name , String gender , 
    String age ,String userName , String password) {
    //perform user addition operation to DB
}

public void addUser(User user) {
    //perform user addition operation to DB
}

//where user will be a class 
class User{
    private String name ;
    private String gender ;
    private int age ;
    private String userName;
    private String password;
    //here we can have constructors and getters and setters 
    //for above instance variables 
}

12. Réutilisation du code :

J'ai déjà parlé du code en double que vous devriez éviter. Fondamentalement, vous devez toujours rechercher vos fonctionnalités avant de les écrire dans la base de code ou dans la zone de code associée et si vous les trouvez, utilisez-les, sinon, continuez avec votre propre méthode et écrivez-les.

13. NOTE DE FIN

J'ai écrit de nombreuses bonnes pratiques que chaque développeur devrait suivre lors de l'écriture de code dans n'importe quel langage. Ces meilleures pratiques améliorent vos compétences en rédaction de code et vous aideront certainement dans un avenir proche. J'espère que vous avez pris note de ces points importants et que vous les implémenterez dans vos pratiques d'écriture de code.

Vous pouvez utiliser le plug-in SonarLint pour Eclipse et IntelliJ IDE pour améliorer la qualité de votre code. Ce plug-in vous suggère quelles sont les meilleures pratiques lors de l'écriture de code.

En conclusion, l'écriture de code propre est un aspect essentiel du développement logiciel qui peut avoir un impact significatif sur la qualité, la maintenabilité et la réussite globale d'un projet. Un code propre se caractérise par sa lisibilité, sa simplicité et sa clarté, et il suit les conventions de codage établies et les meilleures pratiques.

Le but ultime de l'écriture de code propre est de faciliter la compréhension et le travail des autres (et des futures versions de vous-même), ce qui conduit à une efficacité accrue et à une réduction des bogues. Adhérer aux principes d'un code propre nécessite de la discipline et un effort constant d'amélioration, mais les avantages valent bien l'investissement.

Suivez Vikram Gupta pour un contenu similaire.