Erste Schritte Hilfe bei einem kleinen Spiel.

[xp36]

Hallo,
Ich programmiere jetzt seit ein paar Tagen in Java und habe dieses kleine Spiel geschrieben.
Wenn ich dieses Spiel starte, wird immer nur die erste Nachricht wiederholt, ich kann den Fehler leider nicht finden.
Falls jemand mir helfen könnte oder mir einen generellen Verbesserungsvorschlag geben könnte wäre ich sehr dankbar.

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        int min = 1;
        int max = 1000;
        int guess = (min + max) / 2;
        int ergebnis;
        System.out.println("Suchen Sie sich eine Zahl zwischen 1 und 1000 aus.");
        do {
            ergebnis = frage(guess);
        }while(ergebnis != 1);
    }
    public static int frage(int guess) {
        System.out.println("Ist deine Zahl die " + guess + "?");
        System.out.println("=> Ja = 1");
        System.out.println("=> größer als " + guess + " = 2");
        System.out.println("=> kleiner als " + guess +" = 3");
        Scanner sc = new Scanner(System.in);
        int ergebnis = sc.nextInt();
        
        if(ergebnis == 1) {
            System.out.println("Deine Zahl ist also "+guess+".");
            return(1);
        }
        else if(ergebnis == 2) {
            guess = guess + (guess / 2);
            return(2);
        }
        else if(ergebnis == 3) {
            guess = guess / 2;
            return(2);
        }
        else {
            System.out.println("Falsche Angabe!");
            return(2);
        }
    }

}

 

[kneitzel]

Parameter in Java werden alle als Call by Value übergeben. Es wird also nur der Wert der Variable guess übergeben. Der Parameter guess ist davon unabhängig. Wenn Du diesen änderst, dann ändert sich die Variable der main Methode nicht.

Was Du also machen könntest: Die Anpassung von Guess könnte direkt in der Schleife erfolgen und nicht in der Methode. Damit dies geht, gibst Du das ergebnis zurück.

 

[xp36]

Danke

Parameter in Java werden alle als Call by Value übergeben. Es wird also nur der Wert der Variable guess übergeben. Der Parameter guess ist davon unabhängig. Wenn Du diesen änderst, dann ändert sich die Variable der main Methode nicht.

Was Du also machen könntest: Die Anpassung von Guess könnte direkt in der Schleife erfolgen und nicht in der Methode. Damit dies geht, gibst Du das ergebnis zurück.

 

[me-ton]

Für dein Vorhaben bräuchtest du die Eulersche Betafunktion. Die ist allerdings nicht ganz so trivial.

 

[mihe7]

Die Bots waren auch schon mal besser.

 

[me-ton]

Ich bin kein Bot und das war sicher keine Bot Frage... aber wenn man keine Ahnung hat...

 

[kneitzel]

Ja, aber dann erkläre uns doch einfach, wozu der TE die Eulersche Betafunktion Deiner Meinung nach benötigt? Für dieses kleine Spiel ja wohl kaum. Lass uns an Deinem tollen Wissen teilhaben! @mihe7 und ich wollen auch endlich mal was dazu lernen....

Oder bist Du zu sehr damit beschäftigt, neue Accounts zu erstellen? Dieses Hobby von Dir habe ich immer noch nicht verstanden. Wie viele Accounts hast Du denn nun schon? Oder hast Du da selbst keine Übersicht mehr Tobias?

 

[me-ton]

hm falls wieder mal ein Account aus mir nicht erklärlichen Gründen gesperrt wird, erstelle ich einen neuen. Das ist ja auch keine große Sache.

Dennoch bleibt die Wahrheit für manche wie euch oft schwer verdaulich, aber das liegt wiederum nicht an mir.

Ich werde jedenfalls nicht lügen oder mich verstellen, nur um irgendwem zu gefallen. Lügner gibt es schon genug.

 

[Mart]

vllt wäre ein ansatz nicht gebannt zu werden angebracht

 

[Blender3D]

