Java Backend

[Maxel33]

Hallo,

ich befasse mich nun schon seit längeren mit der Programmiersprache Java. Ich nutze dabei die Tutorial-Reihe "Java Leicht gemacht" von Christian Gesty auf Udemy. Ich bin jetzt beim Sortieren von Daten mit Comperator. Jedoch folgen darauf noch Java Lambdas, Innere und Anonyme Klassen, Threads und ein Exception Kurs. Ich habe nun schon soo viel Theorie in mich hinein gefressen und möchte nun auch langsam mal etwas selbst gestalten. Am liebsten Backend mäßig. Doch ich finde kaum etwas, was ich selbst machen kann bzw. überhaupt kann. Ich fühle mich irgendwie ein wenig blöd, da ich noch nichts wirklich alleine kann. Es heißt doch aber "learning by doing". Man verliert auch schnell den Spaß bei so viel Theorie ohne Bezug zur Praxis. Auf YouTube gibt es auch kaum Projekte etc.

Es wäre ultra nett, wenn ihr mir helfen könntet.

Liebe Grüße

 

[Barista]

Früher gab es bei JEE eine Petshop-Beispiel-App, Spring hat auch so was in der Richtung.

 

[mihe7]

Schau mal unter https://ccd-school.de/coding-dojo/ (insbesondere bei Application und Architecture Katas, da sollte doch was dabei sein).

 

[M.L.]

Weiterhin ist Backend-Programmierung im Kern "nur" die interne (Weiter)Verarbeitung von Daten jedweder Art (setzt also weder den Einsatz von Frontends inkl. Controllern oder Datenbanken voraus). Der genannte Kurs ist für Backend aber weniger geeignet, obwohl Themen wie (z.B.) Threads, Exceptions, Datenstrukturen auch hier relevant sind.

 

[Thallius]

Wo ist denn dein Problem? Fällt Dir nichts ein? Denk Dir irgendeine Software aus die Du gerne für Dich hättest und schreib sie dir. Am besten irgendwas das sich mit einem deiner Hobbies befasst. Ich habe damals ein Flugbuch fürs Gleitschirmfliegen geschrieben und eine App die meine gelesenen Bücher verwaltet. Sowas in der Art wird Dir ja wohl auch einfallen. Und wenn man es dann selber benutzt, dann macht es auch Spaß.
Wichtig ist nur, das die erste Version erstmal wirklich sehr Basic sein sollte. Fang nicht gleich an 1 Million Features zu überlegen die die Software haben muss sonst Verzweifelt man schnell

 

[Maxel33]

Erstmal alles vielen Dank für die Anregungen und Ideen.

 

[Maxel33]

Wo ist denn dein Problem? Fällt Dir nichts ein? Denk Dir irgendeine Software aus die Du gerne für Dich hättest und schreib sie dir. Am besten irgendwas das sich mit einem deiner Hobbies befasst. Ich habe damals ein Flugbuch fürs Gleitschirmfliegen geschrieben und eine App die meine gelesenen Bücher verwaltet. Sowas in der Art wird Dir ja wohl auch einfallen. Und wenn man es dann selber benutzt, dann macht es auch Spaß.
Wichtig ist nur, das die erste Version erstmal wirklich sehr Basic sein sollte. Fang nicht gleich an 1 Million Features zu überlegen die die Software haben muss sonst Verzweifelt man schnell

Dankeschön für diese Antwort. Das Problem besteht darin, dass ich nicht weiß, wie ich eine Oberfläche erstellen kann und diese mit Java verknüpfe. Muss ich dort andere Programme nutzen? Hast du vielleicht einige Quellen zur Hand, die mir da helfen können?

 

[Jw456]

Hallo schaue dir doch mal Java Swing an.

https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwiA0e61nqHyAhXKhf0HHb6EAiIQFnoECAYQAw&url=http%3A%2F%2Fwww.mobile.ifi.lmu.de%2Fwp-content%2Fuploads%2Flehrveranstaltungen%2Fjavakurs-fuer-fortgeschrittene-sose18%2F03_swing.pdf&usg=AOvVaw1olyTn2b9ipsPLA6waCCjJ

Oder JavaFX .

Die Anfänge von JavaFX sollten auch in deinem Kurs sein , laut Inhalts Verzeichnis.

 

[Hag2bard]

Ein offenbar langweiliges und simples Programm, wie z.b. eine Einkaufsliste, eine To-Do Liste oder ein Kalender kann, wenn man es man es dann mal tatsächlich zu seinem eigenem Projekt macht so umfangreich sein, dass man wirklich viel dabei lernt. Es werden Probleme auftauchen, an die man nicht gedacht hat. Die Komplexität ist doch höher als erwartet, was dich zwingt sauber zu programmieren.
Wenn du ein Reportair an Programmen geschrieben hast, kannst du alle in einer Benutzeroberfläche vereinen.

 

[Thallius]

Du kannst natürlich das Frontend ebenso in Java machen. Dann hast du halt eine Client App die sich per HTTPRequest mit dem Backend verbindet.
Du kannst, wenn Du Spaß dran hast auch HTML und Javascript nehmen. Es ist jetzt kein Hexenwerk mit HTML ein Formular zu basteln, dass du dann per AJAX an dein Backend schickst und ebenso mit AJAX Daten vom Backend wieder abholst. Dann kannst du die App halt von jedem Rechner aus im Browser benutzen. Ist halt schöner.

