[Java] het nut van een klasse splitsing :?

[Verwijderd]

De afgelopen dagen heb ik voor school aan een simpele uitvoering van tictactoe (boter, kaas en eieren) gewerkt. Het spel bestaat uit een aantal klasse waarvan de onderstaande er een is. (nl Board)

Het spel werkt echter is er een probleem, ipv 9 integers op een rij te zetten, moet de code worden omgebouwt naar een systeem met rows en columns (3x3). De informatie moet dus in cellen worden geplaatst. Hiervoor mag ik een nieuwe klasse Cell aan het spel toevoegen.

Vraag:
Mijn vraag is nu, welke gedeelte behoord thuis in de (nieuwe) klasse Cell en welk behoord in Board te blijven. Ik snap het nut van die splitsing niet zo.. Ik neem zelf aan dat de tokens (X, O etc) dan naar Cell verhuizen, zodat deze 'eenvoudiger' aangepast kunnen worden ofzo??

De 'oude' code:

code:

public class Board
{
    private static int aboard[] = new int[9];                       // Maak een array aan.
    
    private static String[] todraw = new String[9];
    public static void tekenBoard()                                 // Methode om het board te tekenen.
    {
        int[] fromBoard = Board.getArray();                         // Vraag de array van klasse Board.
        fromBoard = Board.getArray();
        for (int i=0; i < 9; i++)                                   // Loopje om alle 9 vakjes langs te gaan.
        {
            switch (fromBoard[i])                                   // Kijken welke waarde elk element heeft.
            {
                case 1:                                             // Waarde 1 is een X
                    todraw[i] = "X";
                    break;
                case 2:                                             // Waarde 2 is een O
                    todraw[i] = "O";
                    break;
                default:                                            // Als het niet 1 of 2 is, is er niets, dus een .
                    todraw[i] = ".";
            }
        }
        for (int i=2; i < 9; i=i+3)                                 // Hier gaan we weer alle vakjes langs, maar in stappen van 3
        {                                                           // Hier wordt het board werkelijk getekend.
            int j = (i - 2);                                        // j wordt het eerste vakje.
            int k = (i - 1);                                        // k wordt het 2e vakje.
                                                                    // i wordt het 3e vakje.
            System.out.print("\t\t|\t\t|\t\t\n");                   // De \t is een TAB. de \n is een nextline
            System.out.print("\t" + todraw[j] + "\t|\t" + todraw[k] + "\t|\t" + todraw[i] + "\t\t" + j + "\t" + k + "\t" + i + "\n");
            System.out.print("\t\t|\t\t|\t\t\n");
            System.out.print("------------------------------------------------\n");
        }
    }
    
    public void Board()
    {
        for (int i = 0; i < 10; i++)
            aboard[i]=0;                                            // Alles is standaard 0. 0 = leeg
    }
    
    public static int[] getArray()                                  // Methode om de board array terug te geven.
    {
        return aboard;
    }
    
    public static void setArray(int pos, int token)                 // Methode om de array in te stellen.
    {                                                               // De waarde kan dus een 1 of 2 worden (X of O)
        aboard[pos] = token;
    }
}

[ Voor 4% gewijzigd door Verwijderd op 31-03-2004 18:05 . Reden: spelfoutjuh ]

[Alarmnummer]

Je moet proberen om functionaliteit zo onder te brengen zodat jij het beter kan begrijpen. Denken in een bordelement zoals cell is veel handiger dan te denken in bv (3,2) (de positie op het bord). Ik probeer voor iedere conceptueel 'ding' ook een object aan te maken. Dan kan je alle functionaliteit die hoort bij dat object daar ook in plaatsen. En kan je het later een beetje 'vergeten' hoe het in elkaar zat, als je aan de buiten kant nog maar kan zien wat die doet.

[edit]

Vooral als je systeem uit tig stukken functionaliteit bestaat, dan krijg je een overzichtlelijk systeem als je alles in 1 object propt. In dit geval maakt het denk ik niet zoveel uit, maar ik denk dat jouw docent de opgave niet te moeilijk wil maken.

En verder zou ik ook proberen om geen integers te gebruiken als jij iets anders bedoelt. Ik neem aan dat je 0 neemt als vrije positie, 1 als X en 2 als 0. Het is veel praktischer om bv leeg, kruisje, rondje te nemen ipv getallen.

code:

class Toestand{
      public final static LEEG = new Toestand();
      public final static KRUISJE = new Toestand();
      public final static RONDJE = new Toestand();

      private Toestand(){}//niemand mag nog toestanden aanmaken, 
                                      //die hierboven staan zijn voldoende.
}


class Cell{
     private int _x;
     private int _y;
     private Toestand _toestand;

     public Cell(int x, int y){
           _x = x;
           _y = y;
          _toestand = Toestand.LEEG;
     }
   
  
     public int getX(){
           return _x;
     }

      public int getY(){
           return _y;
      }

       public void setToestand(Toestand t){
            _toestand = t;
       }

       public Toestand getToestand(){
             return _toestand;
       }
}

[ Voor 70% gewijzigd door Alarmnummer op 31-03-2004 18:20 ]

[bille]

bekijk et eens object georienteerd? Een spelbord bestaat uit 9 cellen. en iedere cel heeft 0 of 1 token.

Ik zou
een klasse Bord maken die extend Vector of die een array bevat (waar je de cellen inzet).
Een klasse Cell maken die een Token kan bevatten.
Een super klasse Token maken met subclasses X en O

daarnaast heb je nog een klasse Spel en die bevat een Bord en de Main functie en een paint methode waarin je per cell opvraagt welk token erin zit en hoe je dat token moet tekenen.

tis niet zozeer dat je OO MOET programmeren, tis netjes is om het wel te doen. OO programmeren doe je vanwege onderhoudbaarheid, herbruikbaarheid.. blablabla niet omdat et anders niet werkt.

[riezebosch]

quote: Alarmnummer

overzichtlelijk

grapje?

[ Voor 3% gewijzigd door riezebosch op 01-04-2004 11:43 ]

[Robtimus]

bille schreef op 31 maart 2004 @ 18:21:
Ik zou
een klasse Bord maken die extend Vector of die een array bevat (waar je de cellen inzet).

Nog logischer zou zijn een 3x3 array natuurlijk he?