[JAVA] Point 57 Réduire la portée des variables locales

supposition

Un nouveau venu qui développe java depuis environ un mois écrit pour sortir ce qu'il a appris en lisant Effective Java. Je vise un article aussi simple que possible à comprendre même pour les débutants, en décomposant mon interprétation et en l'expliquant.

[Grossièrement]

La réduction de la portée des variables locales peut améliorer la lisibilité et la maintenabilité de votre code et réduire le risque de commettre des erreurs.

[Mauvais exemple 1]

badPractice1

String hoge = "hoge";
int fuga;
double piyo = 0.1;

doSomething(hoge);

... //Certains traitements

doSomething(fuga); //Quel est le type de fuga? Quelle est la valeur initiale?

... //Certains traitements

{
    doSomething(piyo) //Quel est le type de piyo? Quelle est la valeur initiale?
}

—— Détourne l'attention du lecteur.
-> J'essaie de comprendre ce que je fais, mais j'utilise les ressources de mon cerveau pour me souvenir des variables.

• Le lecteur a du mal à se souvenir du type et de la valeur initiale lorsque la variable est utilisée. --Large champ.
  -> Plus le champ d'application est large, plus il est susceptible d'être utilisé dans des endroits non prévus, avec des conséquences désastreuses.

[Écrivons ceci]

goodPractice1

String hoge = "hoge";
doSomething(hoge);

... //Certains traitements

int fuga = 10;
doSomething(fuga);

... //Certains traitements

double piyo = 0.1;
{
    doSomething(piyo)
}

--Déclarez la première fois qu'une variable locale est utilisée.
-> Il n'est pas nécessaire de mémoriser le type de variable et la valeur initiale, et le lecteur peut se concentrer sur la compréhension du processus.

• Réduisez la portée.
  -> fuga et piyo ont une portée avant plus étroite, ce qui réduit la possibilité d'une mauvaise utilisation.
• Les variables locales incluent essentiellement les valeurs initiales.
  -> S'il n'y a aucune information pour initialiser raisonnablement la variable, ce n'est pas le moment de l'initialiser, il faut donc la reporter jusqu'à ce que l'information soit obtenue (sauf pour l'exception par le bloc try-catch ci-dessous).

exception

Hoge hoge = null;
try {
    hoge = hogeHoge();
} catch (HogeException e) {
    e.hoge();
}
hoge.doSomething();

-> Dans un tel cas, une initialisation rationnelle n'est pas possible.

[Mauvais exemple 2]

badPractice2

Iterator<Hoge> i = hoge.iterator();
while(i.hasNext()) {
    doSomething(i.next());
}

Iterator<Hoge> i2 = hoge2.iterator();
while(i.hasNext()) { //Il y a un bug
    doSomething(i2.next());
}

• Le large éventail de variables locales provoque des bogues.
  -> Puisqu'il n'y a aucun problème avec le code lui-même, il se compile normalement et il est difficile de remarquer les erreurs.

[Écrivons ceci]

goodPractice2

for (Iteratro<Hoge> i = hoge.iterator(); i.hasNext()) {
    doSomething(i.next());
}
//Erreur de compilation-je n'ai pas trouvé
for (Iteratro<Hoge> i2 = hoge2.iterator(); i.hasNext()) {
    doSomething(i2.next());
}

• Vous pouvez immédiatement remarquer l'erreur.
  -> Puisque les portées de i et i2 sont respectivement contenues dans le bloc for, une erreur de compilation se produira si vous essayez de faire référence à une variable en dehors de la portée.
• Pas besoin d'éviter les noms de variables en double. Un exemple est présenté ci-dessous.
  

goodPractice3

for (Iteratro<Hoge> i = hoge.iterator(); i.hasNext()) {
    doSomething(i.next());
}

for (Iteratro<Hoge> i = hoge2.iterator(); i.hasNext()) {
    doSomething(i.next());
}

-> Il a un style d'écriture très sophistiqué et est plus facile à lire que tout.

[Mauvais exemple 3]

badPractice4

public int calcTotalAmount(int price) {
    double taxRate = 1.1;
    ... //Traitement pour calculer le prix TTC

    ... //Traitement pour calculer les frais d'expédition

    int totalAmount = taxIncludedPrice + shippingFee;

    return totalAmount;
}

• Une variable locale qui n'a rien à voir avec le processus existe dans la portée.
  -> Une variable locale appelée taxRate existe dans le cadre du processus non pertinent de calcul des frais d'expédition.

[Écrivons ceci]

goodPractice4

public int calcTotalAmount(int price) {
    int taxIncludedPrice = calcTaxIncludedPrice(price);
    int shippingFee = calcShippingFee(price);

    return taxIncludedPrice + shippingFee;
}

public int calcTaxIncludedPrice(int price) {
    double taxRate = 1.1;
    ... //Traitement pour calculer le prix TTC

    return taxIncludedPrice ;
}

public int calcShippingFee(int price) {
    ... //Traitement pour calculer les frais d'expédition

    return shippingFee;
}

-> Il ne contient pas de variables locales inutiles dans la portée, ce qui réduit la possibilité de bogues.

[Résumé]

1. Déclarez la variable locale la première fois qu'elle est utilisée.
2. Lors de la déclaration d'une variable locale, la valeur initiale doit être incluse.
3. Utilisez des boucles for plutôt que while (uniquement si vous n'avez pas besoin de variables de boucle après la fin de la boucle).
4. Réduisez la taille de la méthode pour la rendre plus ciblée.