[Java] Sintassi 'strana' per array e metodi (domande da novizio...)

[utrecht]

Scusate se uso troppe parole ma vedrete che faccio presto... Riporterò alla fine un esempio che ho trovato in rete per porre 2 domande riguardo una sintassi (ricorrente anche su altri codici) che non riesco a comprendere.

Domanda No.1:
L'utilizzo di un array prevede prima di tutto che esso sia dichiarato e quindi supponiamo:
int[] mioVettore;
Successivamnete, poichè rappresenta solo un reference ad un vettore, assegno ad esso l'oggetto vero e proprio, quindi:
mioVettore = new int[5];
Volendo dereferenziarlo:
mioVettore[0]=1,
mioVettore[1]=11,
etc..
Oppure più in breve:
int[] mioVettore={1,11,...};

Cosa significa allora la sintassi seguente per un array?
carta[] cinquina= new carta[5];
Più in basso c'è anche
private carta[][] mazzo=new carta[4][10];

Domanda No.2:
Perchè viene dichiarato un metodo anteponendo il nome della classe? Non è strano come identificatore di un metodo?
public carta estrai_carta() {
...
}

Sembreranno banali ma mi stanno facendo dannare...
ciao e grazie a tutti!!
*/

import javax.swing.*;

public class esempio51
{
public static void main(String[] args)
{
mazzo_carte mioMazzo = new mazzo_carte();


//come esempio di applicazione estraggo cinque carte e le mostro in output

carta[] cinquina= new carta[5];
for (int i=0; i!=5; i++)
{
cinquina[i]=mioMazzo.estrai_carta();
}

//per dimostrare il confronto tra carte

String relazione;
if (cinquina[0].maggiore(cinquina[1])) relazione="maggiore";
else relazione="minore";

//stampo le mie carte e l'esito del confronto tra le prime due


JOptionPane.showMessageDialog(null, cinquina[0].getFigura()+" "+cinquina[0].getSeme()+"\n"
+cinquina[1].getFigura()+" "+cinquina[1].getSeme()+"\n"
+cinquina[2].getFigura()+" "+cinquina[2].getSeme()+"\n"
+cinquina[3].getFigura()+" "+cinquina[3].getSeme()+"\n"
+cinquina[4].getFigura()+" "+cinquina[4].getSeme()+"\n"
+"la prima carta è "+relazione+" della seconda");

System.exit(0);
}
}

//la seguente classe definisce un oggetto di tipo carta

class carta
{
final private static String[] semi ={"oro", "coppe", "bastoni", "spade"};
final private static String[] figure ={"asso", "due", "tre", "quattro","cinque","sei","sette","donna","cavallo","re"};

private int seme;
private int figura;
private boolean estratta;

public carta(int unSeme, int unaFigura, boolean aBoolean)
{
seme=unSeme;
figura=unaFigura;
estratta=aBoolean;
}

public carta(int unSeme, int unaFigura)
{
seme=unSeme;
figura=unaFigura;
estratta=false;
}

public String getSeme()
{
return semi[seme];
}

public int getIndiceSeme()
{
return seme;
}

//metodi di lettura della figura
public String getFigura()
{
return figure[figura];
}

public int getIndiceFigura()
{
return figura;
}

//lettura dello stato della carta
public boolean giaEstratta()
{
return estratta;
}

//cambio dello stato della carta
public void setEstratta()
{
estratta=true;
}

//cambio dello stato della carta
public void setNonEstratta()
{
estratta=false;
}

//con questo metodo posso comparare una carta con le altre
public boolean maggiore(carta unaCarta)
{
if (this.seme > unaCarta.getIndiceSeme()) return true;
else if (this.figura > unaCarta.getIndiceFigura()) return true;
else return false;
}

}

//la seguente classe definisce un mazzo di carte assieme a suoi comportamenti elementari