Ich würde echt klein anfangen. Mach eine Springboot App die nichts weiter macht als mit einem Request irgendwelche Daten in JSON zu empfangen und in eine Datenbank zu schreiben.
Dann nimmst du z.B. Postman und schickst einfach mal Daten hin und liest sie wieder aus. Dabei lernst du wie sowas alles funktioniert. Danach kannst du dann statt Postman ein richtiges Frontend bauen.

 

[M.L.]

Oberfläche

JavaFX *könnte* eine separate Installation verlangen (kommt auf das verwendete JDK an). Daneben sollte man erstmal _ohne_ Oberfläche (oder GUI Builder) anfangen, da solche Werkzeuge längerfristige Aspekte wie Erweiterbarkeit oder Wartbarkeit aussen vor lassen (könnten) Für später: https://www.java-forum.org/thema/wi...vernuenftige-klassen-ein.185926/#post-1197005

 

[mihe7]

Das Problem besteht darin, dass ich nicht weiß, wie ich eine Oberfläche erstellen kann und diese mit Java verknüpfe. Muss ich dort andere Programme nutzen? Hast du vielleicht einige Quellen zur Hand, die mir da helfen können?

@Maxel33, ich würde Dir vorschlagen, ein einfaches Projekt zu wählen und dieses ggf. mit Unterstützung aus dem Forum durchzuziehen. Wenn Du kein Thema hast, könntest Du einfach mal https://ccd-school.de/coding-dojo/application-katas/haushaltsbuch/ nehmen. Die Bedienung über die Befehlszeile kannst Du dabei erstmal vergessen (s. u.), es geht erstmal um das Haushaltsbuch selbst.

Versuche, ein objektorientiertes Modell dafür (oder für ein von Dir gewähltes Thema) zu entwerfen und wenn Du das hast, gibst Du Bescheid, ob Du

• Frontend, Backend oder vollständige Anwendung
• Desktop-, Web- oder mobile Anwendung

entwickeln willst. Dann kann man besser darauf eingehen.

 

[Maxel33]

Ein offenbar langweiliges und simples Programm, wie z.b. eine Einkaufsliste, eine To-Do Liste oder ein Kalender kann, wenn man es man es dann mal tatsächlich zu seinem eigenem Projekt macht so umfangreich sein, dass man wirklich viel dabei lernt. Es werden Probleme auftauchen, an die man nicht gedacht hat. Die Komplexität ist doch höher als erwartet, was dich zwingt sauber zu programmieren.
Wenn du ein Reportair an Programmen geschrieben hast, kannst du alle in einer Benutzeroberfläche vereinen.

Heyy, dankeschön für deine Antwort. Du meinst sicherlich, dass ich das Programm erstmal in der Konsole schreiben soll?

Liebe Grüße

 

[Maxel33]

@Maxel33, ich würde Dir vorschlagen, ein einfaches Projekt zu wählen und dieses ggf. mit Unterstützung aus dem Forum durchzuziehen. Wenn Du kein Thema hast, könntest Du einfach mal https://ccd-school.de/coding-dojo/application-katas/haushaltsbuch/ nehmen. Die Bedienung über die Befehlszeile kannst Du dabei erstmal vergessen (s. u.), es geht erstmal um das Haushaltsbuch selbst.

Versuche, ein objektorientiertes Modell dafür (oder für ein von Dir gewähltes Thema) zu entwerfen und wenn Du das hast, gibst Du Bescheid, ob Du

• Frontend, Backend oder vollständige Anwendung
• Desktop-, Web- oder mobile Anwendung

entwickeln willst. Dann kann man besser darauf eingehen.

Okay Dankeschön. So werde ich es machen. Wenn ich fertig bin, werde ich hier einmal den Code schicken.

Liebe Grüße

Maxi

 

[Maxel33]

Habe mich jetzt für ein TicTacToe in der Konsole entschieden. Nun habe ich schon das Spielfeld. Doch wie schafft man es die Eingabe des Users in die dafür vorgesehene Spalte des Arrays einzutragen.

Packe den Quellcode hinzu:

public class Main {

    public static void main(String[] args) {
       
        String[][] board = new String[3][3];
        board[0][0] = "  ";
        board[0][1] = "  ";
        board[0][2] = "  ";
        board[1][0] = "  ";
        board[1][1] = "  ";
        board[1][2] = "  ";
        board[2][0] = "  ";
        board[2][1] = "  ";
        board[2][2] = "  ";
       
        System.out.println(board[0][0] + "|" + board[0][1] + "|" + board[0][2]);
        System.out.println("-----");
        System.out.println(board[1][0] + "|" + board[1][1] + "|" + board[1][2]);
        System.out.println("-----");
        System.out.println(board[2][0] + "|" + board[2][1] + "|" + board[2][2]);
       
       
       


    }

}

 

[mrBrown]

In dem Java-Kurs, den du genannt hast, kam da schon was zu Objekt-Orientiertem Design (oder ähnlichem) vor?

 

[Maxel33]

In dem Java-Kurs, den du genannt hast, kam da schon was zu Objekt-Orientiertem Design (oder ähnlichem) vor?

Nein, nur zur OOP allgemein.

 

[kneitzel]

Paar Anmerkungen zu dem Code:

a) Versuche es doch bitte, objektorientiert anzugehen. Du hast also ein Board, welches dann Felder hat. Was für Werte kann denn ein Feld haben? Das ist doch nicht wirklich ein String. Ein Feld kann doch nur einen von 3 Werten annehmen - sowas klingt nach enum.