oder mir einen generellen Verbesserungsvorschlag geben könnte wäre ich sehr dankbar.

[CODE lang="java" title="GuessNumber" highlight="7-19"]import java.util.Scanner;

public class GuessNumber {
final static Scanner input = new Scanner(System.in);

public static void main(String[] args) {
Guess guess = new Guess(1, 1000);
int answer = 0;
try {
do {
guess.nextGuess(answer);
guess.showMenu();
answer = inputInt("1,2 oder 3", 1, 3);
} while (answer != Guess.NR_FOUND);
System.out.println("Ich habe <" + guess.getNumber() + "> in " + guess.getCount() + " Versuchen gefunden.");
} catch (IllegalStateException e) { // user didn't give correct answers
System.out.println(e.getMessage());
System.exit(1);
}
}

static int inputInt(String label, int min, int max) {
int value = 0;
boolean ok = false;
do {
System.out.print(label + " >");
try {
value = Integer.parseInt(input.next());
if (value < min || value > max) {
System.out.println("Ein Zahl im Bereich [" + min + "-" + max + "] eingeben!");

} else
ok = true;
} catch (NumberFormatException e) {
System.out.println("Bitte nur ganze Zahlen eingeben!");
}
} while (!ok);
return value;
}

}[/CODE]

[CODE lang="java" title="Guess"]public class Guess {
public static final int NR_FOUND = 1;
public final static int NR_TO_SMALL = 2;
public final static int NR_TO_BIG = 3;

private int min;
private int max;
private int number;
private int count = 0;

public Guess(int min, int max) {
this.min = min;
this.max = max;
}

public int getCount() {
return count;
}

public int getNumber() {
return number;
}

private int getStep(int max, int min) {
return (max - min) / 2;
}

public void nextGuess(int answer) throws IllegalStateException {
if (answer == NR_FOUND)
return;
if (max == min)
throw new IllegalStateException("Sie haben falsche Angaben gemacht!");
count++;
int step = 0;
if (count == 1) { // first try
number = min + getStep(max, min);
return;
}
if (answer == NR_TO_BIG) {
max = number - 1;
step = getStep(number, min);
number = step == 0 ? min : number - step;
return;
}
if (answer == NR_TO_SMALL) {
min = number + 1;
step = getStep(max, number);
number = step == 0 ? max : number + step;
}
}

public void showMenu() {
System.out.println("--------------------------------");
System.out.println("Ist deine Zahl die <" + number + "> ?");
System.out.println("(1) Ja");
System.out.println("(2) Sie ist größer als <" + number + ">");
System.out.println("(3) Sie ist kleiner als <" + number + ">");
System.out.println("--------------------------------");
}

@Override
public String toString() {
return String.format("[%d-%d] + Versuch Nr.%d", min, max, count);
}

}[/CODE]

 

[Mart]

in next guess kannst du alles was in den ifs drin steht in methoden extrahieren um überblick zu bekommen eg

   public void nextGuess(int answer) throws IllegalStateException {
        if (answer == NR_FOUND)
            return;
        if (max == min)
            throw new IllegalStateException("Sie haben falsche Angaben gemacht!");
        count++;
        int step = 0;
   
   
        if (count == 1) { // first try
            countIsFirstTry();
        }
        if (answer == NR_TO_BIG) {
            nrToBig();
        }
        if (answer == NR_TO_SMALL) {
            nrIsToSmall();
        }
    }

die methoden würden dann so ausschauen ( komplett unverändert )

    private void countIsFirstTry()
    {
        number = min + getStep(max, min);
    }

    private void nrToBig()
    {
        int step;
        max = number - 1;
        step = getStep(number, min);
        number = step == 0 ? min : number - step;
    }

    private void nrIsToSmall()
    {
        int step;
        min = number + 1;
        step = getStep(max, number);
        number = step == 0 ? max : number + step;
    }

ich hab nur in meiner ide auf "extract method" geklickt dh es zieht einfach das zeug raus in eine Methode ohne zu verändern, die Returns in deinen 3 ifs bekommst du mit einem switch case weg und dadurch dass ja alles jetzt in einer methode steht schaut der switch auch noch ganz schick aus auch wenn das swithc nur 2 cases hat ( default is auch noch da aber egal ) macht es deinen code übersichtlicher und erweiterbarer

    public void nextGuess(int answer) throws IllegalStateException {
        if (answer == NR_FOUND)
            return;
        if (max == min)
            throw new IllegalStateException("Sie haben falsche Angaben gemacht!");
        count++;
        int step = 0;
   

        if (count == 1) { // first try
            countIsFirstTry();
        }
        switch (answer) {
            case NR_TO_BIG -> nrToBig();
            case NR_TO_SMALL -> nrIsToSmall();
        }
    }

ich hab IMMER noch nichts an deiner Funktionalität in irgendeiner weise geändert ( falls doch war es unbeabsichtigt ) ich nehm das von @Blender3D gerade her

// Klassen Attribut
private PrintStream outPutStream = System.out;

und in showMenu()

    public void showMenu() {
        outPutStream.println("--------------------------------");
        outPutStream.println("Ist deine Zahl die <" + number + "> ?");
        outPutStream.println("(1) Ja");
        outPutStream.println("(2) Sie ist größer als <" + number + ">");
        outPutStream.println("(3) Sie ist kleiner als <" + number + ">");
        outPutStream.println("--------------------------------");
    }

muss das sein ? nein muss nicht sein
ist es gut das zu tun? ja kann vorteile haben
du änderst deinen PrintStream um im nachhinein auf irgendwas was in eine Datei Schreibt zb dann musst du es nur noch in dem Klassen Attribut ändern und nicht mehr 5 mal => unvirsellerer Code
vermiede Duplikation wo es geht


das

if (answer == NR_FOUND)

kannst du "vllt" in dein Switch Case einbauen .. möchte nichts an der logik im moment ändern
dann hättest du alle ifs mit "answer == irgendwas" in deinem Switch aber das ist dir überlassen

ich würde es wenn möglich so machen ( das funtkoiniert so noch nicht du kannst es aber so umbauen wenn du magst oder vllt sogar noch besser da noch in der "nextGuess" logik drinnen ist + fehlerbehandlung )

   public void nextGuess(int answer) throws IllegalStateException {
        if (max == min)
            throw new IllegalStateException("Sie haben falsche Angaben gemacht!");
        count++;
 
        int step = 0;
   

        if (count == 1) { // first try
            countIsFirstTry();
        }
       privateStep(answer)

    }
    private void privateStep(int answer){
                switch (answer) {
            case NR_FOUND -> nrFound(); // gibts noch nicht !
            case NR_TO_BIG -> nrToBig();
            case NR_TO_SMALL -> nrIsToSmall();
        }
    }

was hier "auffallen sollte"
1. die Fehler behandlung wird in der Public mehtode gemacht und dann die "fall" behandlung und logik wird in der Private gemacht -> trennung von fehler und logik
2. dein Kommentar first Try wird unnötig wenn du die Methode gut benennst und ich habe sie nahc deinem kommentar benannt -> kommentar fällt weg
gute namen killen einfach die meisten kommentare was "guter Stil" ist, weil code lügt nicht, kommentare schon !


so würde ich den Code "refactoren" ... ich habe nur den Code Umsortiert und namen geändert KEINERLEI funktionalität die ich geändert habe.. ich weis ja nicht was du noch rum coden willst

Mit dem Jetzt ist es "viel" schwerer den Code zu zerschießen weil du einfacher debuggen kansnt ( der stack trace sagt dir wo dir deine Sache abgeschmiert ist )
MIt dem ist es einfacher Code zu erweitern ( du schreibst das zeug nicht in die IFs wie du es hattest sondern in die Mehtoden ) dann musst nur zu den methoden hupfen und da was ändern

wahrschienlich krieg ich eh wieder kritik von irgendwen dass es icht so passt aber ich mag code der idioten sicher ist und an einem switch case und 3 methoden sollte sich doch jeder zurecht finden ( das ist auch wichtig )