class mazzo_carte
{
private carta[][] mazzo=new carta[4][10];

//il COSTRUTTORE
// chiamo 40 volte il costruttore delle carte
public mazzo_carte()
{
for(int i=0;i!=4;i++)
for(int j=0;j!=10;j++)
{ mazzo[i][j]=new carta(i,j,false);
// Seguono istruzioni di traccia
System.out.println(i+" "+j);
System.out.println(mazzo[i][j].getFigura()+" "+mazzo[i][j].getSeme());
}
}

//un metodo pubblico che descrive un "comportamento" della classe mazzo
//esso estrae una carta

public carta estrai_carta()
{
boolean da_trovare=true;
int indiceseme, indicefigura;
do{
indiceseme=(int)(Math.random()*4);
indicefigura=(int)(Math.random()*10);
if (!mazzo[indiceseme][indicefigura].giaEstratta()) da_trovare=false;
}while (da_trovare);
mazzo[indiceseme][indicefigura].setEstratta();
return mazzo[indiceseme][indicefigura];
}
}

[recoil]

Originariamente inviato da utrecht
Cosa significa allora la sintassi seguente per un array?
carta[] cinquina= new carta[5];
Più in basso c'è anche
private carta[][] mazzo=new carta[4][10];

significa che dichiari un vettore e nello stesso tempo lo inizializzi, si puo' fare e cosi risparmi righe di codice
la seconda dichiarazione ti da un array bidimensionale, vuol direi che hai 4 array di 10 elementi ciascuno.

Domanda No.2:
Perchè viene dichiarato un metodo anteponendo il nome della classe? Non è strano come identificatore di un metodo?
public carta estrai_carta() {
...

perche' il metodo restituisce un oggetto di tipo carta.
e' come in C, se devi restituire un intero metti int davanti al nome della funzione

[utrecht]

dichiari un vettore e nello stesso tempo lo inizializzi, si puo' fare e cosi risparmi righe di codice

Il dubbio risiede nel fatto che non c'è "tipo_di_dato_[] nome_vettore" bensì "nome_della_classe[] nome_vettore".

Vuol dire forse che è lecito dichiarare 'carta' come tipo di dato per questo array?

[recoil]

Originariamente inviato da utrecht
Il dubbio risiede nel fatto che non c'è "tipo_di_dato_[] nome_vettore" bensì "nome_della_classe[] nome_vettore".

Vuol dire forse che è lecito dichiarare 'carta' come tipo di dato per questo array?

quando crei un array non sei limitato ai tipi di dato "primitivi" come int, double ecc. quindi puoi creare un array fatto di oggetti carta.
attenzione perche' quando lo riempi o gli assegni un oggetto di tipo carta gia' esistente o devi usare nuovamente il new perche' lui ha solo riservato il posto per tot oggetti di quel tipo, non ha creato tot oggetti.

[etonRifles]

In java definire una classe equivale a definire un nuovo tipo il cui nome coincide con il nome della classe... allora ad esempio, una volta definita la classe Carta, scrivere:

Carta c = new Carta("oro","asso");

significa dichiarare una variabile c che memorizza il riferimento ad un oggetto di tipo Carta, in grado di eseguire tutte le operazioni implementate dai metodi della classe Carta. In maniera analoga, scrivere:

Carta[] cc = new Carta[10];

significa dichiarare un array (cioè un insieme di variabili omogenee) di 10 elementi, ciascuno dei quali rappresenta un riferimento ad un oggetto di tipo Carta che deve essere opportunamente inizializzato... ad esempio dopo la dichiarazione può seguire qualcosa del tipo:

cc[0] = new Carta("oro","due");

è ovviamente possibile dichiarare anche array multidimensionali di tipo Carta, ad esempio:

Carta[][] mazzo = new Carta[4][10];

abbiamo in questo modo un array di array cioè un array di 4 elementi ciascuno dei quali è a sua volta un array... in un esempio del genere è comodo pensare ad un array di array coma ad una matrice (4x10), questo perchè i 4 array hanno tutti la medesima dimensione...