Ein einfaches "Vier Gewinnt" Spiel für Anfängerin

Kamy

Mitglied
Hallo zusammen!
Ich bin eine Anfängerin in Java-Programmierung (lerne erst seit 2 Monaten) und versuche, ein einfaches "Vier Gewinnt" Spiel zu schreiben. Leider funktioniert es nicht, und selbst kann ich nicht meine Fehler findeno_O. Unser Professor hat gesagt, dass es schon ziemlich fortgeschrittene Aufgabe ist, aber ich will es trotzdem schaffen:D.
Ich weiß, der Code sieht total schlecht aus, aber ich hoffe, ihr habt Verständnis dafür. Problempunkte:
1.Die Steine erscheinen nicht an den zugehörigen Stellen, sondern ein wenig versetzt.
2.Die Steine bewegen sich nur in der Diagonale.

...Und eventuell noch mehr:rolleyes:.
Danke für eure Hilfe!

Klasse SpielStein
Java:
import edu.princeton.cs.introcs.StdDraw;

public class SpielStein {
    
    boolean istRot;
    
    SpielStein(boolean istRot){
        this.istRot = istRot;
    }
    
    boolean istRot() {
        return istRot;
    }
    
    public void zeicheStein(int xPos, int yPos, int radius) {
        
        if(istRot)
            StdDraw.setPenColor(StdDraw.RED);
        else
            StdDraw.setPenColor(StdDraw.YELLOW);
        
        StdDraw.filledCircle(xPos, xPos, radius);
    }

}

Klasse SpielFeld
Java:
import edu.princeton.cs.introcs.StdDraw;

public class SpielFeld {
    
    public static final int anzahlSpalten = 7;
    public static final int anzahlZeilen = 6;
    public static final int feldGrosse = 80;
    
    public static final int breite = feldGrosse/anzahlSpalten;
    public static final int hoehe = feldGrosse/anzahlZeilen;
    public static final int radius = Math.min(breite, hoehe)/2-1;
    
    
    
    SpielStein [][] steine = new SpielStein[anzahlSpalten][anzahlZeilen];
    
    public void zeichnenGrundRiss() {
        
        StdDraw.setXscale(0, feldGrosse);
        StdDraw.setYscale(0, feldGrosse);
        
        StdDraw.rectangle(feldGrosse/2, feldGrosse/2, feldGrosse/2, feldGrosse/2);
        
        for (int spalte = 0; spalte < anzahlSpalten; spalte++) {
            for(int zeile = 0; zeile < anzahlZeilen; zeile++) {
                StdDraw.circle(spalte * breite + breite/2, zeile * hoehe + hoehe/2, radius);   
                
            }
        }
        
    }
    boolean legeStein(int spalte, boolean farbe) {
        
         for (int zeile = 0; zeile < anzahlZeilen; zeile++) {
                if(steine[spalte-1][anzahlZeilen-1] != null) {
                    System.out.println("Die Spalte ist schon voll! Wählen Sie eine andere Spalte aus!");
                return false;
                }else if(steine[spalte-1][zeile] == null){
                steine[spalte-1][zeile] = new SpielStein(farbe);
                return true;
                }
                
         }
         return farbe;
    
  }

    public void zeicheSpielFeld() {
        
        StdDraw.setXscale(0, feldGrosse);
        StdDraw.setYscale(0, feldGrosse);
        
        for (int spalte = 0; spalte < anzahlSpalten; spalte++) {
            for(int zeile = 0; zeile < anzahlZeilen; zeile++) {
                int xCenterPos = spalte * breite + breite/2;
                int yCenterPos = zeile * hoehe + hoehe/2;
                
                StdDraw.setPenColor(StdDraw.BLACK);
                StdDraw.circle(xCenterPos, yCenterPos, radius);
                
                if(steine[spalte][zeile] != null)
                    steine[spalte][zeile].zeicheStein(xCenterPos, yCenterPos, radius);
            }
        }
    }
    
    public boolean gewinnt() {
        
        for (int zeile = 0; zeile < 7; zeile++) {
            int summe = 1;

            for (int spalte = 0; spalte < 5; spalte++) {
                if (steine[spalte][zeile] != null && steine[spalte + 1][zeile] != null
                        && steine[spalte][zeile] == steine[spalte + 1][zeile]) {
                    summe++;

                    if (summe >= 4) {
                        return true;
                    }

                } else {
                    summe = 1;

                }
            }
        }
        return false;
    }
        
        
    }

Klasse Spiel
Java:
import edu.princeton.cs.introcs.StdDraw;

public class Spiel {

    public static void main(String[] args) {
        
        boolean rotIstAmZug = false;
        
        SpielFeld spiel = new SpielFeld();
        spiel.zeichnenGrundRiss();
        
        while(true) {
            if(rotIstAmZug == false) {
                System.out.println("Rot ist am Zug!");
            rotIstAmZug = true;
        }else if(rotIstAmZug == true){
                System.out.println("Gelb ist am Zug!");
                rotIstAmZug = false;
        }
            System.out.println("Wo soll der Stein hingesetzt werden (1-7)?");
            int spalte = EAM.rInt(); //Code input
            
            
            spiel.legeStein(spalte, rotIstAmZug);
            StdDraw.clear();
            spiel.zeicheSpielFeld();
        }
        
        
        

    }


    }
 

Anhänge

  • Bildschirmfoto 2019-12-22 um 11.58.44.png
    Bildschirmfoto 2019-12-22 um 11.58.44.png
    416 KB · Aufrufe: 21

LimDul

Top Contributor
In deiner Klasse SpielStein steht:
Java:
StdDraw.filledCircle(xPos, xPos, radius);
Da sollte eher
Java:
StdDraw.filledCircle(xPos, yPos, radius);
stehen :)

Da ist ein typischer Fehler, den man selber nicht sieht, weil man ja beim selber lesen genau weiß da stehen soll :)
 

Kamy

Mitglied
In deiner Klasse SpielStein steht:
Java:
StdDraw.filledCircle(xPos, xPos, radius);
Da sollte eher
Java:
StdDraw.filledCircle(xPos, yPos, radius);
stehen :)

Da ist ein typischer Fehler, den man selber nicht sieht, weil man ja beim selber lesen genau weiß da stehen soll :)

OMG...Es funktioniert:oops:. Unglaublich:D.
Vielen Dank!
 

White_Fox

Top Contributor
Auch wenn das noch kein Fehler als solcher ist dennoch ein Hinweis:

boolean istRot; Nimm anstatt eine Boolean lieber eine Enumeration:

Java:
public enum Color{
    RED,
    YELLOW
}
//-----------------------------