Du könntest für dei Konstanten auch enums hernehmen aber die sind bei dem refactoren ohne funktionalität zu ändern schwer da man bei dem was ich versucht habe zu JEDEM Zeitpunkt das gleiche ergebnis zu bekommen wei wenn ich den Code von dir laufen lassen hätte
wenn ich enums einbaue ist der Code kurze zeit nicht testbar -> bei einem fehler weis ich nicht warum es nicht mehr funtkioniert ich hab keine Ahnung von deiner funktionalität deswegen konnte ich sie auch nicht ändern

PS: die namen sind keinerlei zwang und es 4 in der früh .. die methoden namen sind ja nicht mal konsistent .. wie zb nristosmall und nrtobig.. einmal ohne is und einmal mit.. aber egal

 

[kneitzel]

hm falls wieder mal ein Account aus mir nicht erklärlichen Gründen gesperrt wird, erstelle ich einen neuen. Das ist ja auch keine große Sache.

Dennoch bleibt die Wahrheit für manche wie euch oft schwer verdaulich, aber das liegt wiederum nicht an mir.

Ich werde jedenfalls nicht lügen oder mich verstellen, nur um irgendwem zu gefallen. Lügner gibt es schon genug.

Ich denke, Du hast da die Kernproblematik sehr gut aufgebracht:

Für Dich geht es um Wahrheiten oder gar um "die Wahrheit". Für mich (und auch viele Andere hier) geht es schlicht um Thesen oder Meinungen. Man kann beliebige Meinungen vertreten oder als Thesen in den Raum stellen. Und da sind dann Argumente wichtig. Und dann ist auch wichtig, dass man seine eigene Meinung nicht als "die Wahrheit" ansieht und dann alles andere falsch ist. Das ist ein schwarz / weiss denken, das einfach - entschuldige die harte Ausdrucksweise - Unsinn ist.

Es geht einfach um diverse Thesen und die entsprechenden Argumente. Und dann kann sich jeder überlegen, welche Argumente ihn überzeugen oder auch einfach: Womit man besser klar kommt.

Das aber nur am Rande - ich habe es ja regelmäßig Dir gegenüber erwähnt: meinen kannst Du, was Du willst. Das ist für mich in Ordnung. Alles, was ich da machen kann ist maximal Argumente bringen und - falls Du mal auch ein Argument bringst - auf dieses eingehen.

Ich denke, dass damit das Thema erledigt ist. Nicht, dass es nicht lustig wäre, aber jetzt sind im Thread doch noch andere interessante Punkte aufgekommen, die für den TE wichtig sein müssten.

 

[kneitzel]

Zu dem Vorschlag von @Blender3D vielleicht noch ein paar Worte da ich fürchte, dass nur der Code etwas viel auf einmal ist, weil Du noch an anderen Grundlagen bist und noch nicht objektorientiert arbeitest:
a) Ein wichtiger Punkt, den er verfolgt: Objektorientierung. Er erstellt eine Klasse, von der er dann Instanzen erzeugt. Diese Instanzen können dann einen gewissen Status in sich halten, der veränderlich ist. Das ist dann in seinem Code die Klasse Guess. Diese hat einen Zustand wie min, max, ....
b) Aufteilung in mehrere Methoden. Das ist auch eine standard Vorgehensweise, die man ständig anwendet.

Ich werde nachher noch etwas tiefer auf diese beiden Punkte eingehen, da diese eine wichtige Grundlage sind. Jetzt leider reicht die Zeit nicht aus, da ich jetzt erst einmal ins Büro fahren muss.

@Mart Du hast da einen sehr schönen Post geschrieben - ich würde das dann nachher aber auch noch etwas vertiefen - und Dir vielleicht ein paar interessante Punkte aufzeigen, die Du so noch nicht gesehen hast (und die sich auch um die a) und b) oben drehen werden.

Sorry, dass dies so kurz ausfällt, aber ich werde dies später noch vertiefen.

 

[xp36]

Ich habe es jetzt einfach so gelöst:

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        
        int max = 1000;
        int min = 1;
        int temp;
        
        System.out.println("Suchen sie sich eine Zahl zwischen 1 und 1000 aus.");
        
        Scanner sc = new Scanner(System.in);
        
        int guess = (max + min) / 2;
        
        do {
            System.out.println("Ist die gesuchte Zahl die " + guess + "?");
            
            System.out.println("Ja => 1");
            System.out.println("Die Zahl ist kleiner => 2");
            System.out.println("Die Zahl ist größer => 3");
            temp = sc.nextInt();
            
            if(temp == 1) {
                System.out.println("Yeah, ich habe gewonnen!");
            }
            else if(temp == 2) {
                max = guess;
                guess = nextGuess(guess, max, min);
            }
            else if(temp == 3) {
                min = guess;
                guess = nextGuess(guess, max, min);
            }
            else {
                System.out.println("Falsche Eingabe");
            }
            
        } while(temp != 1);

    }
    
    
    public static int nextGuess(int guess, int max, int min) {
        guess = (max + min) / 2;
        return guess;
    }

}

 

[kneitzel]

Eine kleine Rückmeldung zu dem Code:

    public static int nextGuess(int guess, int max, int min) {
        guess = (max + min) / 2;
        return guess;
    }

Die Methode nutzt den Parameter guess nicht. Da der Parameter nicht genutzt wird, sollte man diesen auch einfach entfernen:

    public static int nextGuess(int max, int min) {
        int guess = (max + min) / 2;
        return guess;
    }

Damit existiert der Parameter guess nicht mehr und guess ist jetzt eine lokale Variable.

 

[kneitzel]

Die vesprochene ausführliche Antwort:
a) objektorientierte Entwicklung
Bei der objektorientierten Entwicklung wird etwas aufgebaut, das (natürlich stark vereinfacht und abstrakter) der realen Welt näher kommt: diverse Objekte interagieren zusammen. Dabei haben die Objekte einen Zustand und ein Verhalten. Ein Objekt kann dabei andere Objekte enthalten. Dies hat den Vorteil, dass in einem Programm eine Welt aufgebaut werden kann, die unserer gewohnten Sichtweise näher kommt. Dadurch wird Code deutlich lesbarer.

Somit sollte man sich bei einer Entwicklung immer überlegen, was man denn genau für Elemente hat und wie diese miteinander interagieren. Bei so einem Spiel wäre also denkbar:

- Man hat einen Spieler. Hier wären dann Dinge zu finden, die den Spieler betreffen wie Eingabe / Ausgabe.
- Man hat einen Ratevorgang.
- Man hat das eigentliche Spiel.

Wie diese Dinge miteinander interagieren lässt sich gut zeigen:
a) Erst einmal brauchen wir ein neues Spiel. Und dieses starten wir.
b) Der Spieler wird gebeten, sich eine Zahl zwischen 1 und 1000 auszusuchen und zu merken.
c) Ein Ratevorgang wird erstellt für eine Zahl zwischen 1 und 1000.
d) So lange die Zahl nicht erraten wurde
d.1) die nächste Zahl wird geraten.
d.2) Der Spieler wird gebeten, die geratene Zahl zu bewerten.
d.3) Je nach Ergebnis wird verändert: Zahl erraten / obere Grenze anpassen / untere Grenze anpassen

Somit haben wir den Algorithmus erst einmal beschrieben. Das können wir nun so umsetzen.
a) wird dann sowas wie Spiel spiel = new Spiel(); spiel.start(); ==> das landet in der main
b) in start() wird dann das Spieler gebeten. Also etwas wie spieler.getNewRandomNumber oder so. Das Spieler objekt muss aber natürlich erzeugt worden sein, also wird Spiel ein Spieler haben (instanzvariable) und die wird im Konstruktor initialisiert!
c) Ratevorgang wird erstellt
d) boolean zahlErraten = false; while (!zahlErraten) {
d.1) int gerateneZahl = ratevorgang.getNextGuess();
d.2) int result = spieler.evaluateGuess(gerateneZahl);
d.3) switch (result) .....

Das ist dann ein erster schneller Start, wie man sowas objektorientiert aufbauen kann.

b) Aufteilung in mehrere Methoden:
Code sollte immer lesbar sein. Ein guter Weg ist eine Unterteilung in mehrere Methoden. Der Methodenname beschreibt dabei genau, was die Methode macht (und die Methode macht dann auch nur das!). Damit ist die Signatur der Methode wie ein kleiner Kommentar:

public void tueEtwas()

ist dann beim Lesen wie ein Kommentar:
// tue etwas

Zusätzlich bekommen man noch die Ausgabe (hier void, also nichts) und eine Eingabe (auch hier dann nichts). Das hilft sehr.

Hinzu kommen dann viele Nebeneffekte:
- Leichtere Wiederverwendung (Eine fertiges LEGO Haus als Ganzes ist und bleibt ein Lego Haus. Aber hat man es als viele Bauteile: Dann kann man die Bauteile auch anders verwenden.)
- Leichtere Testbarkeit - Jede Methode macht an sich relativ wenig. Damit sind die zu testenden Fälle übersichtlich und in der Regel auch schnell und einfach durchzuführen.
- Kein doppelte Code

Dann bin ich noch nicht auf @Mart eingegangen. Hier wurde vorgeschlagen, Dinge aufzuteilen und dies dann in private Methoden zu packen. Das ist vom Ansatz her erst einmal nicht falsch. Aber es gibt hier dann gewisse Probleme: Das, was da gebaut wird, ist nur innerhalb der Klasse nutzbar. Dies bedeutet:
- nicht durch Tests von außen testbar
- nicht wiederverwendbar (von außerhalb der Klasse)

Das ist natürlich nicht so schön. Daher ist die Frage: Wie kann ich etwas aufteilen und behalte dennoch die Testbarkeit oder Wiederverwendbarkeit?

Wir haben das eigentlich in Punkt A schon erläutert. Aber schauen wir uns das im realen Leben an:
Es gibt ein komplexes Produkt - z.B. ein Auto. Dieses bekommt ein einfaches Interface nach außen (also public Methoden): Mann kann lenken, schalten, Gas geben, ....
Aber man will die ganze Komplexität nicht in den Methoden abdecken. Das wird viel zu groß. Man kann es in private Methoden untergliedern, aber das wäre dann alles nicht so testbar....
Die Lösung: Die Komplexität unterteilt man einfach in mehrere Klassen. Das ist dann wie in der realen Welt:
Wenn ein Auto gebaut wird, dann werden da viele komplexe Bauteile verwendet. Z.B. ein Motor. "Gas geben" wird dann ganz einfach und man braucht hier keine private Methoden. Und das, was man da dann verwendet, das hat dann eigene Tests. So ein Motor ist getestet. Darauf kann man dann vertrauen.
Also statt private Methoden einzuführen, wird eher die Klassenhirarchie verändert und es kommen neue Klassen hinzu. Diese bilden dann Komplexität ab. Und diese neuen Klassen sind dann meist auch universeller. Den Motor kann ich auch in ein Schiff einbauen ... oder in ein Stromgenerator oder .....
Und da der Motor klare Aussenschnittstellen hat, kann das Verhalten des Motors auch getestet werden.

Bei dem Beispiel erkennt man das dann daran, dass ich in a) gleich mehrere Objekte versucht habe zu identifizieren.

Edit: Überschriften der Blöcke fett gemacht.

 

[Mart]

Hier wurde vorgeschlagen, Dinge aufzuteilen und dies dann in private Methoden zu packen. Das ist vom Ansatz her erst einmal nicht falsch. Aber es gibt hier dann gewisse Probleme: Das, was da gebaut wird, ist nur innerhalb der Klasse nutzbar. Dies bedeutet:
- nicht durch Tests von außen testbar
- nicht wiederverwendbar (von außerhalb der Klasse)

