[JAVA] un dubbio o mistero da sfatare

[a2000]

ti vengo incontro:

non è che la classe "informatico" sia derivata dalla superclasse "servo" ?

[misterx]

esatto

come chimico che deriva da benzinaio

[PGI]

Originariamente inviato da a2000
ti vengo incontro:

non è che la classe "informatico" sia derivata dalla superclasse "servo" ?

Ammetto di essere un po' restio a risponderti a2000, perchè da un lato fai un uso inconsueto ma straordinario dell'italiano (non so quanti lo apprezzino ma a me piace e parecchio), dall'altro non sempre capisco ciò che dici (non ho fama di volpe in arguzia ma ho un apprezzabile livello di sincerità )

Sfortunatamente non ho preso la strada dell'informatica (benchè adori allo stesso modo quella che, invece, ho scelto), non so confermarti o meno se i programmatori siano "servi" (ma qui potrei aver frainteso il significato). Per quanto ho letto potrei dire che alcuni paiono un po' poco critici verso le informazioni che circolano ma potrebbe essere una questione di scarso interesse "teorico".

In Italia, almeno, perchè a guardare per il mondo, specialmente la parte anglofona, il panorama scade e parecchio: forsè lì l'informatico non estende "servo" ma di sicuro implementa "spocchia".

&Ciao.

[misterx]

Cosa hai studiato PGI ?

[PGI]

Ho studiato legge.

Per spegnere la modalità chat-line, se sei interessato ad una serie di autorevoli curiosità su Java, io caldeggio la lettura di questa serie di pagine web (che forse ho già segnalato)The JavaTM Virtual Machine Specification, che coprono tutti i concetti dell'OOP per come sono stati affrontati nella progettazione di Java.

[a2000]

con gli avvocati è gara persa.

[misterx]

A _________
|          |
B          D
|
C

così facendo:

A prova = new C();

la classe "C" a quali metodi può accedere ?

[PGI]

C ha i metodi non-private definiti nelle classi superiori (quindi B e A), idem per i campi.

Poichè tuttavia "prova" è un riferimento di tipo "A", in compilazione usando "prova" puoi accedere ai soli metodi definiti nella classe A (benchè l'oggetto a cui punti sia di tipo C). A complicare le cose sta il fatto che i "metodi" a cui puoi accedere attraverso "prova" hanno la segnatura definita in A ma, in esecuzione, il loro contenuto è determinato a partire dall'oggetto a cui puntano fino a trovarne la prima implementazione.

Esempio: definiamo le tre classi A, B e C come segue. A padre di B padre di C.

public class A {
    
  public A() { }
  
  public void stampaValore() { System.out.println("stampa valore di A"); }
  
}

public class B extends A{
    
  public B() { }
  
}

public class C extends B{
    
  public C() { }
  
  public void stampaValore() { System.out.println("stampa valore di C");}
  
  public void unMetodoDiC() {}
}

A possiede un metodo "stampaValore": stampaValore è ereditato da B, nella forma definita in A. stampaValore è ereditato anche da C, ma qui viene sovrascritto ed il metodo è destinato a restituire una stringa diversa in output.

A prova = new C();
prova.stampaValore(); -> output "stampa valore di C"
prova.unMetodoDiC(); -> errore in compilazione, "prova" è un tipo A, la classe A non definisce il metodo "unMetodoDiC()";

if(prova instanceof C) {
((C)prova).unMetodoDiC(); -> casting, valido //come si traduca "casting" in italiano non lo so, perchè "conversione" è già usato per un'altra faccenda
} else {
System.out.println("Il riferimento prova non punta ad un oggetto di tipo C");
}

prova=new B();
prova.stampaValore(); -> output "stampa valore di A": B eredita il metodo come definito in A.

In fondo potremmo dire (ma lo dico solo io) che l'ereditarietà determina sempre il trasferimento dal genitore al figlio della segnatura dei metodi ed eventualmente del corpo.

Dopo questa perla di saggezza dovrei uscire di scena con una capriola ma non ho trovato lo "smilies" addatto

[a2000]

prova con uno di questi:

[misterx]

Originariamente inviato da a2000

prova con uno di questi:

non è che stai un tantino esagerando ?

[misterx]

Originariamente inviato da misterx

A _________
|          |
B          D
|
C

ok PGI, molto chiaro; quindi:

A prova = new C(); // vedo i metodi di A
B prova = new C(); // vedo i metodi di A+B
C prova = new C(); // vedo i metodi di A+B+C

oppure:

A prova = new C(); // vedo i metodi di A+B+C
se........((C)prova).metododesiderato();

idem se:

B prova = new C(); // vedo i metodi di A+B+C
e se........((C)prova).metododesiderato();

dovrebbe essere così

[a2000]

Originariamente inviato da misterx
non è che stai un tantino esagerando ?

hai ragione, scusa, non vi importuno più.

anche perchè hai molte probabilità che venga a romperti i c@gli@ni direttamente live in Mailand !!!

cala la pasta !

[misterx]

in che cosa consiste in soldoni, l'interfaccia Iterator ?

[PGI]

Mettiamola così: Iterator è il nuovo Enumeration. Lo scopo è identico, definire il nome di alcuni metodi per lo scorrimento degli elementi di una lista (iterator ed enumeration hanno lo stesso, elementare, scopo).

La ragione della novità è "storica" ma ne faccio una supersintesi: java è un linguaggio standardizzato da Sun, ma il "vero" standard inizia dalla versione 1.2 e (speriamo) giunge a compimento con la 1.4. Standard va qui inteso come "standard dei nomi": tra le cose che sono cambiate, oltre alla notazione maiuscola di tutte le costanti (Color.WHITE è ignoto sub-1.4), c'è anche il nome dei metodi (next, get, length, size, in, out sono alcune delle "nuove" notazioni).

Sun non poteva semplicemente ridefinire Enumeration perchè il nuovo JFC richiedeva un metodo aggiunto (quel remove() ) : aggiungerlo ad Enumeration avrebbe reso incompatibili i vecchi sorgenti con le nuove API. Così ci ha messo una pezza, ha chiamato la new entry Iterator, in futuro Enumeration scomparirà (ancora non è deprecated ma scommetto un soldo che lo sarà presto).

&Ciao.

[misterx]

pensavo fosse una sorta di puntatore da richiamare quando desidero riposizionarmi all'inizio di una lista (array) di oggetti

[misterx]

l'ho sparata grossa ?

[PGI]

Pensavo fosse un'affermazione

Non è un puntatore, e questo è evidente, Java non ha i puntatori (almeno non nella forma a cui generalmente si pensa) e non ha un'aritmetica dei puntatori.

Ma se pensare al comportamento di un oggetto che possiede i metodi di un Iterator come ad un puntatore ti aiuta a comprendere meglio il suo funzionamento segui la strada del modello-puntatore.

Delle affinità (molto vaghe) potrebbero anche esserci: secondo l'aritmetica dei puntatori in C (per quel poco che ne so), l'incremento unitario di un puntatore ad un array "salta" all'interno degli elementi dell'array al successivo elemento.

Analogo è il comportamento di un iterator, quando viene creato punta al primo elemento di una serie, il next() passa al successivo, lo scorrimento però è unidirezionale.

Rinnovo comunque l'invito: pensa agli oggetti nel modo in cui ti aiuta di più a capirli (occhio però a non rifilare in giro la storia del puntatore )

[misterx]

lo tengo per me, ma sono convinto che sia un bel puntatore, come del resto gli oggetti di java rinominati, che altro non sono che le buone vecchie strutture del buon vecchio "C"

una dritta

ho una serie di stringhe ) file di testo, ne quale appaiono alcune frasi separate da particolari caratteri esempio:


frangean la biada col #rumor di# croste disse G.Gaber in #un suo# monologo molti anni fa
e se dopo bla bla #bla#


volevo usare lo StingTokenizer non sapendo se esiste già qualche metodo di una classe che fa di meglio il lavoro

che ne dici ?

[PGI]

E' pelino riduttivo il confronto che fai tra Java e C. Devi tener conto che Java non è nato da una costola di C, ma da più "costole" (Mesa, Beta, C, C++...). Anche qui, puoi usare le strutture C se ti aiuta a comprendere gli oggetti, ma un oggetto Java è una struttura quanto io sono una falena: abbiamo entrambi un DNA, ci muoviamo, ci piace la luce, ma, ad esempio, io non picchio la testa contro una lampadina accesa finchè qualcuno non la spegne.

Per lo StringTokenizer: direi che hai centrato lo scopo dell'oggetto, cioè separare una stringa in parti prendendo come "segnalatore" un carattere.

Tieni conto tuttavia che da quelle "ipotetiche" stringhe devi estrarre non ogni singolo pezzo ma solo quello contenuto tra i caratteri di marcatura #-#. La soluzione che troverai sarà poi valida (salvo un adattamento) anche quando dovrai affrontare il "parsing" delle voci di capitolo §-§ (§§...-§§...). Puoi usare uno StringTokenizer, ma il problema è se sia più semplice usare uno StringTokenizer oppure un metodo espressamente dedicato, perchè lo StringTokenizer è molto generico: non ti da solo quello che sta in mezzo ai tag, restituisce anche quello che sta prima e quello che sta dopo. Per capire se sia adatto dovresti chiederti che tipo di stringhe incontrerai: ad esempio, se in una linea ci fosse più di una parola chiave, io #tu# noi #voi# devi tener conto che solo "tu" e "voi" sono parole chiave, mentre "io " e " noi " non lo sono.

[misterx]

mah, ho bello che capito che mi tocca lavorare

ripiegherò su charAt()............contando i caratteri speciali (# o § oppure §§) e poi substring(start,fine) ed amenità simili

tutto sommato, il problema non è tanto scrivere le classi, giacchè ho visto che hai dato un'occhiata sul sito; il problema è capire e scrivere come piace agli altri

ci si sente blindati; e non mi è mai piaciuto

hai omesso il B ed il BCPL tra la catena di linguaggi da te menzionati