array, dubbio

[Lucked]

Ciao a tutti, volevo chiedervi, qual'è la differenza?

class D{
  private int [] c = new int[2];
  D(){
    c[0] = 4;
    c[1] = 3;
  }
}

class D{
  private int [] c;
  D(){
    c[0] = 4;
    c[1] = 3;
  }
}

[valia]

in questo caso hai

class D{
  private int [] c = new int[2];
  D(){
    c[0] = 4;
    c[1] = 3;
  }
}

che al momento della dichiarazione del vettore,

  private int [] c = new int[2];

c'è anche l'istanziazione dello stesso (dichiari cioè quanto spazio occupa).
Con il costruttore poi vai a dire chi sono i suoi elementi.

mentre qui fai

class D{
  private int [] c;
  D(){
    c[0] = 4;
    c[1] = 3;
  }
}

quando dichiari il vettore dici solo che vuoi un vettore di interi, è nel costruttore che dici quanto vale il vettore (considerala un'istanziazione implicita, in cui la dimensione è dettata dal numero di elementi che metti tra le graffe)

[Lucked]

...ci sono i vettori per questo scopo, la seconda forma secondo me è sbagliata, perchè non segnala errori il compilatore?

[Alex'87]

Originariamente inviato da Lucked
perchè non segnala errori il compilatore?

Perché dovrebbe? Il vettore viene inizializzato a null (cosa perfettamente valida), sta al programmatore fare in modo che quel vettore non sia null nel momento in cui viene usato. In questo caso si vede ad occhio che manca qualcosa ma in generale un vettore può essere lasciato a null e istanziato successivamente per cui non c'è nulla di sbagliato in quella scrittura

[valia]

Originariamente inviato da Alex'87
Perché dovrebbe? Il vettore viene inizializzato a null (cosa perfettamente valida), sta al programmatore fare in modo che quel vettore non sia null nel momento in cui viene usato. In questo caso si vede ad occhio che manca qualcosa ma in generale un vettore può essere lasciato a null e istanziato successivamente per cui non c'è nulla di sbagliato in quella scrittura

anzi ci sono pure casi che il vettore lo inizializzi tramite metodi.
L'operazione è corretta perché tu dichiari di voler utilizzare un'istanza di quel tipo, solo quando vorrai inserirci dei valori, devi dichiararne la dimensione.
Anche nel caso in cui inizializzi tramite metodo, hai cmq un punto in cui fai o una new o un'istanziazione esplicita, per cui in fase di compilazione non hai errori (se lo usi male li hai in esecuzione)

[desa]

Il primo caso è come l'ha descritto valia: l'inizializzazione avviene esplicitamente prima ancora dell'esecuzione del costruttore. All'ingresso di quest'ultimo ti trovi un array "valido" in cui tutti gli elementi sono inizializzati al valore di default (0 per gli array di int) e a cui puoi tranquillamente accedere in lettura e, come fai tu, in scrittura.
Attenzione per quanto riguarda il secondo caso: la spiegazione di valia è corretta, solo che si riferisce a un codice diverso, ossia

class D{
  private int [] c;
  D(){
    c = new int[] {4, 3};
  }
}

in cui l'inizializzazione di "c" avviene all'interno del costruttore. Quello che stai facendo in questo modo è istanziare un nuovo array di int, contemporaneamente specificando che deve contenere - in sequenza - gli elementi 4 e 3: è evidente - e dunque implicito - che l'array avrà lunghezza 2.

In merito al secondo caso che hai posto vale quanto detto da Alex'87, ma vorrei fare una precisazione.
A differenza delle variabili locali (per le quali se non esegui una inizializzazione esplicita il compilatore segnala il classico messaggio "variable XXX might not have been initialized"), nel caso delle variabili di istanza (gli attributi) è il sistema stesso ad attuare una inizializzazione implicita, applicando la valorizzazione con un valore di default (0 se la variabile è int, null se è un array o un oggetto, ecc.).
Per questo non ricevi errori: il compilatore riconosce che "c" è un attributo, si accorge che non hai fatto tu l'inizializzazione e predispone quindi il codice in modo che quest'ultima venga eseguita con il default "null".
Poi, è evidente che se cerchi di accedere ad un valore di un array null incorrerai in una eccezione... ma questo è un errore che verrà riconosciuto solo a runtime.

[Lucked]

L'operazione è corretta perché tu dichiari di voler utilizzare un'istanza di quel tipo, solo quando vorrai inserirci dei valori, devi dichiararne la dimensione.

pero poi accedo a delle posizioni nella memoria quindi, come succede anche per il C, delle posizioni a cui non è consentito accedere?

quando faccio:

c[0] = 4;
c[1] = 3;

scrivo qualcosa nella memoria credo.

[Lucked]

Ah un momento, ieri sera compilavo ed eseguivo un programma cosi:

class D{
  private int [] c;
  D(){
    c[0] = 4;
    c[1] = 3;
  }
}

class p{
public static void main(String [] args){
  new D();
}
}

e a runtime non mi segnalava nessun errore, per questo ho aperto il post! Invece stamattina me lo segnala... magari, provo a dire...che puo nascere qualche problema se compili D ed esegui p...anche se stamattina non succede, boh ci faro attenzione

[valia]

L'ordine di compilazione è importante:

prima compili D e poi compila P (magari dai dei nomi che non siano lettere dell'alfabeto e basta), ma se compili direttamente la classe che compila il main, il compilatore in automatico compila tutte le classi da lui riferite.

Guarda bene agli errori in runtime e agli errori di compilazione, si presentano in istanti diversi e hanno significati diversi

questa classe funziona senza errori di compilazione/esecuzione

public class Main {

    private static int[] vector ;

    public Main(){
        vector = new int[2];
        vector[0] = 1;
        vector[1] = 2;
    }

    public static void main(String [] argv){
        Main main = new Main();
        for (Integer intero : vector) System.out.println("intero : " + intero);
    }
}

[desa]

pero poi accedo a delle posizioni nella memoria quindi, come succede anche per il C, delle posizioni a cui non è consentito accedere? quando faccio: c[0] = 4; c[1] = 3; scrivo qualcosa nella memoria credo.

Certo che stai accedendo a delle "posizioni" in memoria. Parlando in generale (quindi, non solo nel caso che hai sollevato) se sono valide, il dato verrà inserito correttamente. Se non lo sono, riceverai un errore dalla macchina virtuale (NullPointerException se l'array è null, ArrayIndexOutOfBoundsException se fai riferimento ad un indice fuori da quelli ammessi).
In entrambi i casi, si tratta di una situazione che sarà verificata a runtime: il compilatore non può sapere se, al momento in cui verranno eseguite, quelle istruzioni faranno riferimento a una posizione "esistente" oppure no. Dipende dalla sequenza di esecuzione.

e a runtime non mi segnalava nessun errore

Molto probabilmente stavi eseguendo qualcos'altro, oppure hai fatto un po' di prove e hai perso di vista quale codice stavi effettivamente eseguendo (una possibilità può anche essere quella prospettata da valia).
Guarda: cancella tutti i class, ricompila il codice che hai postato con javac *.java e riesegui. Vedrai che incorrerai in una eccezione.