Das ist natürlich nicht so schön. Daher ist die Frage: Wie kann ich etwas aufteilen und behalte dennoch die Testbarkeit oder Wiederverwendbarkeit?

Wir haben das eigentlich in Punkt A schon erläutert. Aber schauen wir uns das im realen Leben an:
Es gibt ein komplexes Produkt - z.B. ein Auto. Dieses bekommt ein einfaches Interface nach außen (also public Methoden): Mann kann lenken, schalten, Gas geben, ....
Aber man will die ganze Komplexität nicht in den Methoden abdecken. Das wird viel zu groß. Man kann es in private Methoden untergliedern, aber das wäre dann alles nicht so testbar....
Die Lösung: Die Komplexität unterteilt man einfach in mehrere Klassen. Das ist dann wie in der realen Welt:
Wenn ein Auto gebaut wird, dann werden da viele komplexe Bauteile verwendet. Z.B. ein Motor. "Gas geben" wird dann ganz einfach und man braucht hier keine private Methoden. Und das, was man da dann verwendet, das hat dann eigene Tests. So ein Motor ist getestet. Darauf kann man dann vertrauen.
Also statt private Methoden einzuführen, wird eher die Klassenhirarchie verändert und es kommen neue Klassen hinzu. Diese bilden dann Komplexität ab. Und diese neuen Klassen sind dann meist auch universeller. Den Motor kann ich auch in ein Schiff einbauen ... oder in ein Stromgenerator oder .....
Und da der Motor klare Aussenschnittstellen hat, kann das Verhalten des Motors auch getestet werden.

ich konnte nicht entscheiden was in eine Extra klasse gehört ich habe von einem vortrag von 2012 auf youtube die sachen angewandt die funktionieren auch größtenteils immer

ich habe aber nur die ersten schritte gemacht dh 0 den Code überhaupt angesehen ( ich weis nicht was der tut ) sondern nur refactored auf basis von namen und das was mich gleich anhupft ( wie ifs und schleifen ) das refactoring in eigene klassen hab ich gar nicht gemacht da war ich auch schon zu müde

 

[kneitzel]

Dein Ansatz war auch nicht falsch! Das war nicht als Widerspruch sonern als Ergänzung / Vertiefung gedacht. Wenn Du mit Unit Tests arbeiten willst, dann wird dies aus meiner Sicht halt wichtig.

 

[Mart]

. Wenn Du mit Unit Tests arbeiten willst

habe ich noch nicht getan ich lese halt die unit test sachen manchmal mit im forum aber soweit bin ich noch nicht


EDIT: den vortrag kann ich auch für den TE empfehlen .. ich weis auch nicht was der code in dem C# projekt macht was da refactored wird aber die erklären es so dass es komplett unwichtig ist was der code tut, und "alles" was man in c# kann für refactoring sollte auch in java möglich sein diese sind ja doch schon sehr nahe zusammen einzige waas "nicht" soooo ist ist dass es in java keine Defaultparameter gibt dh man muss sich einen Builder bauen ... aber das ist eines worüber ich öfter stolper der rest sind schon spezielle ausnahmen

 

[Mart]

um noch ein live beispiel anzuführen ich habe das auch so gemacht in meinen projekt.. dass es view heißt ist noch veraltet hab ich noch nicht geändert


alles in der for schleife ist verbose ( wort lastig ) du brauchst keinerlei ahnung was die methoden machen du wirst es trotzdem verstehen was passiert

wenn du wissen musst was direkt passiert schaust du einfach in den Methoden nach

    public static void connect(final Object view, final Object bindTo, final Class<? extends Annotation> annotation)
    {
        final var viewFields = view.getClass().getDeclaredFields();

        for (Field viewField : viewFields)
        {
            final FieldHandler<?> fieldHandler = new FieldHandler<>(viewField, view);

            if (fieldHandler.isAnnotationPresent(annotation))
            {
                fieldHandler.bindProperties(bindTo);
            }
        }
    }