Array Abfrage will nichts so wie ich will....

das ganze programm oder die klasse?!
Es funktionierte noch, als das Programm in einer Klasse war.. nachdem Aufteilen in Klassen klappte es aufeinmal nicht mehr..

Das ganze Programm, wo es in einer Klasse war, hat ca. 450 zeilen..
Die Klasse Spielfeld nun, wo es drinnen steht 216..

Java: 
ackage viergewinnt_aufgabe2;

     /** ******************************************
     * Klasse die das Spielfeld setzt, anzeigt und den Spieler setzt
     ************************************************/
public class Spielfeld {
       
       private char[][] spielfeld = new char [6][7];
     /** ******************************************
     * Sezt das Spielfeld
     ************************************************/     
    public void setzeSpielfeld() {
               
               for(int i = spielfeld.length - 1; i >= 0; i--) {
          for(int j = spielfeld[i].length - 1; j >= 0; j--) {
              spielfeld[i][j] = ' ';
          }
       }
       zeigeSpielfeld();      
    }
     /** ******************************************
     * Zeigt das Spielfeld an
     ************************************************/      
    public void zeigeSpielfeld() {
        for (int i=0;i<6;i++) {
            for (int j=0;j<7;j++) {
                System.out.print("|"+spielfeld[i][j]);
            }
            System.out.println();
            System.out.println("--------------");
        } 
                 for (int j=1;j<8;j++) {
                    System.out.print("|"+j); 
                 }
                 System.out.println("");
                 System.out.println();
    }
    
        /** ******************************************
     * Prüft Senkrechte, Waagerechte und Diagonale Zeilen ob es ein Sieger gibt
     * oder ob es Unentschieden endett
     * @param feld - Feld des Arrays
     * @param reihe - Reihe des Arrays
     * @param spieler - Aktueller Spieler
     ************************************************/    
    public char hatGewonnen(int feld, int reihe, char spieler) {
        boolean istunentschieden = true;
        char sieger = ' ';
        for(int i = spielfeld.length - 1; i >= 0; i--) {
          for(int j = spielfeld[i].length-1; j >= 0; j--) {
              if(spielfeld[i][j] == ' ')
              istunentschieden = false;
          }
        } 
        if (istunentschieden) {
              sieger = '?';
        }
        
        //vertikal nach unten
        
        int zaehler=0;
        int _reihe = reihe;
        int _feld = feld;
 
        for (int i = reihe; i<6;i++) {
            if (spielfeld[_reihe][_feld] == spieler) {
            _reihe++;    
            zaehler++;
            }
        }
        
        if (zaehler>=4){
            sieger = spielfeld[reihe][feld];
            return sieger;
        }

        sieger = hatGewonnenHor(feld, reihe, spieler, sieger);
        sieger = hatGewonnenDia(feld, reihe, spieler, sieger);
        
        return sieger;
    }
    
    /** ******************************************
     * Prüft Horizontal ob ein Gewinner feststeht
     * @param feld - Feld im Array
     * @param reihe - reihe die der Spieler angegeben hat
     * @param spieler - Aktueller Spieler
     * @param sieger - Zeigt den Sieger an
     ************************************************/    
    public char hatGewonnenHor(int feld, int reihe, char spieler, char sieger) {
         //horizontal nach rechts
        int _reihe = reihe;
        int _feld = feld;
        int z = feld;
        int zaehler = 0;
        for (int i = feld; i<7;i++) {
          if (spielfeld[_reihe][_feld] == spieler)  {
                _feld++;
                zaehler++;
          
          }
        }
        //nach links
        for (int c = feld; c>0;c--) {
            if (spielfeld[_reihe][z-1] == spieler)  {
                z--;
                zaehler++;
            }
        }

        if (zaehler>=4){
            sieger = spielfeld[reihe][feld];
            return sieger;
        }
        return sieger;
    }
    