Dein Code ist so besser lesbar. Denn aus istRot = false; folgt zwar, daß der Stein nicht rot sein soll - aber was ist er dann? Blau? Schwarz? In deinem speziellen Fall kommt zwar nur Gelb in Frage weshalb der Weg mit Boolean zumindest nicht falsch ist. Aber eine Enumeration macht es eigentlich jedem einfacher: nicht nur uns, sondern auch dir selber.

Ein weiterer Vorteil einer Enumeration ist: Änderungen sind einfacher. Stell dir einfach vor, du willst später mal mehrere Farben implementieren. Dann hört es mit boolean ganz schnell auf. Boolean eignet eigentlich immer dann so richtig gut, wenn der Zustand tatsächlich nur mit 'wahr' oder 'falsch' beschrieben werden kann.
 

Kamy

Mitglied
Auch wenn das noch kein Fehler als solcher ist dennoch ein Hinweis:

boolean istRot; Nimm anstatt eine Boolean lieber eine Enumeration:

Java:
public enum Color{
    RED,
    YELLOW
}
//-----------------------------

Dein Code ist so besser lesbar. Denn aus istRot = false; folgt zwar, daß der Stein nicht rot sein soll - aber was ist er dann? Blau? Schwarz? In deinem speziellen Fall kommt zwar nur Gelb in Frage weshalb der Weg mit Boolean zumindest nicht falsch ist. Aber eine Enumeration macht es eigentlich jedem einfacher: nicht nur uns, sondern auch dir selber.

Ein weiterer Vorteil einer Enumeration ist: Änderungen sind einfacher. Stell dir einfach vor, du willst später mal mehrere Farben implementieren. Dann hört es mit boolean ganz schnell auf. Boolean eignet eigentlich immer dann so richtig gut, wenn der Zustand tatsächlich nur mit 'wahr' oder 'falsch' beschrieben werden kann.

Vielen Dank für den Tipp! Enumeration kenne ich noch nicht, muss mich noch mit dem Thema beschäftigen . Das macht wirklich mehr Sinn:).
 

Kamy

Mitglied
P.S ich bräuchte nur Gewinnspalte :).
Java:
public void checkingVerticalWin(int spalte) {
        int count = 0;

            for (int zeile = 0; zeile < anzahlZeilen; zeile++) {
               
                if(steine[spalte][zeile] == steine[spalte][zeile + 1] && zeile <= 6) {
                    count++;
                    if(count == 4) {
                        System.out.println("You won!");
                    }else{
                        count = 0;
                    }
                    }
             }
    }

Geht nicht:D
 
Zuletzt bearbeitet:
X

Xyz1

Gast
PS Der Algorithmus ist zwar für Tic Tac Toe, jedoch lässt er sich genau so auf Vier Gewinnt anwenden....
 

thecain

Top Contributor
Das ist aber TicTacToe
/edit Tobias Antwort erst nach dem Senden gesehen. mMn nach nicht anwendbar, da für ein Feld n mal n mit n in einer Reihe zum Gewinn
 

Javinner

Top Contributor
Angenommen du willst eine Reihe auf Bedingung "Ende" überprüfen, so ist diese gegeben, wenn vier Plätze übereinstimmen.
Hier eine Beispielzeile des Spielfeldesint[] reihe = {1, 2, 1, 1, 1, 1, 2, 2}. Angenommen Rot = 1, Gelb = 2. Prüfen wir das Feld:
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
So wie es aussieht, hat Rot gewonnen. Hierfür gibt es mehrere Lösungen, alle die zum richtigen Ergebnis führen, sind richtig ;)
 

mihe7

Top Contributor
Die wohl einfachste Variante ist, den Gewinner anhand des letzten Zugs zu überprüfen. Damit der Spieler gewonnen hat, muss sein letzter Zug vier (EDIT: seiner) Steine miteinander verbunden haben.

Alternativ kannst Du natürlich auch ein gegebenes Spielbrett nach einem Gewinner durchsuchen. Für eine Spalte würde ich spontan folgenden Algorithmus versuchen:
Code:
zeile := Index der letzten Zeile
alt := Belegung des Felds (zeile, spalte)
zeile := zeile -1
z := 1
so lange zeile >= 0 und aktuell nicht leer ist {
    aktuell := Belegung des Felds (zeile, spalte)
    falls alt == aktuell  {
        z := z + 1
        falls z == 4, dann ist aktuell der Gewinner -> ENDE
    } sonst {
        z := 1
    }
    zeile := zeile - 1      
    alt := aktuell
}
kein Gewinner in spalte
 

White_Fox

Top Contributor
Enumeration kenne ich noch nicht, muss mich noch mit dem Thema beschäftigen .
Im Prinzip kannst du die wie einfache Konstanten verwenden. (Nur im Prinzip, Enumerationen können noch ein wenig mehr, du könntest z.B. jedem Eintrag in der Enumeration noch Werte für RGB mitgeben.)

Verwenden würdest du das bei dir so:

Java:
public enum Color{
    RED,
    YELLOW
}

public class SpielStein {
  
   private  Color color;    //Sichtbarkeitsmodifizierer nicht vergessen! (Der fehlt bei dir noch.)
  
    SpielStein(Color c){
        this.color = c;
    }
  
    Color getColor() {
        return color;
    }
  
    //...
}


public void someMethod(){
    //Objekt SpielStein erstellen:
    SpielStein neuerStein = new SpielStein(Color.RED);
  
    //Farbe prüfen:
    if(neuerStein.getColor == Color.YELLOW){
        //...
    }
}
 

Devanther

Top Contributor
Hallo,

interessantes Projekt!

Ich hab die 3 Klassen mal in mein Eclipse kopiert, doch ich bekomme leider eine
Fehlermeldung. Ich kann die Klasse Spiel nicht ausführen.


Exception in thread "main" java.lang.Error: Unresolved compilation problems:
EAM cannot be resolved
StdDraw cannot be resolved

at paket1.Spiel.main(Spiel.java:21)

Weiss jemand, wie ich das Projekt zum Laufen bekomme?
Ich würde es auch gerne lernen.

StdDraw.filledCircle(xPos, yPos, radius);

Das habe ich natürlich umbenannt, aber wie gesagt, funktioniert immer noch nicht -.-
Was muss man ändern, damit es geht?

Hoffe, jemand kann helfen.
 

Meniskusschaden

Top Contributor
Die Klasse StdDraw gibt's hier.

Aus EAM wird offenbar nur eine Methode benötigt, über die man die Spaltennummer eingeben kann. Als ersten Ansatz kannst du folgendes nehmen:
Java:
public class EAM {

    public static int rInt() {
        return Integer.parseInt(JOptionPane.showInputDialog("Spaltennummer"));
    }

}
 

Devanther