b) Deine Code-Zeilen gleichen sich sehr stark. Das ist in der Regel ein Zeichen für eine Doppelung:

        board[0][0] = "  ";
        board[0][1] = "  ";
        board[0][2] = "  ";

Ist also immer das Gleiche, nur eben dass da an einer Stelle von 0 bis 2 durchgezählt wird -> Schleife.
Das Gleiche dann noch mit den Blöcken - Du hast 3 Mal den Block und da wird wieder von 0 bis 2 gezählt ...

c) Wenn Du die Ausgabe dann auch separat hast, dann kannst Du den eigentlichen Spielablauf angehen. Das wäre dann aber auch wieder eine eigene Klasse. TicTacToe oder so. Da kannst Du dann die Abläufe entwickeln:
- Am Anfang wird ein Spielfeld erzeugt.
- Dann werden die Spieler abwechelnd nach einem Feld gefragt, verifiziert, ob die Auswahl gültig ist u.s.w.

 

[Maxel33]

Paar Anmerkungen zu dem Code:

a) Versuche es doch bitte, objektorientiert anzugehen. Du hast also ein Board, welches dann Felder hat. Was für Werte kann denn ein Feld haben? Das ist doch nicht wirklich ein String. Ein Feld kann doch nur einen von 3 Werten annehmen - sowas klingt nach enum.

b) Deine Code-Zeilen gleichen sich sehr stark. Das ist in der Regel ein Zeichen für eine Doppelung:

        board[0][0] = "  ";
        board[0][1] = "  ";
        board[0][2] = "  ";

Ist also immer das Gleiche, nur eben dass da an einer Stelle von 0 bis 2 durchgezählt wird -> Schleife.
Das Gleiche dann noch mit den Blöcken - Du hast 3 Mal den Block und da wird wieder von 0 bis 2 gezählt ...

c) Wenn Du die Ausgabe dann auch separat hast, dann kannst Du den eigentlichen Spielablauf angehen. Das wäre dann aber auch wieder eine eigene Klasse. TicTacToe oder so. Da kannst Du dann die Abläufe entwickeln:
- Am Anfang wird ein Spielfeld erzeugt.
- Dann werden die Spieler abwechelnd nach einem Feld gefragt, verifiziert, ob die Auswahl gültig ist u.s.w.

Ich habe es jetzt versucht mit einem enum. Wusste zuvor nicht, was das ist & auch jetzt funktioniert es nicht wirklich. Was mache ich falsch?

public class Main {

    public static void main(String[] args) {
        
        Eingabe[] array1 = new Eingabe[3];
        
        for(int i = 0; i < array1.length; i++) {
            System.out.print(array1[i]);
            if(i < 2) {
                System.out.print("|");
            }
        }
        


    }

}

Hier das Enum ->

public enum Eingabe {
    O,
    X,
    Nichts
 

}

 

[kneitzel]

Am Anfang ist die objektorientierte Herangehensweise bestimmt schwer. Daher einfach einmal das, was ich oben geschrieben habe einmal etwas verdeutlicht mit Code (Im Forum geschrieben, daher ohne jede Syntax Überprüfung und so!):

Du hast also ein Board, welches dann Felder hat.

Das wäre also dann etwas wie:

public class Board {
    private Field[][] fields = new Field[3][3];
}

Ein Feld kann doch nur einen von 3 Werten annehmen - sowas klingt nach enum.

public enum Field {
    FIRST_PLAYER,
    SECOND_PLAYER,
    EMPTY;
}

Ist also immer das Gleiche, nur eben dass da an einer Stelle von 0 bis 2 durchgezählt wird -> Schleife.

Das kann man etwas aufzeigen bei der Klasse Board:

public class Board {
    private Field[][] fields = new Field[3][3];

    public Board() {
        for (int row = 0; row < fields.length; row++) {
            for (int column = 0; column < fields[row].length; column++) {
                fields[row][column] = Field.EMPTY;
            }
        }
    }
}

c) Wenn Du die Ausgabe dann auch separat hast, dann kannst Du den eigentlichen Spielablauf angehen.

Also erst einmal die Ausgabe - das kann man in Board mit rein nehmen (also sowas wie eine print Methode), oder man macht es in eine eigene Klasse (Overkill am Anfang aber das, was später üblich wird).

Also geben wir Board noch eine print() Methode:

public void print() {
    for(int row = 0; row < fields.length; row++) {
        for (int column = 0; column < fields[row].length; column++) {
            System.out.print(" ");
            switch(fields[row][column]) {
                case FIRST_PLAYER:
                    System.out.print("X");
                    break;
                case SECOND_PLAYER:
                    System.out.print("O");
                    break;
                case EMPTY:
                    System.out.print(" ");
                    break;
            }
            System.out.print(" ");
        }
        System.out.println();
    }
}

Das wäre dann aber auch wieder eine eigene Klasse. TicTacToe oder so. Da kannst Du dann die Abläufe entwickeln:
- Am Anfang wird ein Spielfeld erzeugt.
- Dann werden die Spieler abwechelnd nach einem Feld gefragt, verifiziert, ob die Auswahl gültig ist u.s.w.

Also Klasse TicTacToe mit erstem Anfang:

public class TicTacToe {
    private Board board = new Board();
    int player = 1;
    public void run() {
        while (!board.finished()) {
            getMoveOfPlayer();
            if (playerWon()) {
                printWinMessage()
            } else if (!board.movesAvailable()) {
                printGameEndedInTie()
            } else {
                nextPlayer();
            }
        }
    }
}

Das ist einfach mal eine Logik so runter geschrieben. Du erkennst ganz viele Methoden, die noch nicht geschrieben wurden. Aber so in der Art sollte es dann immer weiter herunter gebrochen werden.

 

[Jw456]

Dein zweidimensionales Array war eigentlich schon richtig nur eben nicht vom Datentyp String dafür hast du doch das Enum erstellt.

Beim zuweisen also erst mall alle Felder „lehr“ wirst du zwei verschachtelte for schleifen brauchen.

Edit ok zu langsam

 

[Maxel33]

Ich war bisher so weit:

eigentlich müsste doch der Anfang vollkommen ok sein, oder?

public class Spielfeld {
    
    Eingabe[][] array1 = new Eingabe[3][3];
    
    
    public Spielfeld() {
    for(int i = 0; i < array1.length; i++) {
        for(int j = 0; j < array1.length;j++) {
        array1[i][j] = Eingabe.EMPTY;
        System.out.print(array1[i][j]);
        if(j < 2) {
            System.out.print("|");
        }
    }
        System.out.println();
}
}
    

}

Dabei ist Eingabe das enum.

Kann ich so weitermachen?

 

[Jw456]

Überlege mal warum kneinzel eine print Methode gemacht hat . Weil du die viel brauchen wirst und zwar nach jeder Eingabe wirst du das Spielfeld neu Ausgeben müssen.

auch der Bezeichner Eingabe ist nicht sinnvoll. Halte dich an das was Kneizel dir gegeben hat.

 

[Maxel33]

Überlege mal warum kneinzel eine print Methode gemacht hat . Weil du die viel brauchen wirst und zwar nach jeder Eingabe wirst du das Spielfeld neu Ausgeben müssen.

auch der Bezeichner Eingabe ist nicht sinnvoll. Halte dich an das was Kneizel dir gegeben hat.

Ich habe das ja in der Spielfeld Klasse & nicht in der Main

 

[Jw456]

Kneizel wollte dir zeigen das es besser ist das löschen des Board und ausgeben anzeigen des Board auf zwei Methoden zu verteilen.

so wie du es machen willst wirst du immer wider den gleichen Code schreiben bei jeder ausgabe

 

[mihe7]

Habe mich jetzt für ein TicTacToe in der Konsole entschieden.

Eine sehr gute Entscheidung: das ist relativ einfach und man kann in Richtung OO gehen. Ihr seid ja eh schon gut dabei...

 

[kneitzel]

Ich war bisher so weit:

eigentlich müsste doch der Anfang vollkommen ok sein, oder?

Das Anfang ist schon relativ gut. Da kommt am Anfang extrem viel auf einmal und das macht es nicht ganz so einfach.

Generell finde ich es aber sehr gut, dass Du weiter selbst versucht etwas zu schreiben und nicht nur übernimmst. Denn nur so lernt und vertieft man etwas.

Einfach ein paar Gedanken, die mir so durch den Kopf gehen:
a) Bei jeder Methode ist die Frage: Was erwarte ich? Ein Konstruktor soll ja nur eine neue Instanz initialisieren. Also dafür sorgen, dass die diversen Instanzvariablen vernünftig belegt sind. Eine Ausgabe wird da nicht erwartet.
b) Die Ausgabe ist etwas, das regelmäßig gebraucht wird. Daher macht es Sinn, sowas in eine eigene Methode zu packen. So kann die Methode einfach immer aufgerufen werden, wann immer Du es brauchst.
c) Bei Bezeichnern (also den Namen die Du vergibst) immer etwas überlegen, was es denn genau ist. Du hast das Enum "Eingabe" genannt. Aber ist es denn wirklich eine Eingabe? Eingeben tut der Spieler ja etwas wie 1 2. Er gibt ja kein X oder = an. Es geht also eher um eine Feldbelegung.
Es ist vollkommen normal, dass einem nicht immer sofort gute Begriffe einfallen. Aber immer beim Betrachten des Codes die Frage im Hinterkopf behalten: Was habe ich da in der Variable? Was repräsentiert eine Instanz einer Klasse? Was macht die Methode? Und dann ggf. einen Namen direkt anpassen. Die Entwicklungsumgebungen haben da meist eine guter Unterstützung, um etwas umzubenennen.

 

[Maxel33]

Das Anfang ist schon relativ gut. Da kommt am Anfang extrem viel auf einmal und das macht es nicht ganz so einfach.

Generell finde ich es aber sehr gut, dass Du weiter selbst versucht etwas zu schreiben und nicht nur übernimmst. Denn nur so lernt und vertieft man etwas.

