Newsgroup: it.comp.java
Titolo: Costruttore di Default ?

Ciao a tutti,
stavo ripassando come istanziare le classi Java,
ho notato che esiste un costruttore di default
ma a qual'e'? quali sono i valori di default?
Grazie.
Ciao
Morfeus

 ma a qual'e'? quali sono i valori di default?
Il costruttore di default e' quello che viene creato dal
compilatore se non lo metti tu. Non ha parametri
e non fa' niente.
Davide

...

Ah! grazie mille!
ma nel mio libro c'e' scritto
che inizializza qualcosa tipo "le variabili della classe"
con i valori di default
e' falso?
Ciao
Morfeus

In una definizione di classe tipo
class classeprova
{
    int prova;
    ......
}
per default Java utilizza il costruttore classeprova()
per cui per allocare una classe utilizzando new
farai una chiamata del tipo
classeprova s = new classeprova();
in cui la parte destra richiama il costruttore di default.
Dal momento che il costruttore di classe è un metodo come tutti gli altri,
può essere "sovrascritto" con una tecnoca detta "Overlod dei metodi".
Modificando quindi la classe con
class classeprova
{
    int prova;
    ......
    classeprova()
    {
        prova=3;
     }
}
nel momento della inizializzazione il costruttore inizializzerà il valore
del dato membro.
Ma non finisce qui perchè di costruttori se ne possono fare a piacimento
purchè abbaiano
differente lista di parametri
Il passo successivo è quindi:
class classeprova
{
    int prova;
    ......
    classeprova()
    {
        prova=3;
     }
    classeprova(int val)
    {
        prova=val;
     }
}
A questo punto puoi utilizzare un nuovo costruttore in modo che, quando
istanzi l'oggetto
puo passare anche parametri in input.
classeprova s = new classeprova(3);
Spero di essere stato chiaro, comunque in giornata publicheò sul mio sito
(
www.java-net.tv
)
i primi capitoli di un corso su java.
Per qualsiasi altra cosa sono a  disposizione
In bocca al lupo
Max
--
--
Massimiliano Tarquini
E-Mail:tarq...@all-one-mail.net
-------------------------------------------------------------------
Java e Java(tm) 2 Enterprise Edition free books on line
http://www.java-net.tv
-------------------------------------------------------------------
"Se, in un primo momento, l'idea non è assurda, allora
non c'è nessuna speranza che si realizzi".
A. Einstein
-------------------------------------------------------------------


Sei stato chiarissimo grazie, un'ultima cosa perfavore,
nell'esempio che ti ho riportato sopra
in assenza della dichiarazione del costruttore
come vengono inizializzate le variabili?
Cioe' la variabile prova viene inizializzato a 0 o con un Null ?
e la variabile stringa ?
Ciao
rmorfeus


Le variabili possono essere in generale inizializzate al momento della loro
dichirazione,
e mai vengono inizializzate per default dal compilatore, percui una
dichiarazione del tipo:
int prova;
ha come unico effetto quello di indicare al compilatore di allocare 32 bit
per contenere un numero intero.
Queste variabili, che indicano tipi primitivi (non oggetti) sono
referenziate per valore. Per poterle inizializzare
sulla riga di dichiarazione basterà scrivere
int prova=0;
Per quanto riguarda gli oggetti la cosa è un po differente inquanto non
vengono referenziati per valore e le variabili che li identificano "si
comportano come oggetti" ma in realtà contengono solo la traccia della
locazione in memoria dell'oggetto (indirizzo). Per queste variabili Java
alloca 4 byte.
Riprendendo la classe precedente, una dichiarazione del tipo:
classeprova s;
riserva solo 32 bit per far si che s possa contenere il riferimento
all'oggetto una volta instanziato, riferimento che sarà memorizzato in s
dall'operatore new:
classeprova s = new classeprova().
Ma questo non è ancora il nostro punto di arrivo.Diversamente da C, null non
equivale  a zero, ma rappresenta un oggetto nullo. In java, ogni variabile
reference ad un oggetto non inizializzato viene impostata di default a null,
ossia
classeprova s;
equivale a
cclasseprova s = null;
Quella che tu chiami variabile stringa, in realtà è un oggetto con alcune
proprietà particolari. Infatti
un oggetto stringa, oltre ad essere alloocato ed inizializzato con il metodo
classico
String stringa = new String("mio nome");
può essere allocato utilizzando l'operatore + di concatenazione tra stringhe
oppure direttamente con una stringa:
String stringa = "mio nome";
String stringa2 = "mio"+"nome";
Ciao Max


 classeprova s = null;