Top Contributor
Ich habe jetzt die Klasse EAM hinzugefügt...es geht immer noch nicht.

Was willst du mir damit sagen, dass es in deinem Link die Klasse StdDraw gibt?

Was genau muss ich machen?
 

Meniskusschaden

Top Contributor

Devanther

Top Contributor
So, ich habe es jetzt zum Laufen gebracht! Vielen Dank für die Hilfe!


Das Problem ist jetzt aber noch, dass das ohne sichtbare Grafik läuft.
Also, man kann das Spiel nur mit Zeilen und Spaltenangabe spielen, aber man sieht leider noch nicht
wo die Steine fallen etc...

https://www.java-forum.org/thema/ei...r-anfaengerin.186791/#lg=post-1205602&slide=0

Das würde ich gerne sehen.
Ohne diese Grafik kann man es nicht wirklich spielen.
 

Devanther

Top Contributor
Hm. Bei mir ist es auch ein Endlosspiel, bei dir auch?

Hast du ein normales JavaProjekt erstellt oder ein JavaFX Projekt erstellt?

Werde es morgen an einem anderen PC testen. Ist aber komisch, dass ich keine Grafik habe, schade.
 
Zuletzt bearbeitet:

Devanther

Top Contributor
OK, bei mir ist es auch noch Stand aus dem Eröffnungsposting, dann muss man da noch was ergänzen und besser machen.

Was ist die Klasse StdDraw?
Welchem Zweck dient sie?
 

Meniskusschaden

Top Contributor

Devanther

Top Contributor
Das ist eine Bibliotheksklasse? StDraw?

Und von solchen Klassen die man benutzen kann, gibt es sehr sehr viele....?
Welche anderen Bibliotheksklassen gibt es noch, paar Beispiele... ich kenne mich da nicht aus.
Für welche Zwecke gibt es bereits fertige Klassen?
 
Zuletzt bearbeitet:

Kamy

Mitglied
Hm. Bei mir ist es auch ein Endlosspiel, bei dir auch?

Hast du ein normales JavaProjekt erstellt oder ein JavaFX Projekt erstellt?

Werde es morgen an einem anderen PC testen. Ist aber komisch, dass ich keine Grafik habe, schade.

Im Spiel fehlt noch eine richtige Gewinnbedingung :D. Habe es noch nicht bearbeitet.

Siehst du dieses Fenster nicht?

12792
 

Kamy

Mitglied
Ich habe jetzt die Klasse EAM hinzugefügt...es geht immer noch nicht.

Was willst du mir damit sagen, dass es in deinem Link die Klasse StdDraw gibt?

Was genau muss ich machen?
Soweit ich weiß, EAM ist die Bibliothek von unserer Hochschule. Du muss einfach eine Methode implementieren, mit der Du einen Text eingeben kann :)
 

Kamy

Mitglied
Das ist eine Bibliotheksklasse? StDraw?

Und von solchen Klassen die man benutzen kann, gibt es sehr sehr viele....?
Welche anderen Bibliotheksklassen gibt es noch, paar Beispiele... ich kenne mich da nicht aus.
Für welche Zwecke gibt es bereits fertige Klassen?

Ja, es gibt eine Menge von verschiedenen Bibliotheksklassen. Bibliotheksklassen sind Sammlungen fertig programmierter Klassen, die man in seine eigenen Programme einbinden kann. Man kann auch seine eigene Klassenbibliothek erstellen.

Z.B. Die Klasse StdDraw erlaubt es Dir, mit Deinen Programmen Zeichnungen zu erstellen.
Die Bibliotheksklasse Random kann für Zufallszahlen benutzt werden.
Die Klasse ArrayList dient zum Speichern von Objekten.
Du hast bestimmt schon oft in deinen Programmen den Aufruf System.out.println verwendet. Diese Anweisung ruft die Methode println des Objekts out der Klasse System auf.

...Ok, man kann gar nicht alle aufzählen :). Ich hoffe, dass ich Dir ein wenig geholfen habe.
 

Kamy

Mitglied
Die wohl einfachste Variante ist, den Gewinner anhand des letzten Zugs zu überprüfen. Damit der Spieler gewonnen hat, muss sein letzter Zug vier (EDIT: seiner) Steine miteinander verbunden haben.

Alternativ kannst Du natürlich auch ein gegebenes Spielbrett nach einem Gewinner durchsuchen. Für eine Spalte würde ich spontan folgenden Algorithmus versuchen:
Code:
zeile := Index der letzten Zeile
alt := Belegung des Felds (zeile, spalte)
zeile := zeile -1
z := 1
so lange zeile >= 0 und aktuell nicht leer ist {
    aktuell := Belegung des Felds (zeile, spalte)
    falls alt == aktuell  {
        z := z + 1
        falls z == 4, dann ist aktuell der Gewinner -> ENDE
    } sonst {
        z := 1
    }
    zeile := zeile - 1     
    alt := aktuell
}
kein Gewinner in spalte


Vielen Dank für Deine Hilfe! Probiere es heute in meinem Programm:). Ich hoffe, es wird endlich funktionieren :D
 

Kamy

Mitglied
Im Prinzip kannst du die wie einfache Konstanten verwenden. (Nur im Prinzip, Enumerationen können noch ein wenig mehr, du könntest z.B. jedem Eintrag in der Enumeration noch Werte für RGB mitgeben.)

Verwenden würdest du das bei dir so:

Java:
public enum Color{
    RED,
    YELLOW
}

public class SpielStein {
 
   private  Color color;    //Sichtbarkeitsmodifizierer nicht vergessen! (Der fehlt bei dir noch.)
 
    SpielStein(Color c){
        this.color = c;
    }
 
    Color getColor() {
        return color;
    }
 
    //...
}


public void someMethod(){
    //Objekt SpielStein erstellen:
    SpielStein neuerStein = new SpielStein(Color.RED);
 
    //Farbe prüfen:
    if(neuerStein.getColor == Color.YELLOW){
        //...
    }
}

Cool, danke! Das sieht aber gut aus!:). Der Code ist wirklich besser lesbar.
 

Kamy

Mitglied
Angenommen du willst eine Reihe auf Bedingung "Ende" überprüfen, so ist diese gegeben, wenn vier Plätze übereinstimmen.
Hier eine Beispielzeile des Spielfeldesint[] reihe = {1, 2, 1, 1, 1, 1, 2, 2}. Angenommen Rot = 1, Gelb = 2. Prüfen wir das Feld:
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
{1, 2, 1, 1, 1, 1, 2, 2}
So wie es aussieht, hat Rot gewonnen. Hierfür gibt es mehrere Lösungen, alle die zum richtigen Ergebnis führen, sind richtig ;)

Ich verstehe, was Du meinst :). Vielen Dank, versuche es heute nochmal, habe jetzt genug Lösungsvorschläge:D
 
X

Xyz1

Gast
Was ist denn an der Aufgabe so schwer zumal Du jetzt schon zwei Links mit Lösungsvorschlägen hast?

Willst Du uns ver... albern?
 
K

kneitzel

Gast
P.S ich bräuchte nur Gewinnspalte :).
Java:
public void checkingVerticalWin(int spalte) {
        int count = 0;

            for (int zeile = 0; zeile < anzahlZeilen; zeile++) {
              
                if(steine[spalte][zeile] == steine[spalte][zeile + 1] && zeile <= 6) {
                    count++;
                    if(count == 4) {
                        System.out.println("You won!");
                    }else{
                        count = 0;
                    }
                    }
             }
    }

Geht nicht:D

Also bei sowas solltest Du immer genau aufpassen, was Du wie machst. Die Logik ist falsch und ich habe Probleme, da das Vorgehen auch zu verstehen, das Du umsetzen möchtest ....

Generell ist mein Ratschlag:
a) Notierte in Worten, was Du machen willst. Was willst Du wie prüfen?
b) Erst wenn Du Dir das klar gemacht hat - Am besten bist Du es mit einem Stift und Papier Schritt für Schritt durchgegangen - dann fängst Du an und schreibst Java Code.

Also bei checkingVerticalWin übergibst Du eine spalte. Und die gehst Du dann Zeile für Zeile durch.
- Wenn der erste Stein (Zeile: 0) gleich dem zweiten Stein (Zeile: 1) ist: Was ist dann der Zähler?
- Wenn der erste Stein nicht gleich dem zweiten Stein ist: Was ist dann der Zähler?
==> Nun prüfst Du die nächsten Steine. Was ist, wenn der zweite Stein gleich dem dritten Stein ist? Und was ist, wenn dieser nicht gleich ist?

Wozu hast Du die Prüfung zeile <=6? Zeile wird doch in der for Schleife begrenzt. Stimmt evtl. die Begrenzung nicht?
 

White_Fox

Top Contributor
P.S ich bräuchte nur Gewinnspalte :).
Java:
public void checkingVerticalWin(int spalte) {
        int count = 0;

            for (int zeile = 0; zeile < anzahlZeilen; zeile++) {
            
                if(steine[spalte][zeile] == steine[spalte][zeile + 1] && zeile <= 6) {
                    count++;
                    if(count == 4) {
                        System.out.println("You won!");
                    }else{
                        count = 0;
                    }
                    }
             }
    }

Geht nicht:D

Der ultimative Geheimtipp aller Ingenieure: Versuche, ein beliebig großes, hochkomplexes Problem in möglichst viele kleine, einfachere Einzelprobleme zu zerlegen. Zum Beispiel so:

Java:
//Das große Ganze: die beiden Parameter sind die Koordinaten des letzten Zuges auf dem Spielfeld.
public boolean lastPlayerWon(int lastCoordinateX, int lastCoordinateY){
    return
        vertical(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine vertikale Gewinnzeile abgeschlossen hat.
        diagonalFromLeftToRight(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat//Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat.
        diagonalFromRightToLeft(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat//Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (rechts nach links) abgeschlossen hat.
        horizontal(lastCoordinateX, lastCoordinateY) ? //Prüfe, ob der letzte Zug eine horizontale Gewinnzeile abgeschlossen hat.
        true : false;
}

//Teilprobleme lösen:

/*
* Prüft, ob es eine Gewinnzeile gibt, die die Koordinaten einschließt.
* Es wird davon ausgegangen, daß die Koordinaten x und y der letzte Zug waren
* und keine Steine darüber liegen.
*
*@return true, wenn alle vier Steine vertikal unter den angegebenen Koordinaten
* die gleiche Farbe haben, anderenfalls false.
*/
boolean vertical(int x, int y){
    Color comparecolor = getColor(x, y);     //Die Methode getColor(int x, int y) liefert die
    boolean compareFromLastRound == true;  //Farbe des Spielsteins an der angegebenen Stelle zurück.
    int i = y;    //Schleifenzähler
  
    if(y <= 2){return false;} //Wenn y sowieso schon kleiner als vier ist (und zuoberst liegen soll) braucht man nicht überlegen: Es kann keine Gewinnzeile sein.
  
    //Dank des UND bleibt compareFromLastRound false, wenn der Farbvergleich einmal false geliefert hat.
    while(i > 0 && i <= y-4){
        compareFromLastRound = compareFromLastRound && comparecolor == getColor(x, i);
        i--;
    }
    return compareFromLastRound;
}

//Hier darfst du dir selber etwas überlegen. Beachte: Es kann, anders als bei vertical(),
//auch Felder geben in denen kein Spielstein liegt. Diesen Fall kannst du mit Enumerationen
//auch sehr gut nachbilden: Neben RED und YELLOW erweiterst du diese um einen Eintrag NOCOLOR.

boolean diagonalFromLeftToRight(int x, int y){}
  
boolean diagonalFromRightToLeft(int x, int y){}
  
boolean horizontal(int x, int y){}

Wie gesagt, eine kleine Anregung. Um ehrlich zu sein, ich hab mir deine Code noch nicht im Detail angeschaut und weiß daher nicht, ob es bei dir so umsetzbar ist. Aber ich hoffe, ich konnte dir zumindest eine Vorstellung davon geben, wie man größere Aufgaben löst und diese halbwegs lesbar im Code abbildet.
Ich persönlich programmiere recht gern geschwätzig. Wenn ein einzelner Arbeitsschritt aus z.B. zwei oder drei Zeilen besteht, lagere ich diese Zeilen gern in eine Methode aus und gebe ihr einen passenden Namen. Methoden kann man nicht nur dazu benutzen, mehrmals benötigte Codefragmente an einer einzigen Stelle zu haben, sondern auch, um die Lesbarkeit insgesamt zu verbessern.

Wenn du nachher deinen Code nicht mehr kommentieren mußt, sondern aus Methoden- und Variablennamen stets klar hervorgeht was du da machst (oder machen willst ;)), dann hast du was geschafft.
Und glaub mir, du wirst diese Art zu programmieren noch sehr zu schätzen lernen - entweder schon beim Fehlersuchen, oder aber spätestens dann, wenn du nach einem Jahr irgendwelches altes Zeug wieder anfassen mußt. Dann gibt es zwei Möglichkeiten:
  • Welcher Trottel hat denn diesen Schrott geschrieben, da blickt doch niemand mehr durch?
  • Geil, wer hat denn diesen schön strukturierten Code - Ah, da ist ja die Stelle die ich suchte...
-> Oh, das war ja ich.


Ich habe zwei Links gebracht in denen die Lösung steht und prinzipiell 1:1 kopiert werden kann.
Ja, aber die Lösung interessiert hier niemanden, insbesondere Kamy interessiert sich, soweit ich das sehe, nicht für die Lösung. Sondern für die Fähigkeit, eine Lösung selber auf die Beine zu stellen.
 

Kamy

Mitglied
Also bei sowas solltest Du immer genau aufpassen, was Du wie machst. Die Logik ist falsch und ich habe Probleme, da das Vorgehen auch zu verstehen, das Du umsetzen möchtest ....

Generell ist mein Ratschlag:
a) Notierte in Worten, was Du machen willst. Was willst Du wie prüfen?
b) Erst wenn Du Dir das klar gemacht hat - Am besten bist Du es mit einem Stift und Papier Schritt für Schritt durchgegangen - dann fängst Du an und schreibst Java Code.

Also bei checkingVerticalWin übergibst Du eine spalte. Und die gehst Du dann Zeile für Zeile durch.
- Wenn der erste Stein (Zeile: 0) gleich dem zweiten Stein (Zeile: 1) ist: Was ist dann der Zähler?
- Wenn der erste Stein nicht gleich dem zweiten Stein ist: Was ist dann der Zähler?
==> Nun prüfst Du die nächsten Steine. Was ist, wenn der zweite Stein gleich dem dritten Stein ist? Und was ist, wenn dieser nicht gleich ist?

Wozu hast Du die Prüfung zeile <=6? Zeile wird doch in der for Schleife begrenzt. Stimmt evtl. die Begrenzung nicht?


Jetzt sehe ich, dass die erste if-Anweisung falsch ist.

Also bei checkingVerticalWin übergibst Du eine spalte. Und die gehst Du dann Zeile für Zeile durch.
- Wenn der erste Stein (Zeile: 0) gleich dem zweiten Stein (Zeile: 1) ist: Was ist dann der Zähler?
- Wenn der erste Stein nicht gleich dem zweiten Stein ist: Was ist dann der Zähler?
==> Nun prüfst Du die nächsten Steine. Was ist, wenn der zweite Stein gleich dem dritten Stein ist? Und was ist, wenn dieser nicht gleich ist?
Ja, genau das war die Logik dahinter.
Ich hatte überhaupt keine Vorkenntnisse im Programmieren, als ich mit Studium angefangen habe, deswegen ist es immer noch schwer für mich, die sinnvolle Konzeption einer Anwendung zu schaffen.

Vielen Dank für den Tipp! Leider bei der Prüfung habe ich keine Zeit, um alles zu notieren :D, aber generell ist es sinnvoll, ein großes Problem zu zerlegen:).
 

Kamy

Mitglied
Der ultimative Geheimtipp aller Ingenieure: Versuche, ein beliebig großes, hochkomplexes Problem in möglichst viele kleine, einfachere Einzelprobleme zu zerlegen. Zum Beispiel so:

Java:
//Das große Ganze: die beiden Parameter sind die Koordinaten des letzten Zuges auf dem Spielfeld.
public boolean lastPlayerWon(int lastCoordinateX, int lastCoordinateY){
    return
        vertical(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine vertikale Gewinnzeile abgeschlossen hat.
        diagonalFromLeftToRight(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat//Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat.
        diagonalFromRightToLeft(lastCoordinateX, lastCoordinateY) || //Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (links nach rechts) abgeschlossen hat//Prüfe, ob der letzte Zug eine diagonale Gewinnzeile (rechts nach links) abgeschlossen hat.
        horizontal(lastCoordinateX, lastCoordinateY) ? //Prüfe, ob der letzte Zug eine horizontale Gewinnzeile abgeschlossen hat.
        true : false;
}

//Teilprobleme lösen:

/*
* Prüft, ob es eine Gewinnzeile gibt, die die Koordinaten einschließt.
* Es wird davon ausgegangen, daß die Koordinaten x und y der letzte Zug waren
* und keine Steine darüber liegen.
*
*@return true, wenn alle vier Steine vertikal unter den angegebenen Koordinaten
* die gleiche Farbe haben, anderenfalls false.
*/
boolean vertical(int x, int y){
    Color comparecolor = getColor(x, y);     //Die Methode getColor(int x, int y) liefert die
    boolean compareFromLastRound == true;  //Farbe des Spielsteins an der angegebenen Stelle zurück.
    int i = y;    //Schleifenzähler

    if(y <= 2){return false;} //Wenn y sowieso schon kleiner als vier ist (und zuoberst liegen soll) braucht man nicht überlegen: Es kann keine Gewinnzeile sein.

    //Dank des UND bleibt compareFromLastRound false, wenn der Farbvergleich einmal false geliefert hat.
    while(i > 0 && i <= y-4){
        compareFromLastRound = compareFromLastRound && comparecolor == getColor(x, i);
        i--;
    }
    return compareFromLastRound;
}

//Hier darfst du dir selber etwas überlegen. Beachte: Es kann, anders als bei vertical(),
//auch Felder geben in denen kein Spielstein liegt. Diesen Fall kannst du mit Enumerationen
//auch sehr gut nachbilden: Neben RED und YELLOW erweiterst du diese um einen Eintrag NOCOLOR.

boolean diagonalFromLeftToRight(int x, int y){}

boolean diagonalFromRightToLeft(int x, int y){}

boolean horizontal(int x, int y){}

Wie gesagt, eine kleine Anregung. Um ehrlich zu sein, ich hab mir deine Code noch nicht im Detail angeschaut und weiß daher nicht, ob es bei dir so umsetzbar ist. Aber ich hoffe, ich konnte dir zumindest eine Vorstellung davon geben, wie man größere Aufgaben löst und diese halbwegs lesbar im Code abbildet.
Ich persönlich programmiere recht gern geschwätzig. Wenn ein einzelner Arbeitsschritt aus z.B. zwei oder drei Zeilen besteht, lagere ich diese Zeilen gern in eine Methode aus und gebe ihr einen passenden Namen. Methoden kann man nicht nur dazu benutzen, mehrmals benötigte Codefragmente an einer einzigen Stelle zu haben, sondern auch, um die Lesbarkeit insgesamt zu verbessern.

Wenn du nachher deinen Code nicht mehr kommentieren mußt, sondern aus Methoden- und Variablennamen stets klar hervorgeht was du da machst (oder machen willst ;)), dann hast du was geschafft.
Und glaub mir, du wirst diese Art zu programmieren noch sehr zu schätzen lernen - entweder schon beim Fehlersuchen, oder aber spätestens dann, wenn du nach einem Jahr irgendwelches altes Zeug wieder anfassen mußt. Dann gibt es zwei Möglichkeiten:
  • Welcher Trottel hat denn diesen Schrott geschrieben, da blickt doch niemand mehr durch?
  • Geil, wer hat denn diesen schön strukturierten Code - Ah, da ist ja die Stelle die ich suchte...
-> Oh, das war ja ich.



Ja, aber die Lösung interessiert hier niemanden, insbesondere Kamy interessiert sich, soweit ich das sehe, nicht für die Lösung. Sondern für die Fähigkeit, eine Lösung selber auf die Beine zu stellen.

Vielen herzlichen Dank für deine ausführliche Antwort! Die Information ist wirklich gold wert. Ich habe gehört, dass den Code immer zu kommentieren "ein guter Stil" ist. Aber ich bin nicht darauf gekommen, dass es das Leben wirklich erleichtern kann. Dein Beispiel habe ich sehr gut verstanden:).
Wie ich schon oben geschrieben habe, es ist immer noch schwer für mich, die sinnvolle Konzeption zu schaffen. Mangel an Erfahrung und Wissen:(
Aber probiere ich es nochmal. Mein Problem scheint nicht so schwer zu sein.
 

White_Fox

Top Contributor
Leider bei der Prüfung habe ich keine Zeit, um alles zu notieren
Naja, Prüfung ist natürlich ne andere Situation, dennoch: Je mehr du schluderst, desto höher ist die Wahrscheinlichkeit, daß du Fehler machst. Und die Fehlersuche wird definitiv länger dauern. Und auch diese Dinge willst du in einer Prüfung nicht haben.

Die Arbeitsweise unterscheidet sich später im Beruf übrigens nicht sonderlich: In fast allen Firmen (wobei mein Bereich eher Hardware ist), in denen ich bisher war, rotzen die Leute ihr Zeug lieber rasch hin und nehmen sich keine Zeit für ein halbwegs gepflegtes und durchdachtes Design. Selbst wenn die Leute wollten, ließe ihnen schon der erste Zeitplan keine Zeit für ein sinnvolles Design. Was dann übrigens so gut wie immer dazu führt, daß die Firma mehr Geld für das Suchen, Finden und Beheben von Fehlern ausgibt, die eigentlich nicht sein müßten. Und die Termine werden selbstverständlich erst Recht nicht eingehalten, bzw. wird die aufgelaufene Überhang durch widerlich viele Überstunden kompensiert. Dann hat man zwar den Termin gehalten oder nur um wenige Tage verzögert, das geplante Zeitbudget dennoch völlig überzogen. Wenn die Firma das nicht bezahlt (bezahlte Überstunden) bezahlt es der Angestellte mit seiner Freizeit (unbezahlte Überstunden).

Daher: Versuche dir trotz Prüfungsstreß gleich von Anfang an eine vernünftige Arbeitsweise anzugewöhnen. Die Wahrscheinlichkeit, daß du das später auch im Job so machst, ist danach deutlich höher als wenn du dir gleich von Anfang an Schlamperei angewöhnst. In der Regel geht es schnell, von einem hohen Qualitätsniveau auf ein niederes herabzusteigen. Aber erfahrungsgemäß fängt niemand schlampig an, hat damit Erfolg, und steigert die Qualität seiner Arbeit später.

Vergiß nicht: die Prüfung ist nur der nächste Meilenstein, im Rückblick sogar ein völlig unwichtiger. Nimm einfach mal an, du bestehst die Prüfung mit 4,0 gerade noch so. Legst deiner Bewerbung aber dafür z.B. den Quellcode bei, den du gerade schreibst. Allein daß du überhaupt so etwas beilegst reißt sehr viel wieder raus, denn es zeigt daß dich das Fach interessiert hat und daß du (wahrscheinlich) mehr Erfahrung darin hast als jeder andere, der nur ein Hochschulzeugnis hat.

Und wenn die Leute, die deine Bewerbung beurteilen, dann auch noch ohne größere Schwierigkeiten dein Programm lesen können (und dann auch sehr schnell deine Gedankengänge nachvollziehen können und wissen, daß das wahrscheinlich funktionieren wird, selbst wenn es nicht kompiliert) - wen, glaubst du, interessiert danach noch dein Prüfungsergebnis? Selbst wenn ein anderer Bewerber im gleichen Fach eine 1.0 hat, aber darüber hinaus sonst keine Erfahrung vorweisen oder tieferes Interesse glaubhaft machen kann?
Wenn man seine eigenen Arbeiten einer Bewerbung schon beilegt, kommen garantiert auch ein paar Fragen dazu. Auch dann ist es hilfreich, sich in seiner Arbeit rasch zurecht zu finden und ein paar Dinge dazu sagen zu können.


Nachschlag:
Wie ich schon oben geschrieben habe, es ist immer noch schwer für mich, die sinnvolle Konzeption zu schaffen. Mangel an Erfahrung und Wissen
Erfahrung und Wissen eignest du dir doch gerade an...du bist da auf einem ganz guten Weg, denke ich. Und mit nur zwei Monaten (was eigentlich: Programmiererfaharung allgemein oder speziell Javaerfahrung?) hast du da schon einiges geleistet, denke ich.
Mein Professor, der uns programmieren beigebracht hat, sagte immer: Programmieren lernt man nur, indem man das macht. Recht hat er.
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Ich habe gehört, dass den Code immer zu kommentieren "ein guter Stil" ist.
Nein. Kommentiert wird nur, warum man etwas gemacht hat aber nicht, was der Code macht. Letzeres steht nämlich im Code und wenn es nicht offensichtlich ist, lagert man den Code in eine Methode aus, deren Namen die Erklärung liefert.
 

White_Fox

Top Contributor
Ich habe gehört, dass den Code immer zu kommentieren "ein guter Stil" ist.
Naja, die Kommentare hab ich jetzt eher aus didaktischen Gründen eingeführt. Bzw. ist da noch ein Beispiel für ein Javadoc, das z.B. auch ein einer IDE angezeigt werden würde. Lösche die Kommentare mal und versuche dann den Code zu lesen. Wenn der Code dann unverständlich wird, habe ich Mist gebaut. ;)
 

Meniskusschaden

Top Contributor
Die Arbeitsweise unterscheidet sich später im Beruf übrigens nicht sonderlich: In fast allen Firmen (wobei mein Bereich eher Hardware ist), in denen ich bisher war, rotzen die Leute ihr Zeug lieber rasch hin und nehmen sich keine Zeit für ein halbwegs gepflegtes und durchdachtes Design. Selbst wenn die Leute wollten, ließe ihnen schon der erste Zeitplan keine Zeit für ein sinnvolles Design.
Allerdings gibt es da (leider?:confused:) auch noch den Aspekt, dass das "Dahingerotzte" häufig eben doch gut genug ist. Und wenn man dann noch die Parkinsonschen Gesetze berücksichtigt („Arbeit dehnt sich in genau dem Maß aus, wie Zeit für ihre Erledigung zur Verfügung steht.“), scheint man mit knappen Zeitvorgaben oft besser zu fahren. Ich weiß noch nicht, ob ich das gut finde.;)
 