Einfach ein paar Gedanken, die mir so durch den Kopf gehen:
a) Bei jeder Methode ist die Frage: Was erwarte ich? Ein Konstruktor soll ja nur eine neue Instanz initialisieren. Also dafür sorgen, dass die diversen Instanzvariablen vernünftig belegt sind. Eine Ausgabe wird da nicht erwartet.
b) Die Ausgabe ist etwas, das regelmäßig gebraucht wird. Daher macht es Sinn, sowas in eine eigene Methode zu packen. So kann die Methode einfach immer aufgerufen werden, wann immer Du es brauchst.
c) Bei Bezeichnern (also den Namen die Du vergibst) immer etwas überlegen, was es denn genau ist. Du hast das Enum "Eingabe" genannt. Aber ist es denn wirklich eine Eingabe? Eingeben tut der Spieler ja etwas wie 1 2. Er gibt ja kein X oder = an. Es geht also eher um eine Feldbelegung.
Es ist vollkommen normal, dass einem nicht immer sofort gute Begriffe einfallen. Aber immer beim Betrachten des Codes die Frage im Hinterkopf behalten: Was habe ich da in der Variable? Was repräsentiert eine Instanz einer Klasse? Was macht die Methode? Und dann ggf. einen Namen direkt anpassen. Die Entwicklungsumgebungen haben da meist eine guter Unterstützung, um etwas umzubenennen.

Dankeschön für die vielen Tipps.

 

[Maxel33]

Ich möchte jetzt, dass der Spieler seine Nummer eingibt, wo er den Kreis hinhaben möchte. Bin ich auf einem Holzweg oder kann das in die richtige Richtung gehen?

    public void zuweisung() {
        System.out.println("Gebe die Stelle an: ");
        Scanner scan = new Scanner(System.in);
        int eingabei = scan.nextInt();
        int eingabej = scan.nextInt();
        
        switch(eingabei & eingabej) {
        case 0:
            array1[0][0] = Eingabe.PLAYER_ONE;
            break;
            
        
            
        }
        
        
    }

 

[Jw456]

Du bekommst doch beide int i und j.
Also kannst du auch gleich die beiden int benutzen das in das Array zu Speichen. Vorher solltest du prüfen od das überhaupt möglich ist. Also ob das Feld noch frei ist. Nicht schon durch einen spielstein belegt ist.

 

[Jw456]

array1[eingabei] [eingabej] = Eingabe.PLAYER_ONE;

Vorher prüfen ob das Feld empty ist.
Wenn es nicht frei ist einen Fehler ausgeben neue Abfrage machen.
Ist es, frei kannst du es Speichen.

Edit vergesse das switch

 

[mihe7]

Ich möchte jetzt, dass der Spieler seine Nummer eingibt, wo er den Kreis hinhaben möchte. Bin ich auf einem Holzweg oder kann das in die richtige Richtung gehen?

Grundsatz: trenne Darstellung/Eingabe von Anwendungslogik.

Was ist der Kern des Spiels? Du hast ein Spielfeld, zwei Spieler und ein paar Regeln, z. B. dass die Spieler abwechselnd an der Reihe sind, dass ein besetztes Feld nicht nochmal besetzt werden darf und wann jemand gewonnen hat. Das ist der Kern des Spiels und den implementierst Du völlig unabhängig von irgendwelchen Eingaben.

Schau Dir Deine Klasse an:

public class TicTacToe {
    private Board board = new Board();
    int player = 1;
    public void run() {
        while (!board.finished()) {
            getMoveOfPlayer();
            if (playerWon()) {
                printWinMessage()
            } else if (!board.movesAvailable()) {
                printGameEndedInTie()
            } else {
                nextPlayer();
            }
        }
    }
}

Da hast Du oben ein Board, das weiß, welcher Spieler wohin gezogen hat, ob noch Züge möglich sind usw. Board ist hier mehr oder weniger der Kern der Anwendung. Die Klasse TicTacToe dient dagegen hauptsächlich der Steuerung durch den Anwender.

Du könntest also in getMoveOfPlayer() den Spieler nach dem zu besetzenden Feld fragen und die Info an board übergeben.

 

[Jw456]

Tipp bei der Eingabe solltest Du auch auf prüfen ob die eingegeben Werte von User auch im richtigen Werte Bereich sind. Nicht über die Array Grenzen hinaus gehen. Hatt der user bz 5 4 eingeben solltest du reagieren. Nicht einfach weiter machen.

 

[kneitzel]

Du hast schon viele gute Hinweise bekommen - ich möchte aber auch noch meinen Senf dazu abgeben:

        int eingabei = scan.nextInt();
        int eingabej = scan.nextInt();

Das ist syntaktisch richtig, aber was ist in den Variablen?
Das es Werte sind, die eingegeben wurden, ist evtl. als Spezifizierung nicht so interessant. Das wäre interessant, wenn Du mehrere i und j hättest. Also das "eingabe" kann ich noch etwas verstehen. Aber i und j? Das wird sehr unübersichtlich. An einer Prüfung kann man nicht direkt erkennen, ob diese korrekt ist oder nicht. (Ist ein if (gewuenschteZeile == i) oder if (gewuenschteZeile == j) richtig?
Das eine ist die Zeile und das andere die Spalte. Ein if (gewuenschteZeile == eingabeSpalte) fällt direkt auf: Zeile wird mit Spalte verglichen?
==> Daher bei Namen gut aufpassen, was man da wählt.

        int zeile = scan.nextInt();
        int spalte = scan.nextInt();

Die Klasse Board hat bisher sehr wenig Methoden, weil wir bisher nichts brauchten. Also jetzt müssen wir paar Dinge einbauen / prüfen:
- Wir wollen evtl. prüfen, ob zeile / spalte valide sind. Hier ist dann die Frage: bleiben wir bei index 0 oder wollen wir mit 1 starten? Wir lassen erst einmal die indices so, wie sie bei Arrays sind. Board kann dann also eine Methode bekommen:
isFieldValid(int row, int column) -> Hier prüfen, dass diese von 0..2 sind. Statt der 2 evtl. die größe des Arrays prüfen. Oder einfach eine Konstante einbauen oder so.
- Wenn die Eingabe valide ist, wollen wir prüfen, ob das Feld leer ist:
isFieldEmpty(int row, int column) -> Hier wäre dann zu prüfen, ob das Feld EMPTY ist.
- Dann wollen wir ein Feld setzen: setField(int row, int column, Field value) -> Hier wird dann das Feld gesetzt.

Die Herangehensweise ist für mich immer gleich: Ich formuliere immer die Schritte - das sind dann in der Regel Methoden, die ich schreibe und ich ich dann immer dahinpacke, wo sie hin gehören. Hier geht es ja um das board, daher sind das Methoden in der Klasse Board.

Das ist etwas, das man paar mal so wirklich durchgespielt haben muss - denn es ist eigentlich ganz einfach.

Hier kann man sich das auch so vorstellen, dass die einzelnen Instanzen dumme Personen sind, die nur wissen, was in Instanzvariablen ist und nur das können, was man Ihnen beigebracht hat.
-> Wir fragen das board: Ist das Feld x, y frei? UPS! Board kann darauf noch nicht antworten. Also bringen wir Board bei, wie man darauf antworten muss, sprich: wir schreiben die Methode.

Prinzipiell kann man immer überlegen, wo man die Logik plaziert. Man kann auch dem Board sagen: Setze den aktuellen Spieler auf Feld x,y und sag mir, ob es erfolgreich war!
=> Dann gehen die Schritten oben in das Board. Sprich dem Board bringen wir bei: Bei so einer Nachricht schaust du, ob das Feld gültig ist. Dann schaust Du, ob das Feld noch frei ist und dann .....

Diese Vorstellung, dass Objekte sind Nachrichten senden, ist heutzutage nicht mehr so wirklich verbreitet. Mit hat diese Vorstellung aber immer recht gut gefallen. (Geht aus meiner Sicht auf Smalltalk zurück - da war dies zumindest ein anzutreffender Sprachgebrauch.) Falls Du das eher verwirrend findest, dann vergiss diese Idee einfach direkt wieder.

 

[Maxel33]

Du hast schon viele gute Hinweise bekommen - ich möchte aber auch noch meinen Senf dazu abgeben:

        int eingabei = scan.nextInt();
        int eingabej = scan.nextInt();

Das ist syntaktisch richtig, aber was ist in den Variablen?
Das es Werte sind, die eingegeben wurden, ist evtl. als Spezifizierung nicht so interessant. Das wäre interessant, wenn Du mehrere i und j hättest. Also das "eingabe" kann ich noch etwas verstehen. Aber i und j? Das wird sehr unübersichtlich. An einer Prüfung kann man nicht direkt erkennen, ob diese korrekt ist oder nicht. (Ist ein if (gewuenschteZeile == i) oder if (gewuenschteZeile == j) richtig?
Das eine ist die Zeile und das andere die Spalte. Ein if (gewuenschteZeile == eingabeSpalte) fällt direkt auf: Zeile wird mit Spalte verglichen?
==> Daher bei Namen gut aufpassen, was man da wählt.

        int zeile = scan.nextInt();
        int spalte = scan.nextInt();

Die Klasse Board hat bisher sehr wenig Methoden, weil wir bisher nichts brauchten. Also jetzt müssen wir paar Dinge einbauen / prüfen:
- Wir wollen evtl. prüfen, ob zeile / spalte valide sind. Hier ist dann die Frage: bleiben wir bei index 0 oder wollen wir mit 1 starten? Wir lassen erst einmal die indices so, wie sie bei Arrays sind. Board kann dann also eine Methode bekommen:
isFieldValid(int row, int column) -> Hier prüfen, dass diese von 0..2 sind. Statt der 2 evtl. die größe des Arrays prüfen. Oder einfach eine Konstante einbauen oder so.
- Wenn die Eingabe valide ist, wollen wir prüfen, ob das Feld leer ist:
isFieldEmpty(int row, int column) -> Hier wäre dann zu prüfen, ob das Feld EMPTY ist.
- Dann wollen wir ein Feld setzen: setField(int row, int column, Field value) -> Hier wird dann das Feld gesetzt.

Die Herangehensweise ist für mich immer gleich: Ich formuliere immer die Schritte - das sind dann in der Regel Methoden, die ich schreibe und ich ich dann immer dahinpacke, wo sie hin gehören. Hier geht es ja um das board, daher sind das Methoden in der Klasse Board.

Das ist etwas, das man paar mal so wirklich durchgespielt haben muss - denn es ist eigentlich ganz einfach.

Hier kann man sich das auch so vorstellen, dass die einzelnen Instanzen dumme Personen sind, die nur wissen, was in Instanzvariablen ist und nur das können, was man Ihnen beigebracht hat.
-> Wir fragen das board: Ist das Feld x, y frei? UPS! Board kann darauf noch nicht antworten. Also bringen wir Board bei, wie man darauf antworten muss, sprich: wir schreiben die Methode.

Prinzipiell kann man immer überlegen, wo man die Logik plaziert. Man kann auch dem Board sagen: Setze den aktuellen Spieler auf Feld x,y und sag mir, ob es erfolgreich war!
=> Dann gehen die Schritten oben in das Board. Sprich dem Board bringen wir bei: Bei so einer Nachricht schaust du, ob das Feld gültig ist. Dann schaust Du, ob das Feld noch frei ist und dann .....

Diese Vorstellung, dass Objekte sind Nachrichten senden, ist heutzutage nicht mehr so wirklich verbreitet. Mit hat diese Vorstellung aber immer recht gut gefallen. (Geht aus meiner Sicht auf Smalltalk zurück - da war dies zumindest ein anzutreffender Sprachgebrauch.) Falls Du das eher verwirrend findest, dann vergiss diese Idee einfach direkt wieder.

Okay, ich werde mich mal dran setzen. Vielen Dank für die vielen Informationen. Das ist mein aller erstes "Spiel" welches ich schreibe. In der Praxis ist das gelernte Wissen anfangs echt mega schwer umzusetzen, wenn du verstehst, was ich meine. Man hat die Grundlagen einigermaßen drauf, aber manchmal ist man echt überfordert.

Jedoch vielen Dank, dass ihr mir alle so gut hilft

 

[Maxel33]

Habe nochmal alles ein wenig überarbeitet & noch drei Methoden hinzugefügt(siehe Quellcode). Ebenfalls habe ich das i und das j für "Zeile" & "Spalte" ersetzt. Könntet ihr vielleicht mal drüber Schauen und mir schreiben, ob die Methoden so in Ordnung gehen würden?

    public void eingabeDerStelle() {
        System.out.println("Gebe die Stelle an: ");
        Scanner scan = new Scanner(System.in);
        int zeile = scan.nextInt();
        int spalte = scan.nextInt();
        
    }
    
    public void PrüfenObWertGültigIst(int zeile, int spalte) {
        switch(zeile & spalte) {
        case 0:
            zuweisung();
            break;
        case 1:
            zuweisung();
            break;
        case 2:
            zuweisung();
            break;
        default:
            System.out.println("Dieser Wert liegt nicht im Bereich!");
        }

    }

    public void PrüfungEinesLeerenFeldes(int zeile, int spalte) {
        switch(array1[zeile][spalte]) {
        case EMPTY:
            zuweisung();
            break;
        case PLAYER_ONE:
            break;
        case PLAYER_TWO:
            break;
        }
    }
    
    public void zuweisung() {
        
    }

Ich hatte überlegt eventuell ein Exception zu schmeißen bei der Prüfung, ob der Wert des Arrays in dem Bereich liegt. Was haltet ihr davon?

Liebe Grüße

 

[Jw456]

Zu der Eingabe Methode
Du fragst den User nach Zeile und Spalt. Du gibst die erfragen Daten nicht zurück.
Die int Variablen sind local. Die Eingabe vom User ist nach der Methode. Verlorenen Weg.

 

[kneitzel]

In eingabeDerStelle hast Du die Eingabe in lokalen Variablen. Damit sind die Daten nach der Ausführung weg. Die Daten müssen somit entweder in einer Instanzvariable gespeichert werden oder zurück gegeben werden. So oder so endet es damit, dass Du eine Klasse hast mit spalte/zeile. Das kann ein einfaches Wert-Objekt sein, das Du dann generell nutzt (Also überall, wo Du bisher Zeile/Spalte genutzt hast.

Die Prüfung sollte ein Resultat zurück geben, also ein Ergebnis der Prüfung. Und es sollte kein Nebeneffekt geben. Die Zuweisung ist ja nicht das, was man erwartet. Wenn Du prüfst, ob Du genug Geld für einen Kauf hast, dann prüfst Du nur und kaufst nicht sofort, wenn das Geld reicht.

Und Methodennamen sollten mit kleinen Buchstaben starten und ein Verb beinhalten also z.B. prüfe statt prüfung.

 

[mrBrown]

@Maxel33 du stehst aber schon ziemlich auf switch-case, ne?

 

[Jw456]

Zum prüfen ob das Feld auf dem Board frei ist. Übergibst du die Zeile und Spalte. Der Methode solltest du einen boolesche Rückgabe Wert geben.
Eigentlich brauchst du doch nur zb mit if prüfen od das Board an der Zeile und Spalte lehr ist.
Und das Ergebnis zurück geben.

Eine Methode mit einen Rückgabe Wert wirst du doch wohl kennen. Die hat kein void.

 

[Jw456]

Tipp da du in deiner Eingabe Methode zwei Werte zurück geben musst Zeile und Spalte. Du aber nur einen zurückgeben kannst. Dann fasse die beiden in einer Daten Klasse zusammen und benutze dies als Datentyp.
Wurde von kneitzel auch schon gesagt.

 

[Jw456]

Ein prüfen ob der user es im richtigen Werte Bereich eingeben hat machst du auch nicht.
Also ob es nicht keiner 0 und nicht größer 2 ist.

 

[Maxel33]

@Maxel33 du stehst aber schon ziemlich auf switch-case, ne?

die sind toll, ja

 

[Maxel33]

Ich sehe jetzt ganz und gar nicht mehr durch, wie ich eine Datenklasse erstellen soll. Auch die If-Anweisung verwirrt mich. Ich kann Spalte und Zeile doch nicht in einer if-Anweisung prüfen, ob diese EMPTY sind. Ich weiß gar nicht, wie ich dies machen soll. Habe ich jetzt alle Methoden falsch oder war auch etwas richtiges dran. Bin gerade ganz schön verzweifelt..

 

[kneitzel]

Die Gliederung ist prinzipiell schon gut, lediglich mit dem Fluss der Daten muss man da etwas anpassen.

Die Datenklasse für eine Position im Spielfeld wäre sowas:

public class Position {
    private int zeile;
    private int spalte;
    
    public Position(int zeile, int spalte) { ... }
    
    // Und Getter für zeile/spalte!
}

Konstruktor muss man noch ausfüllen und die Getter fehlen.

Und Du kannst Spalte und Zeile prüfen:

Du kannst ja prüden, ob die Angabe von Spalte und Zeile gültig sind: Was muss alles gelten?
spalte >= 0
spalte <= 2
zeile >= 0
zeile <= 2
Da alles erfüllt sein muss, wäre dies mit und zu vernüpfen.

Ob ein gegebenes Feld leer ist: feld[zeile][spalte] == Feld.EMPTY

Das wären so Ansätze, die Dich hoffentlich weiter bringen können.

 

[Maxel33]

Die Gliederung ist prinzipiell schon gut, lediglich mit dem Fluss der Daten muss man da etwas anpassen.

Die Datenklasse für eine Position im Spielfeld wäre sowas:

public class Position {
    private int zeile;
    private int spalte;
  
    public Position(int zeile, int spalte) { ... }
  
    // Und Getter für zeile/spalte!
}

Konstruktor muss man noch ausfüllen und die Getter fehlen.

Und Du kannst Spalte und Zeile prüfen:

Du kannst ja prüden, ob die Angabe von Spalte und Zeile gültig sind: Was muss alles gelten?
spalte >= 0
spalte <= 2
zeile >= 0
zeile <= 2
Da alles erfüllt sein muss, wäre dies mit und zu vernüpfen.

Ob ein gegebenes Feld leer ist: feld[zeile][spalte] == Feld.EMPTY

Das wären so Ansätze, die Dich hoffentlich weiter bringen können.

Die Datenklasse hatte ich erstellt gehabt.

    public Datenklasse eingabeDerStelle() {
        System.out.println("Gebe die Stelle an: ");
        Scanner scan = new Scanner(System.in);
        int zeile = scan.nextInt();
        int spalte = scan.nextInt();
        Datenklasse dt = new Datenklasse(zeile, spalte);
        return dt;
    }

Zu den anderen Dingen..ist dies so von euch gemeint?

    public boolean PrüfenObWertGültigIst(int zeile, int spalte) {
        if(zeile >=  0) {
            return true;
        }else if(zeile <=2) {
            return true;
        }else if(spalte >=0) {
            return true;
        }else if(spalte <= 2) {
            return true;
        }else {
            return false;
        }

    }

    public boolean PrüfungEinesLeerenFeldes(int zeile, int spalte) {
       
        if(array1[zeile][spalte] == Eingabe.EMPTY) {
            return true;
        }else {
            return false;
        }
    }

 

[kneitzel]

Die Datenklasse hatte ich erstellt gehabt. Wo muss ich diese jetzt einsetzen und was bringt mir der Konstruktor?

Damit kannst Du Deiner Methode eine entsprechende Rückgabe geben:

    public Position eingabeDerStelle() {
        System.out.println("Gebe die Stelle an: ");
        Scanner scan = new Scanner(System.in);
        int zeile = scan.nextInt();
        int spalte = scan.nextInt();
        return new Position(zeile, spalte);
    }

(Um einfach einmal eine Möglichkeit aufzuzeigen.)

Zu den anderen Dingen..ist dies so von euch gemeint?

    public boolean PrüfenObWertGültigIst(int zeile, int spalte) {
        if(zeile >=  0) {
            return true;
        }else if(zeile <=2) {
            return true;
        }else if(spalte >=0) {
            return true;
        }else if(spalte <= 2) {
            return true;
        }else {
            return false;
        }

    }
[/QUOTE]
Nein, damit der Wert gültig ist müssen ja alle Bedingungen wahr sein. Also mit und (&&) verknüpft:
[ICODE]if (zeile >= 0 && zeile <= 2 && .....)[/ICODE]
[QUOTE="Maxel33, post: 1267517, member: 66357"]
    public boolean PrüfungEinesLeerenFeldes(int zeile, int spalte) {
       
        if(array1[zeile][spalte] == Eingabe.EMPTY) {
            return true;
        }else {
            return false;
        }
    }

Ja, wobei man das abkürzen kann. Die Bedingung im if wird ja zu true / false und dann willst Du tru / false zurück geben. Also genau diesen Wert. Daher schreibt man bei sowas in der Regel einfach:
return array1[zeile][spalte] == Eingabe.EMPTY;

 

[Maxel33]

Damit kannst Du Deiner Methode eine entsprechende Rückgabe geben:

Hatte es eben schon in meiner Nachricht korrigiert, da ich es alleine schon herausgefunden hatte, hehe

 

[kneitzel]

Wie werden eigentlich deine Eltern genannt? Mensch? Oder Säugetier? Oder einfach als Lebewesen?

Ja, das ist eine Datenklasse (Wenn man das so bezeichnen möchte). Aber dennoch sollte es ein vernünftigen Namen haben. So wie halt Deine Eltern Lebenwesen sind, werden sie doch bestimmt nicht so bezeichnet

 

[Maxel33]

Jetzt muss ich im Prinzip nur noch die set Methode erstellen oder?

    public void setzFeld(int zeile, int spalte, Spielfeld wert) {
        
        
            
        }

So ist ja der Aufbau. Die Zuweisung kann ich doch bestimmt mit der Datenklasse machen oder? Also wieder eine Datenklasse erstellen?