Programmazione ad oggetti

[Michele96]

Salve, sono un nuovo iscritto e volevo chiedervi come si poteva controllare una posizione di una matrice di oggetti. Mi spiego meglio il codice è :

Campo[][] campoDiGioco1 = new Campo[10][10];

// visualizzo il campo

for(int riga=0 ; riga < campoDiGioco1.length; riga++ ){
for(int colonna=0 ; colonna < campoDiGioco1.length ; colonna++ ){
if(campoDiGioco1[riga][colonna]==0) {
System.out.print("~");
}
}
}

Campo è una classe separata che contiene variabili private.

Eclipse mi dice che c'è un errore nel controllo dell'if. L'errore è
incompatiblità di tipi tra Campo e Intero esiste qualche metodo per controllare ciascuna posizione della matrice campoDiGioco1.

Grazie in anticipo a tutti per il vostro aiuto.

[andbin]

if(campoDiGioco1[riga][colonna]==0) {

L'espressione campoDiGioco1[riga][colonna] è di tipo Campo (insomma è l'oggetto Campo alla tal riga/colonna) .... tu lo stai confrontando con un numero. Quindi: cosa vuoi controllare? Cosa vuol dire "controllare ciascuna posizione della matrice"?


P.S. e ricordati (se non l'hai fatto) di istanziare tutti gli oggetti Campo. new Campo[10][10] istanzia l'array ma NON istanzia i 100 oggetti Campo !

[Michele96]

Grazie andbin per la risposta,

io se era possibile volevo controllare ciascun elemento della matrice campoDiGioco1 e controllare il numero al suo interno.
Cioè campoDiGioco1[0][0] -> controllare se contiene il numero 0 o 1
campoDiGioco1[0][1] -> controllare se contiene il numero 0 o 1
etc per il resto delle posizioni della matrice

No non l'ho istanziata mi potresti dire come si fa.
Grazie

[Ansharja]

Beh certo che ricevi quell'errore in compilazione, stai confrontando una tua classe (Campo) con un tipo primitivo di java, il tipo int.
Probabilmente hai frainteso il significato dell'istruzione:

Campo[][] campoDiGioco1 = new Campo[10][10];

Questa istruzione crea una matrice di dimensione 10*10 dove ogni cella è un oggetto della classe Campo da te definita.

Piu' probabilmente tu vuoi creare un Campo chiamato campoDiGioco1 e vuoi che ogni Campo abbia una matrice di interi che rappresenti lo stato del campo.

Puoi quindi definire tale variabile nella classe Campo come

private int[][] campoDiGioco;

Poi nel costruttore della classe Campo inizializzi tale matrice con l'istruzione

campoDiGioco = new int[10][10];

E nella classe separata crei questo nuovo Campo e lo stampi a video, controllando di volta in volta il valore dell'intero presente nella cella i,j della matrice campoDiGioco.
Per stampare a video il campo in realtà sarebbe utile creare un metodo apposito nella classe Campo, in modo che nella classe principale tu debba solo richiamare il metodo sull'istanza appena creata.

Se non è chiaro qualcosa siamo qui

[andbin]

controllare il numero al suo interno.

Ma dipende da come è fatto Campo! Cosa fa? Quali campi hai messo? Hai dei getter/setter? Lo puoi sapere solo tu ....

No non l'ho istanziata mi potresti dire come si fa.

Doppio ciclo for annidato, istanziazione di un Campo per ciascuna cella e assegnamento all'elemento [riga][colonna] dell'array.

Tra l'altro il doppio ciclo for che hai fatto è corretto perché il numero di colonne è uguale al numero di righe ma in senso generale è più corretto testare:

colonna < campoDiGioco1[riga].length

Ma ripeto che essendo [10][10] in questo caso non è sbagliato usare campoDiGioco1.length anche nel secondo.

[LeleFT]

Innanzitutto bisogna capire com'è fatta quella classe Campo.
Immagino che avrà al suo interno un campo intero, che è ciò che interessa a te... se è così, è stato previsto un metodo di accesso a tale campo? O il campo è pubblico (pessima scelta)?

Insomma... noi non sappiamo nulla di questa classe Campo, quindi non sappiamo in che modo accedi al suo stato interno, quindi non ti possiamo dire con precisione cosa devi fare per controllare il suo stato interno e verificare se è 0 oppure 1.

Supponendo che la classe Campo sia più o meno così:

public class Campo {
   ...
   private int valore;   // Valore che può essere 0 oppure 1
   ...
   public int getValore() {
      return valore;
   }
   ...
}

Allora il controllo diventa

if (campoDiGioco[0][0].getValore() == 0) {
   ...
}

Per istanziare i 100 oggetti campo va usato l'operatore "new":

for(int riga=0; riga<10; riga++) {
   for(int colonna=0; colonna<10; colonna++) {
      campoDiGioco[riga][colonna] = new Campo( ... );   // Solo tu puoi sapere cosa passare (eventualmente) al costruttore
   }
}

Dovresti, comunque, postare il codice della classe Campo, per capire com'è fatta. (e se decidi di postare il codice, postalo all'interno degli appositi tag CODE)

