Newsgroup: it.comp.java
Titolo: Una curiosita', sto imparando! :)

Salve,
e' la prima volta che scrivo qui, sto imparando il java e non riesco ad andare
avanti se non capisco una cosa:
che senso ha:
*protected* void finalize(void) -> classe Object
perche' farlo protetto??
Se TUTTE le classi ereditano per forza il metodo finalize essendo la classe
root (Object) alla base di tutte le classi, se e' protetto o no che
differenza fa'?
Grazie a chiunque risolvera' il mio dilemma! :)
-----== Posted via Deja News, The Leader in Internet Discussion ==-----
http://www.dejanews.com/rg_mkgrp.xp
   Create Your Own Free Member Forum

Un possibilita' potrebbe essere questa:
 
Essendo il metodo finalize() protetto, esclusivamente chi eredita
dalla classe puo' usarlo. Se invece fosse package o public chiunque
potrebbe chiamare la finalize(), e se fosse private non potrebbe
essere reimplementato dalle sottoclassi.
Che ne dici?


| --
| Bruno Bossola
| Groupware/Intranet B.U.           Phone:  +39-11-2252211
| ATOS SpA v.Vaninetti 27           Fax:    +39-11-2203182
| I-10148 Torino ITALY              Change NOSPAM in atos to email me!

 Che ne dici?
Che ancora non mi hai convinto! :))
Grazie lo stesso comunque!



No, questo non e' vero, ed e' proprio per questo che il metodo e'
protetto. 
Non e' possibile infatti scrivere...
 
	Frame f= new Frame();
	f.finalize();
...Ovvero e' normalmente impossibile distruggere esplicitamente un
oggetto, mentre e' possibile invece modificare il comportamento del
distruttore (finalize()) implementandovi i comportamenti che sono
necessari al proprio oggetto. Ad esempio, la classe FileInputStream si
preoccupa, nel distruttore, di chiudere lo stream nel caso tu da fuori
non l'abbia ancora fatto
Il fatto che esso si trovi in Object sta a solo a significare che e'
una caratteristica comune ad ogni oggetto..
Comunque, se ci tieni, cio'  non toglie che  tu possa fare una cosa
del genere:
public class MyObject	// extends Object, of course!
{
    // bla bla
    // bla bla
    public void finalize()
    {
        super.finalize();
    }
}
...mostrando il distruttore al mondo intero!
Ciao,



Ora mi e' venuto un altro dubbio!! :)
Cioe' se io ho:
class MiaClasse
{
 *private* mioMetodo(int x) {}
}
e poi faccio...
class SuaClasse extends MiaClasse
{
 *public* mioMetodo(int x) {}
}
...Cioe' posso modificare il tipo di protezione quando voglio?????
Spero mi possa aiutare anche questa volta.
Scusami ancora, e grazie di nuovo!


differenza fa'?
Se due classsi A1 e A2 ereditano da una classe base B un metodo
protected C (e A1, A2, B sono tutte in diversi package), allora un
metodo di A1 puó invocare C *solo su oggetti di classe A1*, NON
su oggetti di classe A2, B, o qualsiasi altra classe derivata da B.
Non rimproverarti troppo se hai problemi a cogliere questa finezza
(che il Java ha in comune con il C++) -- anche la Microsoft (che pure
di compilatori C++ ne fa!-) ne ha... in VJ++, infatti, la regola é,
erroneamente, piú lasca.  Ma in Java standard, definire metodi
protected nella classe Object un suo senso ben preciso lo ha,
anche se tutte le classi ereditano da Object.
Alex

potrebbe chiamare la finalize(), e se fosse private non potrebbe
Una piccola correzione: in Java, protected é *piú lasco*
di "package" (protezione di default, che di solito é detta
"friendly"): tutti le classi dello stesso package possono
accedere a membri protected, cosí come potrebbero
accedere a membri friendly, ma *in piú* vi hanno anche
accesso (in un senso ben delimitato, come ho spiegato
nel mio precedente post) classi di altri package, purché
ereditino da questa.  Non é quindi vero che se finalize
fosse package "chiunque potrebbe chiamarlo" -- l'insieme
delle classi aventi accesso a quel membro sarebbe anzi
_minore_, se fosse friendly invece che protected (solo
le classi del package java.lang avrebbero accesso).
Alex


Si, per quello che ne so se tu estendi una classe puoi promuoverne i
metodi mediante l'overriding (private -> protected -> public)
modificandone il tipo di protezione. Quello che comunque non potrai
fare e' richiamare dalla classe derivata un metodo privato della
superclasse.
Data la seguente classe A:
public class A
{ 
    protected void iamprotected()	{ }
    private void iamprivate()	{ }
    public void iampublic()		{ }
}
Puoi ottenere la seguente classe B derivata...:
public class B extends A
{
    // promozione da protected a public
    public void iamprotected()	{ }	
    // promozione da private a protected 
    protected void iamprivate()	{ }
}
... e questo e' quello che puoi / non puoi fare:
public class B extends A
{
    // promozione da protected a public
    public void iamprotected()	
    {
        super.iamprotected();	// CORRETTO !!!
    }	
    // promozione da private a protected 
    protected void iamprivate()	
    {
        super.iamprivate();		// ERRORE !!!
    }
}
Questo e' quanto mi ricordo / mi viene in mente attualmente. 
Se ti puo' consolare, anche a me non piace il fatto di poter
promuovere un metodo protetto (rendendolo pubblico a tutti) con la
possibilità di dargli lo stesso esatto comportamento del metodo della
superclasse. Forse "a pelle" accetto di piu' il fatto di poter
promuovere un metodo privato, con la necessità pero' di riscriverlo
completamente.


le classi del package java.lang avrebbero accesso).
Giusto come la moneta d'oro! 
Effettivamente sono stato un po' avventato: ti ringrazio per la
correzione.



Ringrazio Bruno Bossola e Alex Martelli per il loro aiuto!
(Sto elaborando....(ST-TNG :))
Grazie!


correzione.
Prego!  Sono un pignolo dannato, sia per vocazione sia
per avocazione...:-).
Alex