Spero di non essere pignolo sostenendo, sempre se non sbaglio, che le due
scritture non sono in generale equivalenti e quindi intercambiabili.
Se all'interno di una classe metti quale membro, un oggetto, questo e'
automaticamente inizializato a null e come tale vale l'equivalenza sopra. Se
invece definisci un oggetto all'interno di un metodo di un oggetto questo
non viene automaticamente inizializzato ed e' errato farvi delle operazioni
di confronto.
Un paio di esempi forse permettono di chiarirmi.
Questo codice non viene compilato (viene dato l'errore: variable f might not
have been initialized):
import io.java.*;
class C
{
    public static void main(String[] argv) throws Exception
    {
        FileWriter f; // Notare l'assenza di inizializzazione!!
        if (f==null) System.out.println("null");
        else           System.out.println("Non-null");
    }
}
Questo codice viene compilato.
import io.java.*;
class C
{
    public static void main(String[] argv) throws Exception
    {
        FileWriter f=null; // Notare l'inizializzazione!!
        if (f==null) System.out.println("null");
        else           System.out.println("Non-null");
    }
}
W.

e questo stampa 0 e null.
io sapevo che il tipo "int" e' uguale al tipo "integer",
come fa' a stampare 0 e null ?!
Ciao

 e la variabile stringa ?
La variabile stringa (il cui tipo e` "String" con la S in maiuscolo)
verra` inizializzata con null (occhio che "null" e` tutto in
minuscolo... java e` case-sensitive quindi string != String ...)
Questo vale _solo_ per i campi della classe. Per le variabili
dichiarate all'interno del corpo di un metodo tale inizializzazione
non e` garantita, e in assenza di un assegnamento esplicito esse
contengono dei valori "sporchi". E` questo per cui il compilatore
cerca di segnalarti l'utilizzo di una variabile prima di una sua
esplicita inizializzazione.
-- 
Ciao,  |  I play Russian roulette everyday, a man's sport,
Matteo |  With a bullet called life, yeah called life, (SUGAR)

 
noto dell'incoerenza in queste due frasi! :-P
...e soprattutto un'imprecisione nella prima, che spero di aver
chiarito nella mia risposta a "morpheus".


 chiarito nella mia risposta a "morpheus".
Hai risposto a me, invece che a Tarquini.... Era Massimiliano Tarquini a
sostenere la cosa che citi. Io, come ho spiegato nel mio msg. pensavo che le
cose stessero in modo differente.
Ciao, W.

come fa' a stampare 0 e null ?!
No, int è un tipo, Integer (la I è importante) è una classe del
pacchetto java.lang che genera istanze che rappresentano interi,
praticamente:
 int a=3;
a sarà una normale variabile
 Integer a=new Integer(3);
a sarà un oggetto di tipo Integer che contiente un 3.
Questa classe serve in determinati casi in cui i metodi non sono in
grado di lavorare con int, ma riescono a lavorare solo con oggetti, un
esempio per cui questa classe diventa utile sono i Vettori, che in
Java sono una serie di oggetti e non sarebbe quindi possibile fare
vettori di interi.
-- remove "UN.NECESSARY" from the address to reply
msg 100% recyclable.

minuscolo... java e` case-sensitive quindi string != String ...)
Ciao, ti ringrazio molto per le spiegazioni
e ringrazio molto anche tutti gli altri.
W Java!!
Ciao a tutti.
Morfeus