Eclipse Eclipse: Unreachable code

[Guenter123987]

Das ist die Klasse:

public class KeyCodeGenerator {
   
   public long currentKeyCode;
   int currentDigitIndex = 0;
   
   public KeyCodeGenerator() {
       this.currentKeyCode = 0L;
   }
   
   public long nextKeyCode() {
       if (currentKeyCode < 9999L) {
           currentKeyCode++;
           return currentKeyCode;
       } else {
           return -1L;
       }
   }
   
   public int[] nextKeyCodeInArray() {
       if (currentKeyCode < 9999L) {
           currentKeyCode++;
           
           int[] currentIndexDigits = new int[4];
           currentIndexDigits[0] = (int) ( currentKeyCode / 1000L)       ;
           currentIndexDigits[1] = (int) ((currentKeyCode / 100L ) % 10L);
           currentIndexDigits[2] = (int) ((currentKeyCode / 10L  ) % 10L);
           currentIndexDigits[3] = (int) ( currentKeyCode          % 10L);
           return currentIndexDigits;
       } else {
           return null;
       }
   }
   
   public int nextDigit() {
            if (currentDigitIndex == 0) { currentDigitIndex++; return (int) ( currentKeyCode / 1000L)       ; }
       else if (currentDigitIndex == 1) { currentDigitIndex++; return (int) ((currentKeyCode / 100L ) % 10L); }
       else if (currentDigitIndex == 2) { currentDigitIndex++; return (int) ((currentKeyCode / 10L  ) % 10L); }
       else if (currentDigitIndex == 3) { currentDigitIndex=0; return (int) ( currentKeyCode          % 10L); this.nextKeyCode(); }
       else { return -1; }
   }
}

Das Problem liegt in der nextDigit-Methode bei diesem Befehl:

this.nextKeyCode()

Hier wird die Fehlermeldung "Unreachable code" angezeigt. Warum? Danke im Voraus.

 

[Joose]

Weil die Methode beim return-Statement verlassen wird. Alles danach wird nicht mehr ausgeführt.

 

[Guenter123987]

Danke.

 

[Joose]

Kleiner Tipp: Formatiere den Code besser, dann wird er nicht nur für dich sondern auch für andere lesbarer.
Vor allem in deiner Methode "nextDigit()" ist schwer ersichtlich wieviele Statements da jeweils in einem Block stehen.

Folgender Code ist 1:1 deiner, aber um einiges lesbarer 😉

public int nextDigit() {
   if (currentDigitIndex == 0) {
       currentDigitIndex++;
       return (int) (currentKeyCode / 1000L);
   } else if (currentDigitIndex == 1) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 100L) % 10L);
   } else if (currentDigitIndex == 2) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 10L) % 10L);
   } else if (currentDigitIndex == 3) {
       currentDigitIndex = 0;
       return (int) (currentKeyCode % 10L);
       this.nextKeyCode();
   } else {
       return -1;
   }
}

 

[Guenter123987]

Für mich war der Vorgänger lesbarer aufgrund der Kompaktheit, aber ich schreibe die Befehle in Zukunft immer in einzelne Zeilen, wenn das euch beim Lesen hilft.

 

[krgewb]

Schau mal wie akribisch er jedes einzelne Leerzeichen positioniert hat:

   public int nextDigit() {
            if (currentDigitIndex == 0) { currentDigitIndex++; return (int) ( currentKeyCode / 1000L)       ; }
       else if (currentDigitIndex == 1) { currentDigitIndex++; return (int) ((currentKeyCode / 100L ) % 10L); }
       else if (currentDigitIndex == 2) { currentDigitIndex++; return (int) ((currentKeyCode / 10L  ) % 10L); }
       else if (currentDigitIndex == 3) { currentDigitIndex=0; return (int) ( currentKeyCode          % 10L); this.nextKeyCode(); }
       else { return -1; }
   }

PS: Wenn du so etwas hast:

public int nextDigit() {
   if (currentDigitIndex == 0) {
       currentDigitIndex++;
       return (int) (currentKeyCode / 1000L);
   } else if (currentDigitIndex == 1) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 100L) % 10L);
   } else if (currentDigitIndex == 2) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 10L) % 10L);
   } else if (currentDigitIndex == 3) {
       currentDigitIndex = 0;
       return (int) (currentKeyCode % 10L);
       this.nextKeyCode();
   } else {
       return -1;
   }
}

dann kannst du es auch so machen:

public int nextDigit() {
   if (currentDigitIndex == 0) {
       currentDigitIndex++;
       return (int) (currentKeyCode / 1000L);
   }

   else if (currentDigitIndex == 1) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 100L) % 10L);
   }

   else if (currentDigitIndex == 2) {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 10L) % 10L);
   }
 
   else if (currentDigitIndex == 3) {
       currentDigitIndex = 0;
       return (int) (currentKeyCode % 10L);
       this.nextKeyCode();
   }

   else {
       return -1;
   }
}

Wenn du den Code dann von Eclipse formatieren lässt werden die Leerzeilen nicht entfernt.

 

[Thallius]

Genau und ich gehe sogar noch einen Schritt weiter und verwende die alte Klammer-Syntax weil ich sie einfach viel schöner zu lesen finde

public int nextDigit()
{
   if (currentDigitIndex == 0)
   {
           currentDigitIndex++;
       return (int) (currentKeyCode / 1000L);
   }
   else if (currentDigitIndex == 1)
   {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 100L) % 10L);
   }
   else if (currentDigitIndex == 2)
   {
       currentDigitIndex++;
       return (int) ((currentKeyCode / 10L) % 10L);
   }
   else if (currentDigitIndex == 3)
   {
       currentDigitIndex = 0;
       return (int) (currentKeyCode % 10L);
       this.nextKeyCode();
   }
   else
       return -1;
}

Ich habe nie verstanden was der Sinn der neuen Syntax ist? Das sparen eine Zeile? Der Block beginnt mit { und endet mit }.Davor steht die Bedingung wann dieser Block abgearbeitet wird. Warum soll die Klammer auf also in der Gleichen Zeile stehen wie die Bedingung? Ich finde das einfach viel unleserlicher.

Aber wahrscheinlich gewöhnt man sich irgendwann dran. Nur ich habe da keinen Bock drauf 🙂


Gruß

Claus

 

[Joose]

Für mich war der Vorgänger lesbarer aufgrund der Kompaktheit, ....

Wenn du damit besser zurecht kommst, dann kannst du natürlich dabei bleiben. Du musst dich zurecht finden in deinen Code.

....aber ich schreibe die Befehle in Zukunft immer in einzelne Zeilen, wenn das euch beim Lesen hilft.

Es war nur eine Anmerkung dass andere sich leichter tun beim Code lesen + verstehen wenn man sich an allgemeine Konventionen hält. Auch hast du den Vorteil das viele Tutorials oder Code Schnipsel auf den unterschiedlichsten Webseiten sich im groben an die allg. Konventionen halten. Dadurch würdest du dir auch leichter tun diesen Code zu verstehen.

dann kannst du es auch so machen:
.....
Wenn du den Code dann von Eclipse formatieren lässt werden die Leerzeilen nicht entfernt.

Noch unleserlicher und die Leerzeilen zerstören den Zusammenhang vom if/elseif.

Genau und ich gehe sogar noch einen Schritt weiter und verwende die alte Klammer-Syntax weil ich sie einfach viel schöner zu lesen finde

Finde ich auch 😉 leider ist es in Java nicht üblich deswegen habe ich mich für Java an die üblichere Schreibweise gewöhnt.
In C# schreibe ich weiterhin die Klammern in eigene Zeilen.

Ich habe nie verstanden was der Sinn der neuen Syntax ist? Das sparen eine Zeile? Der Block beginnt mit { und endet mit }.Davor steht die Bedingung wann dieser Block abgearbeitet wird. Warum soll die Klammer auf also in der Gleichen Zeile stehen wie die Bedingung? Ich finde das einfach viel unleserlicher.

Ich auch nicht wirklich. Oft will mir wer erklären man erkennt den Block ja auch anhand der Einrückung, dann lässt aber wer mal Klammern weg die Einrückung stimmt dann vielleicht nicht (wegen fehlenden Autoformat) und schon muss man extra kontrollieren ist die Klammer da oder nicht usw.

 

[Guenter123987]

Eben wegen den akribischen Leerzeichen finde ich mich in meinem Code ja gut zurecht und erkenne Zusammenhänge schnell wieder.

 

[krgewb]

Genau und ich gehe sogar noch einen Schritt weiter und verwende die alte Klammer-Syntax weil ich sie einfach viel schöner zu lesen finde

Aber das wird auch zerstört wenn man sich die Einrückungen von Eclipse machen lässt (bei Windows: Strg + Shift + F).

 

[Thallius]

Aber das wird auch zerstört wenn man sich die Einrückungen von Eclipse machen lässt (bei Windows: Strg + Shift + F).

Was man ja zum Glück nicht benutzen muss ...

 

[JStein52]

Aber das wird auch zerstört wenn man sich die Einrückungen von Eclipse machen lässt

Oder auch nicht wenn man das in den Project-Properties/Java Code Style/Formatter auf seine eigenen Wünsche einstellt.

 

[Thallius]

Oder auch nicht wenn man das in den Project-Properties/Java Code Style/Formatter auf seine eigenen Wünsche einstellt.

Wow das muss ich morgen mal ausprobieren...

 

[Guenter123987]

Ich habe nie verstanden was der Sinn der neuen Syntax ist? Das sparen eine Zeile?

Durch weniger Zeilen ist mehr Code auf dem Monitor. Und das hilft bei großen Klassen enorm.

 

[Joose]

Durch weniger Zeilen ist mehr Code auf dem Monitor. Und das hilft bei großen Klassen enorm.

Jein 😉
Monsterklassen sollte man vermeiden, Methoden sollten auch nicht ewig lang sein sondern kurz und knackig.
Daher ist dieses Argument nur bedingt richtig.

 

[thecain]

Ist doch einfach eine Frage der Gewohnheit...

Ich lese schon sehr lange Java Code, deswegen sieht der Java Code Style halt für meine Augen besser aus...

Irgendetwas esoterisches würde ich trotzdem vermeiden, wenn jemand anders an meinem Code arbeiten soll...

 

[mrBrown]

Ist doch die gleiche Diskussion, wie snake_case vs camelCase 😉

Solange man sich beim zusammenarbeiten auf eines einigen kann ist doch alles gut. Ansonsten wird halt einmal autoformatiert...