[JAVA] come è possibile questo?guardate il codice...

[Gremo]

sono un pò occupato su più fronti ultimamente, per chi avesse notato
cmq:

Class Outer {

  private class Inner1 {
    Inner2 = new Inner2();
  }

  private class Inner2 {
  }
}

si tratta semplicemente di 2 classi interne:
come può Inner1 instanziare un oggetto della classe Inner2 dichiarata PRIVATE?

[darp]

Originariamente inviato da Gremo

sono un pò occupato su più fronti ultimamente, per chi avesse notato
cmq:

Class Outer {

  private class Inner1 {
    Inner2 = new Inner2();
  }

  private class Inner2 {
  }
}

si tratta semplicemente di 2 classi interne:
come può Inner1 instanziare un oggetto della classe Inner2 dichiarata PRIVATE?

a parte qualche errorino:

class Outer {

private class Inner1 {
Inner2 d= new Inner2();
}

private class Inner2 {
}
}

compila tranquillamente poichè le classe Inner1 e Inner2 hanno lo stesso livello di visibilità

[Gremo]

Originariamente inviato da darp

a parte qualche errorino:

compila tranquillamente poichè le classe Inner1 e Inner2 hanno lo stesso livello di visibilità

è quello che nn capisco, come mai le due classi private si "vedono". in teoria ho studiato che se una classe interna è dichiarata "private":
-non è visibile all'esterno della classe che la contiene

se "protected":
-è visibile dalla classe di definizione e dalle sue sottoclassi
-è visibile dalle classi che appartengono allo stesso package

risci ad aiutarmi a completare queste visibilità?
grazie

[fek]

Originariamente inviato da Gremo

è quello che nn capisco, come mai le due classi private si "vedono". in teoria ho studiato che se una classe interna è dichiarata "private":
-non è visibile all'esterno della classe che la contiene

Ma le due classi sono all'interno della classe che le contiene, quindi si possono vedentre l'una l'altra.

[Gremo]

doppio

[Gremo]

va bene, allora contestatemi questo:

class Outer {      

  protected class Inner1 {      
    Inner2 i2 = new Inner2();    
  }      

  private class Inner2 {    
  }  

  public Inner1 getInner1() {return new Inner1();}
}
//---------------------------------------------------------
class test {
  public static void main(String[] args) {
    Outer o = new Outer();
    Outer.Inner1 i = o.getInner1();
  }
}

se la classe "Inner1" è dichiarata protected essa è accssibile dalla classe "test", tuttavia test non è:
-una sottoclasse della classe che contiene Inner1 (Outer);
-una classe che appartiene allo stesso package

come fa ad accedervi?
se si dichiara Inner1 private, allora il main dà un errore

[darp]

Originariamente inviato da Gremo

va bene, allora contestatemi questo:

class Outer {      

  protected class Inner1 {      
    Inner2 i2 = new Inner2();    
  }      

  private class Inner2 {    
  }  

  public Inner1 getInner1() {return new Inner1();}
}
//---------------------------------------------------------
class test {
  public static void main(String[] args) {
    Outer o = new Outer();
    Outer.Inner1 i = o.getInner1();
  }
}

se la classe "Inner1" è dichiarata protected essa è accssibile dalla classe "test", tuttavia test non è:
-una sottoclasse della classe che contiene Inner1 (Outer);
-una classe che appartiene allo stesso package

come fa ad accedervi?
se si dichiara Inner1 private, allora il main dà un errore

si da errore e ti dice che non puoi richimare perchè privato, non c'è nulla di strano
ma scusa un attimo, se tu hai due variabili private in una classe tra di loro si vedono quindi anche le inner class private, mentre non le puoi vedere fuori dalla classe

[Gremo]

Originariamente inviato da darp

si da errore e ti dice che non puoi richimare perchè privato, non c'è nulla di strano
ma scusa un attimo, se tu hai due variabili private in una classe tra di loro si vedono quindi anche le inner class private, mentre non le puoi vedere fuori dalla classe

ok, per il fatto della visibilità tra classi private all'interno di una classe ok, ora ho capito, il paragone con le variabili mi ha fatto "accettare" questo comportamento.

la mia domanda cmq era un'altra. quando Inner1 è protected, perchè da test riesco ad istanziarla?(se private, ovviamnete nn va)

[it_developer]

Semplice,
tu hai tralasciato un fatto importante...

Se vedi le varie definizioni di "protected" noterai che questo modificatore stabilisce l'accessibilità del campo modificato SOLO a livello di package...

E se non specifichi nessun package nel tuo codice...java inserisce le tue classi nel package di default...quindi in questo caso TEST e OUTER sono nello stesso package!

(anche se questo non è il modo migliore di affrontare i problemi in java...con un po' di fatica ne vieni fuori... )

[Gremo]

Originariamente inviato da it_developer

Semplice,
tu hai tralasciato un fatto importante...

Se vedi le varie definizioni di "protected" noterai che questo modificatore stabilisce l'accessibilità del campo modificato SOLO a livello di package...

E se non specifichi nessun package nel tuo codice...java inserisce le tue classi nel package di default...quindi in questo caso TEST e OUTER sono nello stesso package!

(anche se questo non è il modo migliore di affrontare i problemi in java...con un po' di fatica ne vieni fuori... )

bene!! grazie della spiegazione, questo "cavillo" del modificatore protected proprio nn lo ricordavo (o più probabilmente il prof non lo ha affrontato)

cosa vuoi dire con :

(anche se questo non è il modo migliore di affrontare i problemi in java...con un po' di fatica ne vieni fuori... )

[Gremo]

colgo l'occasione per chiederti un'altra cosa, ringraziandoti della disponibilità

prendiamo 2 modi diversi per propagare le eccezioni, di cui il mio prof. AFFERMA CHE POSSONO CAUSARE PROBLEMI:

METODO 1: cattura e generazione di una nuova eccezione:

class metodo1 {
   public void faiQualcosa() throws AltraEccezione {
      try {
        generaEccezione(); //metodo che genera un tipo "PrimaEccezione"
      }
      catch (PrimaEccezione e) { //cattura
         throw new AltraEccezione();
      }
  }
}

PROBLEMA DEL METODO 1: VENGONO PERSE LE INFORMAZIONI SU PrimaEccezione

//--------------------------------------------------------------------
METODO 2: cattura e rigenerazione
class metodo2 {
   public void faiQualcosa() throws PrimaEccezione {
      try {
        generaEccezione(); //metodo che genera un tipo "PrimaEccezione"
      }
      catch (PrimaEccezione e) { //cattura
         throw e; //rigenerata
      }
  }
}

PROBLEMI METODO 2: il prof dice che ci sono, ma nn spiega quali, io nn ci arrivo
grazie

[it_developer]

cosa vuoi dire con :
(anche se questo non è il modo migliore di affrontare i problemi in java...con un po' di fatica ne vieni fuori...)

Cioè a volte non conviene affrontare i problemi i maniera cosi verticale...perchè il più delle volte hai come risultato di chiarirti apparentemente il problema ma appena lo ritrovi in una forma leggermente differente...sei nei guai!

Io ti consiglio di usare molto internet...esistono un infinità di guide e tutorial (molti non sono fatti bene, ma altre invece sono proprio un vademecum) e poi ti tener sempre alla portata un libro di testo che a volte ti tira dentro i problemi proprio con degli appositi esercizi che conviene risolvere si utilizzando il codice...ma se ti è possibile...utilizzando un debugger passo passo che ti illustra i vari movimenti degli oggetti java in memoria!

Ti consiglio come tool di sviluppo Eclipse: www.eclipse.org
E' grosso, tutto open-source, e di sfruttarne le capacità di debugger per capire quello che avviene dietro le quinte...

(ovvio che non puoi utilizzare strumenti quali BlueJ o JCreator rapidi ma meno forniti di tools che in molti casi ti aiutano a capire veramente tanto in maniera veloce...)

A volte è anche preferibile utilizzare strutture standard per la programmazione tipo i pattern ma questo è un settore che viene affrontato dopo aver studiato le basi...

Ciao,
it_developer

PS: Dimmi se ho indovinato, fai ing.informatica all'uni, vero???

// utilizzando i costruttori a volte potresti trovati meglio...

[Gremo]

Originariamente inviato da it_developer

Cioè a volte non conviene affrontare i problemi i maniera cosi verticale...perchè il più delle volte hai come risultato di chiarirti apparentemente il problema ma appena lo ritrovi in una forma leggermente differente...sei nei guai!

Io ti consiglio di usare molto internet...esistono un infinità di guide e tutorial (molti non sono fatti bene, ma altre invece sono proprio un vademecum) e poi ti tener sempre alla portata un libro di testo che a volte ti tira dentro i problemi proprio con degli appositi esercizi che conviene risolvere si utilizzando il codice...ma se ti è possibile...utilizzando un debugger passo passo che ti illustra i vari movimenti degli oggetti java in memoria!

Ti consiglio come tool di sviluppo Eclipse: www.eclipse.org
E' grosso, tutto open-source, e di sfruttarne le capacità di debugger per capire quello che avviene dietro le quinte...

(ovvio che non puoi utilizzare strumenti quali BlueJ o JCreator rapidi ma meno forniti di tools che in molti casi ti aiutano a capire veramente tanto in maniera veloce...)

A volte è anche preferibile utilizzare strutture standard per la programmazione tipo i pattern ma questo è un settore che viene affrontato dopo aver studiato le basi...

Ciao,
it_developer

PS: Dimmi se ho indovinato, fai ing.informatica all'uni, vero???

// utilizzando i costruttori a volte potresti trovati meglio...

grazie seguirò i tuoi consigli
riesci a darmi un consiglio sulle eccezioni?il codice è sopra, forse nn lo hai visto...

non faccio ingegneria, poi perchè ti è venuto in mente ingengeria?
faccio una laurea "Tecnologie Web e Multimediali" in pratica l'80% di informatica con esami che trattano di programmazione lato server, multimedia e siti statici

[it_developer]

non faccio ingegneria, poi perchè ti è venuto in mente ingengeria?

Solo ora ho letto che sei di Udine, bella università pure quella, ho detto ing perchè a roma, torino e milano fanno java nel corso di ing. informatica...

faccio una laurea "Tecnologie Web e Multimediali" in pratica l'80% di informatica con esami che trattano di programmazione lato server, multimedia e siti statici

Veramente interessante...forse...per alcuni versi meglio della classica Ing.Info...

Allora venendo al codice...si non l'avevo visto...dunque il fattore eccezioni è sempre un qualcosa dove procedere con cautela...anche se poi nella pratica diventerà tutto più semplice...

Per il problema non vorrei dire una stupidaggine...perchè non ho ancora provato il codice...ma in prima analisi cosi perderesti il fatto che l'origine dell'eccezione è genereEccezione() invece che faiQualcosa()...

Ma come ti ripeto non ho ancora provato nulla è potrebbe essere tutto sbagliato...
perchè in linea di massima sull'eccezioni ci sono varie linee di pensiero...chi appunto le rigenerà e chi invece le cattura e ne lancia di nuove!

Ciao,
it_developer

PS: guarda il mex pv...

[theClimber]

Originariamente inviato da Gremo

PROBLEMI METODO 2: il prof dice che ci sono, ma nn spiega quali, io nn ci arrivo
grazie

Il problema del metodo 2 e' che hai lo stack trace dell'eccezione originale, non viene rigenerata affatto !! non ti accorgerai mai che sei passato dal metodo faiQualcosa().

Metodo alternativo:

METODO 3: rigenera mantenendo la causa

class metodo1 {
   public void faiQualcosa() throws AltraEccezione {
      try {
        generaEccezione(); //metodo che genera un tipo "PrimaEccezione"
      }
      catch (PrimaEccezione e) { //cattura
         throw new AltraEccezione(e);
      }
  }

a partire dalla JDK 1.4 le eccezzioni possono essere costruite con un altra eccezzione che ne e' la causa. I dati dell'eccezzione composta sono l'insieme di quella nuova e dell'originale. Svanatggio: se continui a combinarle, ti escono dei messaggi di centinaia di righe

Ciao

[franksisca]

Dicendo che anche a Cosenza si usa JAVA in quasi tutti i corsi di "programmazione"(anche per quel che riguarda i Sistemi Operativi), il "metodo 3" credo che sia il migliore, ovvere gestione ottimale e non c'è perdita di informazioni sull'eccezione originale.
cmq, magari passo per il solito sapientino che vuole farsi vedere, nella classe Exception, c'è un metodo simpaticissimo, che io consiglio vivamente, anzi io uso solo quello:
{....}
catch(TipoException te){
te.printStackTrace();
}
e non fà altro che stampare lo stack dell'eccezione, ed è utilissimo in fase di progettazione per capirte l'eventuale errore.CIAO

[it_developer]

Anche io sono d'accordo sull'utilizzo del metodo 3, più pulito e in parte molto più leggibile...

(forte...anche a cosenza...java sta prendendo piede negli atenei italiani ad una velocità impressionante...complimenti ai prof! )

Comunque per il printStackTrace() dipende da che applicazione vai a codificare...ad esempio...una applicazione grafica che non usa la console...è preferibile utilizzare un altro metodo per tener traccia dell'eccezione!

Vi consiglio log4j...di Apache.org...una mano santa...in molti casi!
(logging...in generale...ovvio...)

Ciao,
it_developer

[franksisca]

Giusto, senza console devi fare tante altre cose.