Ciao.

[Michele96]

Non ho ancora capito bene come inizializzare la matrice. Posto il codice di Campo

public class Campo {

    private int val=0;
    private int[][] campoDiGioco1;

    public int getVal() {
        return val;
    }


    public void setVal(int val) {
        this.val = val;
    }


    public void inizializza(){
        for(int riga=0; riga<10; riga++) {
           for(int colonna=0; colonna<10; colonna++) {
              campoDiGioco1[riga][colonna] = new Campo(); 
           }
        }
    
    }
    public Campo() {
        campoDiGioco1= new int[10][10];
        for(int riga=0 ; riga < campoDiGioco1.length; riga++ ){
         for(int colonna=0 ; colonna < campoDiGioco1.length ; colonna++ ){
              campoDiGioco1[riga][colonna]=0;
         }
        }
    }
}

Eclipse mi da errore nella funzione inizializza() nella riga in cui eseguo new Campo()

Dove sbaglio??

[Ansharja]

Sbagli qui:

campoDiGioco1[riga][colonna]=new Campo(); 

Se, come pensavo, vuoi che campoDiGioco1 sia una matrice di interi non devi definire ogni sua cella come un oggetto Campo!

Tra l'altro l'inizializzazione corretta la fai nel costruttore di Campo, creando la matrice e assegnando gli zeri in ogni posizione della matrice, quindi a cosa ti serve il metodo inizializza scritto così?

[Michele96]

Si grazie ho risolto con l'inizializzazione e vorrei adesso visualizzare la matrice con un semplice System.out.println();

    public static void visualizza(Campo[][] campoDiGioco) {
        for (int i=0;i<campoDiGioco.length;i++){
            System.out.print("\t"+(i+1));
        }
        System.out.println();
        for(int riga=0 ; riga < campoDiGioco.length; riga++ ){
            System.out.print((riga+1)+"");
                for(int colonna=0 ; colonna < campoDiGioco.length ; colonna++ ){
                    if(campoDiGioco[riga][colonna].getVal()==0){
                        System.out.print("\t"+"~");
                    }
                }
                System.out.println();
            }
       }

Errori di sintassi non c'è ne sono però quando lo mando in esecuzione e come se non trovi il valore di campoDiGioco[riga][colonna].getVal().

Il metodo è dentro il file di Campo

[Ansharja]

Scusa non ho capito bene cosa intendi, non hai capito quando richiamare il metodo visualizza() ?

Se sei in una classe fuori da Campo, dovresti avere nel main della classe un richiamo al costruttore di Campo, subito dopo averlo creato lo visualizzi.
Però continui a fare confusione tra matrice di interi e matrici di oggetti di tipo Campo!
Infatti nel metodo visualizza passi come parametro (Campo[][] campoDiGioco)!

Se il metodo è ideato per visualizzare un oggetto di tipo Campo, cioè vuoi in pratica stampare la matrice di interi campoDiGioco di un particolare Campo puoi farlo almeno in due modi (il secondo è molto più sensato)

1- Hai un metodo visualizza(Campo c) nella tua classe esterna a Campo, quella del main per intenderci, e nel metodo principale crei una nuova istanza di Campo, che poi passi al metodo visualizza.
All'interno del metodo poi controlli il valore di ogni cella della matrice campoDiGioco del Campo che hai passato al metodo.
Il metodo main della classe diventa qualcosa del tipo

// ... eventuali  istruzioni iniziali
Campo c=new Campo();
visualizza(c);
// ... continui il metodo main

2- Dal momento che ora sei interessato a visualizzare un Campo ha molto più senso che il metodo visualizza() sia un metodo della classe Campo e sia richiamato sull'oggetto di tipo Campo che vuoi visualizzare.
In questo modo non devi passare nessun parametro al metodo, quindi visualizza lo definisci nella classe Campo in questo modo :

public void visualizza()
{
     // il metodo non è più static perché viene richiamato su un oggetto e non su una classe...
     
     // qui stampi a video la tua matrice di interi
}

Mentre nel main dell' altra classe a questo punto fai qualcosa del tipo:

// ... eventuali  istruzioni iniziali
Campo c=new Campo();
c.visualizza();
// ... continui il metodo main

In realtà il modo migliore per visualizzare un Campo sarebbe ridefinire il metodo toString() nella classe Campo e stamparlo semplicemente a video ma per ora devi acquisire le basi del linguaggio!