     /** ******************************************
     * Prüft Diagonal ob ein Gewinner feststeht
     * @param feld - Feld im Array
     * @param reihe - reihe die der Spieler angegeben hat
     * @param spieler - Aktueller Spieler
     * @param sieger - wenn Aktueller sieger ist, wirds in Sieger gespeichert
     ************************************************/   
    public char hatGewonnenDia(int feld, int reihe, char spieler, char sieger) {
         //diagonal nach links unten
        int _reihe = reihe;
        int _feld = feld;
        int z = feld;
        int j = reihe;
        int zaehler = 0;
        for (int i = feld, c = reihe;i>=0 && c<6;i--,c++) {
          if (spielfeld[_reihe][_feld] == spieler)  {
              _reihe++;
              _feld--;
              zaehler++;
          }
        }
        // rechts oben
          for (int i = reihe, c = feld;i>0 && c<6;i--,c++) {
          if (spielfeld[j-1][z+1] == spieler)  {
              j--;
              z++;
              zaehler++;
          }
        }
       
        if (zaehler>=4){
            sieger = spielfeld[reihe][feld];
            return sieger;
        }  
        
        
        //diagonal nach rechts unten
        _reihe = reihe;
        _feld = feld;
        z = feld;
        j = reihe;
        zaehler = 0;
        for (int i = reihe, c = feld; i<6 && c<7;i++,c++) {
          if (spielfeld[_reihe][_feld] == spieler)  {
              _reihe++;
              _feld++;
              zaehler++;
          }
        }
        //links oben
        for (int i = feld, c = reihe;i>0 && c>0;i--,c--) {
          if (spielfeld[j-1][z-1] == spieler)  {
              j--;
              z--;
              zaehler++;
          }
        }
        
        if (zaehler>=4){
            sieger = spielfeld[reihe][feld];
            return sieger;
        }
        return sieger;
    
    }
    
     /** ******************************************
     * Eingabe des Spielers wird in das Spielfeld gesetzt
     * @param feld - Feld des Arrays
     * @param spieler - Der Spieler, der am Zug ist
     ************************************************/  
    public int setzeSpielstein(int feld, char spieler) {
        boolean istWahr = false;
        int reihe = 0;
        for (int i = spielfeld.length - 1; i >= 0 && !istWahr; i--) {
            if (spielfeld[i][feld]== ' ') {
                spielfeld[i][feld] = spieler;
                istWahr = true;
                reihe = i;
            }
        }
        zeigeSpielfeld(); 
        return reihe;
    }
    
    public boolean reiheVoll(int eingabe) {
    boolean istVoll = true;
              for (int i = 5; i >=0; i--) {
                if (spielfeld[i][eingabe]== ' ') {
                 istVoll = false;
                }
            }
    return istVoll;
    }
}


ist die Spielfeld klasse.. ist das wichtigere..
Mein Prof meinte vorhin, dass es an meinem "Laptop" liegt, dass ich was falsch eingestellt habe. Hab aber nix umgestellt....
 
Naja, wenn es geht, wenn du es in einer Klasse hast und danach nicht mehr, dann hast du i-was falsch aufgemacht oder greifst falsch drauf zu. Daher wäre es ratsam auch alles zu posten, damit es nachvollziehbar wird, was du getan hast.
Du rufst bestimmt Spielfeld von der anderen Klasse auf und da scheint ja i-was nicht zustimmen.

Und nein, nur weil man es aufteilt und dann nicht mehr läuft, ist das kein Problem des Laptops. Das ist und bleibt Unfug.
 
Mach dein Spielfeld mal static, damit du "immer auf dasselbe" Spielfeld zugreifst..

Code: 
private static char[][] spielfeld = new char[6][7];
 
dürfen keine statischen variablen benutzen bei der Aufgabe. Ist verboten


Java: 
     /** ******************************************
     * Checkt ob die Eingabe zwischen 0 und 6 und ob die Reihe voll ist oder nicht
     * @param eingabe - Eingabe des Spielers
     ************************************************/  
    public boolean istEingabeGueltig (int eingabe) {
        boolean istGueltig = true;
        boolean istVoll = true;
        Spielfeld feld = new Spielfeld();
        ConsolenAusgaben consolenausgaben = new ConsolenAusgaben();
        if (eingabe>6 || eingabe<0) {
                 consolenausgaben.BildschirmAusgaben("FalscheZahl");  
                 istGueltig = false;
                 istVoll = false;
        }
        if (istGueltig) {
            istVoll = feld.reiheVoll(eingabe);
        }
        
        if (istVoll) {
             istGueltig = false;
             consolenausgaben.BildschirmAusgaben("ReiheVoll");
        }
        return istGueltig;
    }

hier wird die klasse aufgerufen bzw. reiheVoll()

Hier soll er einfach in die Klasse Spielfeld in die Methode reiheVoll() und diese prüft ob die Senkrechte Reihe voll ist, wo der Spieler sein Spielsetin reinsetzen will... er gibt dann halt true oder false zurück an istEingabeGueltig()
 
Zuletzt bearbeitet:
Du erstellst dir jedes mal ein neues Spielfeld, dass ist dir klar, oder?
So kann es auch nie voll sein, ....bzw. es ist immer nur 1Zug pro Spielfeld gespeichert.

D.h. du musst das spielfeld-Array statisch machen oder die Klasse nur 1mal erstellen und dann immer wieder benutzen.

also in der gepostet Klasse eine Variable einlegen, ...und darauf immer zugreifen.

Java: 
private Spielfeld sf = null;

public DeineKlasse(){ // von der aufrufenden Klasse der Konstruktor
                                        // ich kenne ja dein Aufbau nicht und das hier ist nur ein Beispiel.
      sf = new Spielfeld();
}

So ungefähr. Und dann in der Methode istEingabeGueltig fragst du nach, ob sf.reiheVoll

So benutzt du immer das selbe Spielfeld.^^
 
Zuletzt bearbeitet:
hmm.. Aber wenn ich jedesmal nen neues Spielfeld mache, wieso läuft das Spiel ganz normal, wenn ich diese Abfrage rausnehme? in der Klasse Spielfeld ist ebenfalls ne ähnliche Abfrage, um den Spielstein zusetzen, und die funktioniert auch und erkennt ob nen spielstein gesetzt ist oder ob nen leerzeichen drinnen ist, zeigt nach jedem Zug das Spielfeld richtig an und auch den Gewinner...

ehhh... checks grad nicht. Ist mein erstens Semster.. vorher noch nie Java gehabt.
 
Aber wenn ich jedesmal nen neues Spielfeld mache, wieso läuft das Spiel ganz normal, wenn ich diese Abfrage rausnehme?
Zum Vergrößern anklicken....
Es funktioniert auch, wenn du sie drin lässt. In der Abfrage jedoch erstellst du dir ein neue Klasse Spielfeld und fragst das ab, anstatt das vermutlich die richtige Klasse abzufragen.

in der Klasse Spielfeld ist ebenfalls ne ähnliche Abfrage, um den Spielstein zusetzen, und die funktioniert auch und erkennt ob nen spielstein gesetzt ist oder ob nen leerzeichen drinnen ist
Zum Vergrößern anklicken....
Die Abfrage funktioniert auch so und die in der Klasse Spielfeld auch, da die Klasse in sich sich ja nicht neu erstellt und das abfragt, sondern sich selbst.


Ich weiß nicht, wie ich es erklären kann, bin in sowas nicht gut.
Aufjedenfall ist es nicht sinnig bei jeder Abfrage eine neue Klasse Spielfeld zuerstellen und die abzufragen.
Du solltest schon immer die gleiche Klasse Spielfeld abfragen.

Daher ist deine Zeile in der Methode istEingabeGueltig
Java: 
Spielfeld spielfeld = new Spielfeld();
nicht richtig.

Du erstellst dir in der abfragenden Klasse eine Klassenvariable
Java: 
private Spielfeld sf = null;

Und dann änderst du die die Zeile in der Methode istEingabeGueltig zu
Java: 
if(sf == null){
sf = new Spielfeld();
}

Und anstatt das du dann nach
Java: 
feld.reiheVoll
abfragst, fragst du nach
Java: 
sf.reiheVoll
ab


Damit du immer die selbe Klasse Spielfeld abfragst und dir nicht zwischendurch einfach eine zusätzliche anlegst und darin rumabfragst.

Ggf. musst du dann andere Methoden in der abfragenden Klasse ebenfalls anpassen. (sf dann benutzen!) - kenne ja dein Code nicht.
 
Zuletzt bearbeitet:
hmm muss ich zum schluss machen... muss nun erstmal ne Klasse für den Spieler erstellen mit ner vererbung usw.
Statt nen neuen Thread zumachen, kann ich ne kurze Frage dazu stellen, ob ich sie richtig habe?! Funktionieren tuts, aber ka obs auch wirklich ne vererbung ist mit extends..
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück