[JAVA] Punkt 57 Minimieren Sie den Umfang lokaler Variablen

Annahme

Ein Neuling, der Java seit ungefähr einem Monat entwickelt, schreibt, um das auszugeben, was er durch das Lesen von Effective Java gelernt hat. Ich strebe einen Artikel an, der selbst für Anfänger so einfach wie möglich zu verstehen ist, indem ich meine Interpretation aufschlüssle und erkläre.

[Grob]

Durch die Minimierung des Bereichs lokaler Variablen kann die Lesbarkeit und Wartbarkeit Ihres Codes verbessert und die Wahrscheinlichkeit von Fehlern verringert werden.

[Schlechtes Beispiel 1]

badPractice1

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

doSomething(hoge);

... //Einige Verarbeitung

doSomething(fuga); //Was ist der Fuga-Typ? Was ist der Anfangswert?

... //Einige Verarbeitung

{
    doSomething(piyo) //Was ist die Art von Piyo? Was ist der Anfangswert?
}

• Lenkt die Aufmerksamkeit des Lesers ab.
  -> Ich versuche zu verstehen, was ich tue, aber ich benutze die Ressourcen meines Gehirns, um mir Variablen zu merken.
• Der Leser hat Schwierigkeiten, sich den Typ und den Anfangswert zu merken, wenn die Variable verwendet wird.
• Breiter Anwendungsbereich.
  -> Je breiter der Anwendungsbereich, desto wahrscheinlicher ist es, dass er an unbeabsichtigten Orten mit katastrophalen Folgen eingesetzt wird.

[Lass uns das schreiben]

goodPractice1

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

... //Einige Verarbeitung

int fuga = 10;
doSomething(fuga);

... //Einige Verarbeitung

double piyo = 0.1;
{
    doSomething(piyo)
}

--Erläutern Sie das erste Mal, wenn eine lokale Variable verwendet wird.
-> Der Variablentyp und der Anfangswert müssen nicht gespeichert werden, und der Leser kann sich darauf konzentrieren, den Prozess zu verstehen.

• Reduzieren Sie den Umfang.
  -> Fuga und Piyo haben einen engeren Vorwärtsbereich, wodurch die Möglichkeit einer falschen Verwendung verringert wird.
• Lokale Variablen enthalten grundsätzlich Anfangswerte.
  -> Wenn keine Informationen vorhanden sind, um die Variable angemessen zu initialisieren, ist es nicht an der Zeit, sie zu initialisieren. Daher sollte sie verschoben werden, bis die Informationen abgerufen wurden (mit Ausnahme der Ausnahme durch den Try-Catch-Block unten).

exception

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

-> In einem solchen Fall ist eine rationale Initialisierung nicht möglich.

[Schlechtes Beispiel 2]

badPractice2

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

Iterator<Hoge> i2 = hoge2.iterator();
while(i.hasNext()) { //Es gibt einen Fehler
    doSomething(i2.next());
}

• Der große Umfang lokaler Variablen verursacht Fehler.
  -> Da es kein Problem mit dem Code selbst gibt, wird er normal kompiliert und es ist schwierig, Fehler zu bemerken.

[Lass uns das schreiben]

goodPractice2

for (Iteratro<Hoge> i = hoge.iterator(); i.hasNext()) {
    doSomething(i.next());
}
//Kompilierungsfehler-Ich habe nicht gefunden
for (Iteratro<Hoge> i2 = hoge2.iterator(); i.hasNext()) {
    doSomething(i2.next());
}

• Sie können den Fehler sofort bemerken.
  -> Da die Bereiche von i und i2 im for-Block enthalten sind, tritt ein Kompilierungsfehler auf, wenn Sie versuchen, auf eine Variable außerhalb des Bereichs zu verweisen.
• Doppelte Variablennamen müssen nicht vermieden werden. Ein Beispiel ist unten gezeigt.
  

goodPractice3

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

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

-> Es hat einen sehr raffinierten Schreibstil und ist leichter zu lesen als währenddessen.

[Schlechtes Beispiel 3]

badPractice4

public int calcTotalAmount(int price) {
    double taxRate = 1.1;
    ... //Verarbeitung zur Berechnung des Preises einschließlich Steuern

    ... //Verarbeitung zur Berechnung der Versandkosten

    int totalAmount = taxIncludedPrice + shippingFee;

    return totalAmount;
}

• Im Bereich ist eine lokale Variable vorhanden, die nichts mit dem Prozess zu tun hat.
  -> Eine lokale Variable namens taxRate existiert im Rahmen des irrelevanten Prozesses zur Berechnung der Versandkosten.

[Lass uns das schreiben]

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;
    ... //Verarbeitung zur Berechnung des Preises einschließlich Steuern

    return taxIncludedPrice ;
}

public int calcShippingFee(int price) {
    ... //Verarbeitung zur Berechnung der Versandkosten

    return shippingFee;
}

-> Es werden keine unnötigen lokalen Variablen in den Bereich aufgenommen, wodurch die Möglichkeit von Fehlern verringert wird.

[Zusammenfassung]

1. Deklarieren Sie die lokale Variable bei der ersten Verwendung.
2. Wenn Sie eine lokale Variable deklarieren, sollte grundsätzlich der Anfangswert enthalten sein.
3. Verwenden Sie for-Schleifen anstatt while (nur wenn Sie nach dem Ende der Schleife keine Schleifenvariablen benötigen).
4. Verkleinern Sie die Methode, um sie fokussierter zu machen.