X

Xyz1

Gast
Nein. Kommentiert wird nur, warum man etwas gemacht hat aber nicht, was der Code macht. Letzeres steht nämlich im Code und wenn es nicht offensichtlich ist, lagert man den Code in eine Methode aus, deren Namen die Erklärung liefert.
Der Meinung bin ich auch. Jetzt mal eine Frage an euch, habe neulich mal jemanden geholfen und würde gern wissen ob dieser Kommentar edel, hilfreich und gut sei bzw. "richtig" sei - oder ob er das Wie aber nicht das Was beschreibt:
Java:
	/**
	 * Helper method for {@link #transformTree(TreeNodeBinary)} that processes the
	 * tree recursively.
	 * 
	 * @param <T>
	 * @param root
	 * @param level
	 * @return The transformed tree.
	 */
	public static <T> TreeNodeBinaryLevel<T> transformTree2(TreeNodeBinary<T> root, int level) {
?
 

White_Fox

Top Contributor
Allerdings gibt es da (leider?:confused:) auch noch den Aspekt, dass das "Dahingerotzte" häufig eben doch gut genug ist.
Ich stimme zumindest zu, daß das häufig so aussieht. Ich (als jemand, der KEIN Softwerker ist und von Programmieren im Grunde ja keine Ahnung hat) würde aber sehr schwer vermuten, daß alles Dahingerotzte auch ein Grund ist, Innovationen und Neuentwicklung auf die lange Bank zu schieben.

Wer faßt schon ein Programm gerne an, von dem man ganz genau weiß: man hat keine Ahnung was da passiert, man blickt da auch nicht so schnell durch, und man wird höchstwahrscheinlich nur etwas kaputt machen sobald man da auch nur eine Kleinigkeit ändert.
Und wer weiß was aufeinmal alles nicht mehr geht, weil Klassen auf Fehlern, die vorher irgendwo schlummerten, aufbauen.

Und welche Geschäftsleitung bezahlt freiwillig ihr Team dafür, den Code für ein Programm, das aktuell verkauft wird, neu zu schreiben?

Aus dieser Sackgasse kommen Firmen so gut wie nicht mehr heraus, würde ich sagen. Ich hab mal in einer Firma mit einem Kalkulationsprogramm (EasyTec) arbeiten müssen, ich dachte immer das stammt noch aus Mitte der 90er:
  • Die GUI hätte aus den 80ern kommen können, wurde garantiert von umgeschulten Maurern oder so gemacht, war jedenfalls in allerlei Hinsicht möglichst nichtintuitiv
  • Daten, die dem Programm eigentlich schon vorlagen, mußten an anderen Stellen nochmal händisch eingegeben werden
  • Keine vernünftige Zwischenablage
  • Keine Vorwärts-Rückwärts-Funktion
  • Total dämliche Fehler: Ich hab mal versehentlich irreparablen Mist gebaut, und da es keine Rückgängigmachenfunktion gab, hab ich das Programm einfach schließen wollen. Das Programm fragt noch "Wollen Sie speichern?", ich verneinte, und konnte in der GUI trotzdem zugucken wie es alle Positionen abklappert, und natürlich hat es den Mist am Ende doch gespeichert. Dann durfte ich zur IT, damit das jemand mit höheren Rechten wieder neu einlesen konnte..
  • Die Bedienung an sich war auch möglichst umständlich gehalten: Ich hatte (abends um 2200) ein Angebot mit vielen hundert Positionen fertigkalkuliert, und dann meinte mein Chef, die Materialpreise müßten noch etwas höher sein, Zuschlag rauf. Dummerweise bot diese Rotzsoftware keinerlei Funktion, um alle (oder wenigstens mehrere) Positionen gleichzeitig anzupassen, da durfte ich dann mit viel Mausgeschubse jede Position einzeln ändern.
  • ...
Ich hab dann aus Spaß mal geschaut und nicht schlecht gestaunt, daß das letzte Update des Programms gerademal drei Monate alt war. Meine Fresse, was war ich sauer. Aber solche Crapware kommt in der Industrie anscheinend öfter vor. Ich hab anderswo noch ein anderes Programm (Mosaik) für ähnliche Zwecke benutzt, das war zwar nicht ganz so schlimm, aber trotzdem hab ich mir oft geflucht ob der unzulänglichen Funktionen. Überhaupt ist Industriesoftware oft ein einziges Elend, man denke nur an SAP oder Teamcenter (ein Versionierungstool, Crapware die ihresgleichen sucht, wird u.a. in der Luftfahrt eingesetzt).

Mittlerweile betrachte ich den Einsatz solcher Crapware durchaus als Grund, eine Stelle zu wechseln (oder gar nicht erst anzutreten). Ich habe einfach keine Lust, mich den lieben langen Tag mit derart fehlerhafter Technik herumzuärgern.

Und wohin Entwicklungsverschleppung und Innovationsstau führen sieht man gerade bei Boeing: Sie wollten erst kein Geld für die Weiterentwicklung der 737 ausgeben, dann warf Airbus den A320 NEO auf den Markt, und auf einmal waren sie im Zugzwang und haben völlig überhastet den fliegenden Schrotthaufen 737 MAX rausgeworfen. Und haben selbst da noch versucht zu sparen, wo es nur ging. Z.B. indem man manche Systeme in C anstatt in Ada programmiert hat. (Auch wenn da möglicherweise noch ein oder zwei andere schwerwiegende Faktoren mitspielten.)
Boeings einziger Trost ist aktuell noch, das Airbus nicht genug Kapazitäten hat um jedem eine A320 NEO zu liefern, der jetzt gerne eine solche kaufen wollen würde.

Jetzt aber Schluß hier für heute.
Frohe Weihnachten allerseits. :)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
R OOP Einfaches Programmierbeispiel für Assoziation, Aggregation und Komposition gesucht Java Basics - Anfänger-Themen 10
J Einfaches Quadrat auf der Console ausgeben lassen Java Basics - Anfänger-Themen 7
H ein einfaches Tic Tac Toe Spiel Java Basics - Anfänger-Themen 1
L Einfaches Kartenspiel (Spieler Klasse) Java Basics - Anfänger-Themen 14
R Einfaches refresh während runtime Java Basics - Anfänger-Themen 4
M JSP-Einfaches Bild anzeigen Java Basics - Anfänger-Themen 4
F Einfaches Threadbeispiel.. Java Basics - Anfänger-Themen 7
S Referentielle Integrität ? (Einfaches Bsp) Java Basics - Anfänger-Themen 2
G Erste Schritte Einfaches Gästebuch erstellen mit Array Java Basics - Anfänger-Themen 7
V Klassen import - einfaches Umleiten auf eigene Klassen? Java Basics - Anfänger-Themen 8
H Erste Schritte Einfaches Programm und GUI zusammen bringen Java Basics - Anfänger-Themen 3
A Android Datenbank gaaanz einfaches Insert geht nicht - warum? Java Basics - Anfänger-Themen 4
B OOP einfaches regex Java Basics - Anfänger-Themen 10
K einfaches Drucken von Text (und ggf Bildern,gemischt) Java Basics - Anfänger-Themen 11
M Ganz einfaches Beispiel, finde den Fehler aber nicht :( Java Basics - Anfänger-Themen 2
S Einfaches Regulaerer Ausdruck Problem Java Basics - Anfänger-Themen 7
E einfaches Schachbrett generieren Java Basics - Anfänger-Themen 9
M Einfaches TicTacToe Programm Java Basics - Anfänger-Themen 19
S einfaches Pokerprogramm Java Basics - Anfänger-Themen 52
S KeyListener für einfaches Programm Java Basics - Anfänger-Themen 3
H einfaches Array -> ']' expected Java Basics - Anfänger-Themen 9
H Webservice - Einfaches Beispiel Java Basics - Anfänger-Themen 2
F Ich raffs nicht! - Wie mache ich ein einfaches Java-window? Java Basics - Anfänger-Themen 54
S Einfaches int Array gibt über System.out.println merkwürden Wert aus Java Basics - Anfänger-Themen 9
K Einfaches Bubblesort Java Basics - Anfänger-Themen 11
O einfaches rechnen mit zahlen Java Basics - Anfänger-Themen 4
H Einfaches Date-parse problem Java Basics - Anfänger-Themen 2
T Array auf einfaches Element umwandeln Java Basics - Anfänger-Themen 8
G einfaches Regex Problem Java Basics - Anfänger-Themen 4
M EInfaches Addieren mit Abbruchbedingung Java Basics - Anfänger-Themen 9
M [Einfaches Beispiel] Problem mit innere Klassen Java Basics - Anfänger-Themen 4
S Einfaches Rechenprogramm Java Basics - Anfänger-Themen 2
G Einfaches Rechenprogramm schreiben! Java Basics - Anfänger-Themen 8
A ausgabe eines arrays - einfaches beispiel Java Basics - Anfänger-Themen 4
M Einfaches Menü erstellen Java Basics - Anfänger-Themen 106
D was ist denn nun schon wieder? Einfaches JSP. Java Basics - Anfänger-Themen 6
D Ein einfaches Problem aber ich brauche einen TIP Java Basics - Anfänger-Themen 2
R einfaches Programm, viele Probleme Java Basics - Anfänger-Themen 29
C Einfaches Paint-Programm Java Basics - Anfänger-Themen 9
P Ein einfaches Spiel: TicTacToe. Fehler und Vorschläge Java Basics - Anfänger-Themen 3
F einfaches Menue in einer Textkonsole Java Basics - Anfänger-Themen 4
W einfaches Frame öffnen Java Basics - Anfänger-Themen 2
N Wahrscheinlich ganz einfaches Problem, aber unverständlich! Java Basics - Anfänger-Themen 3
S einfaches script mit Eingabeaufforderung starten (javac) Java Basics - Anfänger-Themen 8
B Einfaches Speichern und Laden in Java? Java Basics - Anfänger-Themen 3
L Einfaches Warten in eine Schleife Java Basics - Anfänger-Themen 9
P einfaches Perl-Skript aufrufen Java Basics - Anfänger-Themen 7
G einfaches jdialog beispiel Java Basics - Anfänger-Themen 1
B Oberflaecheprog einfaches beispiel (button action listener) Java Basics - Anfänger-Themen 5
N Vermutlich einfaches Problem.. Java Basics - Anfänger-Themen 3
M Minimax-Algorithmus für Vier gewinnt Java Basics - Anfänger-Themen 11
M GUI für Vier-Gewinnt. Java Basics - Anfänger-Themen 4
J Vier gewinnt in Java,Spieler Konstruktor Java Basics - Anfänger-Themen 8
C alle möglichen Kombinationen zweier Ziffern auf drei / vier / und 'n" Stellen Java Basics - Anfänger-Themen 11
amgadalghabra Die vier Sortieralgorithmen die durchschnittliche Laufzeit in Millisekunden Java Basics - Anfänger-Themen 37
H Vier Augen sehen mehr... Java Basics - Anfänger-Themen 6
S Die ersten vier perfekte Zahlen. Java Basics - Anfänger-Themen 30
A Klassen Klasse um einen Wert zu vier Zahlen zu speichern Java Basics - Anfänger-Themen 7
A Tic Tac Toe - Vier Gewinnt Java Basics - Anfänger-Themen 5
E Weiteres Vier Gewinnt-Spiel Java Basics - Anfänger-Themen 2
J Reset Button im Spiel Vier gewinnt einrichten Java Basics - Anfänger-Themen 8
G boolean Methode Vier gewinnt Java Basics - Anfänger-Themen 6
G Algorithmus im Spiel "vier gewinnt" Java Basics - Anfänger-Themen 3
B Zusammenhängende Blöcke bei x-gewinnt erkennen? Java Basics - Anfänger-Themen 14
M monte carlo Algorithmus für 4 gewinnt Java Basics - Anfänger-Themen 12
shiroX Methoden MinMax 4 Gewinnt Java Basics - Anfänger-Themen 2
K Methoden 4 Gewinnt checkDiagonal Methode Java Basics - Anfänger-Themen 10
O Methoden Fehlermeldung(Illegal start of expression) bei 4-Gewinnt-Spiel Java Basics - Anfänger-Themen 5
M Erste Schritte KI für 4 Gewinnt Hilfe! Java Basics - Anfänger-Themen 5
H 3 Gewinnt, Fehler bei Neustart Java Basics - Anfänger-Themen 6
L 5 Gewinnt Array[][] probleme Java Basics - Anfänger-Themen 20
B 4 Gewinnt KI? Java Basics - Anfänger-Themen 9
JFeel-x 4 gewinnt-Versuch + Probleme Java Basics - Anfänger-Themen 2
B Problem mit Drei-Gewinnt-Spiel Java Basics - Anfänger-Themen 24
G Problem mit Array bei einem 4-Gewinnt Spiel Java Basics - Anfänger-Themen 2
A MiniMax- Algorithmus für 4-Gewinnt Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben