Dead Code im Programm?

überlebender

Aktives Mitglied
Hi, ich muss ein Programm schreiben, dass die Wahrheitswerte von Variablen in Abhängigkeit von dem Wahrheitswert anderer Variablen ausgibt. Nun habe ich den Code geschrieben, er funktioniert auch aber in einer Zeile steht "Dead Code"? Ich verstehe nun nicht warum.

Aufgabenstellung:
• Deklarieren Sie im DB die statischen boolean-Variablen x,y sowie a,b,c und die statische int-Variable input. Allen Variablen weisen Sie beliebige Werte zu. Sie dürfen bei input davon ausgehen, dass nur einer der folgenden Werte eingegeben wird: 0,1,10 oder 11.

Wir definieren folgende Eigenschaften:
– E1: x ist wahr (hat also den Wert true).
– E2: y ist wahr.
– E3: die Werte von x und y sind unterschiedlich.

• Im AB weisen Sie x nur dann den Wert true zu, falls input den Wert 10 oder 11 hat. In den beiden anderen Fällen erhält x also den Wert false. Weisen Sie y nur dann den Wert true zu, falls input den Wert 11 oder 1 hat;
In den anderen beiden Fällen wird y der Wert false zugewiesen. Weiterhin erhält a nur dann den Wert true, falls E1 und E2 (gleichzeitig) erfüllt sind. Die Variable b erhält nur dann den Wert true, falls mindestens eine der Eigenschaften E1 und E3 erfüllt sind. Die Variable c verhält sich entsprechend der folgenden Wahrheitstabelle:
Screenshot 2023-11-17 115938.jpg

Java:
package a2;

public class A2_main {

    /*
     * Start des Deklarationsbereichs. Achten Sie unbedingt darauf, dass vor jeder
     * Variablendeklaration das Schluesselwort static steht.
     */

    static boolean x = true;
    static boolean y = false;
    static boolean a = true;
    static boolean b = false;
    static boolean c = true;
    static int input = 10;
    
    
    /*
     * Ende des Deklarationsbereichs.
     */
    public static void main(String[] args) {
        /*
         * Start des algorithmischen Bereichs.
         */

        if (input == 10 || input == 11) {
            x = true;
        }else x = false;
        
        
        if (input == 11 || input == 1) {
            y = true;
        }else  y = false;
    
    
    //Variable a
        
    if (x == true && y == true) {
        a = true;
    }else a = false;
        
    //Variable b
    
    if (x = true || (x ^ y)) {      [I][B]// (x ^ y) dead code????? - Ich sollte hier angeben, dass x und y verschieden sind[/B][/I]
        b = true;
    }else b = false;
    
    //Variable c
    
    if (x == true && y == true) {
        c = false;
    
    }else if (x == true && y == false) {
        c = true;
    
    }else if (x == false && y == true) {
        c = false;
        
    }else if (x == false && y == false) {
        c = true;
    
    
    }
        

        
        
        
        /*
         * Hier endet der algorithmische Bereich. Dieser Kommentar und damit alles, was
         * darunter steht, darf verschoben werden (wenn Sie zum Beispiel mehr Zeilen
         * brauchen).
         *
         * Alles, was hinter diesem Kommentar steht, darf nicht veraendert werden!
         *
         */
        
        System.out.println("Wert von x: " + x);
        System.out.println("Wert von y: " + y);
        System.out.println("Wert von a: " + a);
        System.out.println("Wert von b: " + b);
        System.out.println("Wert von c: " + c);

    }

}
 
Du hast da eine Zuweisung und keinen Vergleich:
if (x = true
Dadurch hast du da immer ein true wert und damit wird er nie in den else Zweig kommen können.
 
Du hast da eine Zuweisung und keinen Vergleich:
if (x = true
Dadurch hast du da immer ein true wert und damit wird er nie in den else Zweig kommen können.
Gibt es eine Möglichkeit, solche kleinen Flüchtigkeitsfehler auch automatisch von der IDE beheben zu lassen oder muss man immer selbst drüber schauen?

Was wäre da das Stichwort ?- um sich selbst mal zu informieren
 
Ich bin mir nicht sicher - evtl. wird da schon von der einen oder anderen Entwicklungsumgebung gewarnt.
Auch Tools wie SonarLint könnten interessant sein und da ggf. eine Warnung aussprechen. Das müsste man ggf. testen.
Und dann gibt es noch PMD und SpotBugs und so als statische Codeanalyse Tools.


Generell ist Code so nicht schön. Generell sollte man sich überlegen, was Du da genau hast.

a) Die Variablen brauchst Du nur in der Methode? Warum sind es dann keine lokalen Variablen?
b) Du weist einigen Variablen immer einen Wert zu - wozu eine Initialisierung bei der Deklaration?
c) Die Variable wird nur ein mal gesetzt. Das ist die ganze Intention dahinter. Daher kann man die Variable final machen.

Also nur mal für die Variable x, wie das dann aussehen könnte:
Java:
    public static void main(String[] args) {
        final boolean x = input == 10 || input == 11;

Wenn Du jetzt so einen Fehler machst, dann bekommst Du vom Compiler eine Fehlermeldung. x ist final und du kannst da nichts mehr zuweisen.

Und das sind dann übrigens die Meldungen, die man meistens hat. "Variable xyz kann final sein" oder so ähnlich wird dann gemeckert.

Damit sind wir dann aber bei dem Thema Clean Code angekommen. Es gibt gewisse Best Practices. Und es gibt Tools, die dies unterstützen. Aber oft kann ein Tool nur dann unterstützen, wenn man schon gewisse Dinge gemacht hat. Und einer von ganz vielen Punkten ist dann das final.

Wenn Du lokale Variablen hast, die Du nur einmal setzt: final!
Parameter: final (Das sind halt nur Werte, die in die Methode rein gehen. Da wird nichts mehr geändert!)
...

Das wäre so meine Sichtweise. Was am Anfang schon sehr helfen kann: SonarLint Plugin (Ich nutze es selbst erst seit kurzem in IntelliJ). Das ist ein ganz einfacher und schneller Einstieg ...
 
Ich bin mir nicht sicher - evtl. wird da schon von der einen oder anderen Entwicklungsumgebung gewarnt.
Auch Tools wie SonarLint könnten interessant sein und da ggf. eine Warnung aussprechen. Das müsste man ggf. testen.
Und dann gibt es noch PMD und SpotBugs und so als statische Codeanalyse Tools.


Generell ist Code so nicht schön. Generell sollte man sich überlegen, was Du da genau hast.

a) Die Variablen brauchst Du nur in der Methode? Warum sind es dann keine lokalen Variablen?
b) Du weist einigen Variablen immer einen Wert zu - wozu eine Initialisierung bei der Deklaration?
c) Die Variable wird nur ein mal gesetzt. Das ist die ganze Intention dahinter. Daher kann man die Variable final machen.

Also nur mal für die Variable x, wie das dann aussehen könnte:
Java:
    public static void main(String[] args) {
        final boolean x = input == 10 || input == 11;

Wenn Du jetzt so einen Fehler machst, dann bekommst Du vom Compiler eine Fehlermeldung. x ist final und du kannst da nichts mehr zuweisen.

Und das sind dann übrigens die Meldungen, die man meistens hat. "Variable xyz kann final sein" oder so ähnlich wird dann gemeckert.

Damit sind wir dann aber bei dem Thema Clean Code angekommen. Es gibt gewisse Best Practices. Und es gibt Tools, die dies unterstützen. Aber oft kann ein Tool nur dann unterstützen, wenn man schon gewisse Dinge gemacht hat. Und einer von ganz vielen Punkten ist dann das final.

Wenn Du lokale Variablen hast, die Du nur einmal setzt: final!
Parameter: final (Das sind halt nur Werte, die in die Methode rein gehen. Da wird nichts mehr geändert!)
...

Das wäre so meine Sichtweise. Was am Anfang schon sehr helfen kann: SonarLint Plugin (Ich nutze es selbst erst seit kurzem in IntelliJ). Das ist ein ganz einfacher und schneller Einstieg ...
Das mit der Variablendeklaration ist wohl so eine Eigenart des Programmierkurses in dem ich bin. Meine Aufgaben werden von einem automatisierten Testsystem geprüft und dafür muss man die Variablen wohl in DB deklarieren.

Danke für die Tipps, werde ich mir mal anschauen.
 
Gibt es eine Möglichkeit, solche kleinen Flüchtigkeitsfehler auch automatisch von der IDE beheben zu lassen oder muss man immer selbst drüber schauen?
genaugenommen ist so ein Statement gar nicht notwendig:
Java:
if (x = true || (x ^ y)) {
    ...
}
Ob jetzt mit = oder == geschrieben sei mal egal. x ist eine boolsche Variable if wertet die ja schon aus. Du wertest das aus und stellst wieder nur das Ergebnis ein, welches durch if ausgewertet wird.
Also schreib einfach:
Java:
if (x || (x ^ y)) {
    ...
}
oder:
Java:
if (x) {
    ...
}
So schreiben das nur Anfänger die noch nicht wirklich wissen was sie tun:
Code:
if (x == true) {
    ...
}
Der Compiler optimiert das sowieso weg. Also zumindest hier sollte die Zuweisung überhaupt nicht passieren.
 
Java:
if (x = true || (x ^ y)) {
...
}
Ob jetzt mit = oder == geschrieben sei mal egal.
Das ist nicht egal, bei Verwendung des einfachen Gleichheitszeichens (Zuweisung) wird erst die Zuweisung ausgeführt und dann das Ergebnis, in diesem Fall true, verwendet. Also immer true, weil bei ODER bereits ein true ausreicht für das Ergebnis true.

Wenn eigentlich ein doppeltes Gleichheitszeichen (Vergleich) gemeint war, dann kann man den Term zu

Java:
x || y

umformen, weil bei x == false der rechte Teil ausgewertet wird. Dieser liefert true, wenn y true ist.
 
Wir definieren folgende Eigenschaften:
– E1: x ist wahr (hat also den Wert true).
– E2: y ist wahr.
– E3: die Werte von x und y sind unterschiedlich.
Hierfür würde ich 3 Methoden schreiben:
Java:
private static boolean eigenschaft1(boolean x) {
    return x;
}

private static boolean eigenschaft2(boolean y) {
    return y;
}

private static boolean eigenschaft3(boolean x, boolean y) {
    return x != y;
}
Diese würde ich dann im Code verwenden. Selbstdokumentierend!
 
Nebenbei angemerkt, die Tabelle (!x und !y oder x und !y) ist einfach nur !y: https://math.stackexchange.com/ques...and-not-b-simplification-using-de-morgans-law (das außenstehende ! bitte wegdenken 😉 )

@überlebender In welcher Klasse bist du?
Nur eben geht es um x und y sind unterschiedlich. also x xor y oder eben (!x und y) oder (x und !y)

variable == wert zu schreiben, ist strenggenommen falsch,
Diese Aussage ist aus meiner Sicht schlicht übertrieben. Das Umdrehen ist auch bekannt als "Yoda condition": Yoda conditions - Wikipedia
Und wie man dem Wikipedia Beitrag entnehmen kann, gibt es da sehr wohl auch Gegenargumente - bei java in erster Linie, dass es eben der natürlichen Sprache entgegen steht und damit das Lesen vom Code schlicht erschwert.

Bei so umstrittenen Punkten würde ich daher eher nicht von "strenggenommen falsch" reden.
 
Ich würde da nicht so viel Wert auf Wikipedia legen, wo kann jeder schreiben kann, und Stack Overflow etwas mehr Kompetenz zusprechen...
Auf SO kann auch jeder schreiben …
Und in dem verlinkten SO Beitrag finden sich u.a. auch ein Link zu dem Wikipedia Artikel und eben auch einige relativierende Aussagen.

Daher kann ich deiner Aussage gerade nicht folgen.
 

Zurück
Oben