Newsgroup: it.comp.java
Titolo: overriding metodo e stringhe

Salve a tutti
ho 1 problemino penso di semplice soluzione:
classe obj padre con un metodo tostring
classe obj1 figlia
     metodotostring ridefinito:
     ritorna stessa stringa di metodo padre  però la scritta tra le
parole "\nReceiver: " e "/ncontent :" và modificata in maniera
opporuna
     come posso fare utilizzando il metodo della classe padre
super.tostring() nel metodo ridefinito a modificare solo quella parte
...penso si possa fare brevemente ma nn rieco a trovare il gisuto
metodo...
grazie per la collaborazione

 metodo...
Se ho ben capito cosa intendi dovrebbe tornarti utile il pattern Template:
http://exciton.cs.rice.edu/javaresources/DesignPatterns/TemplatePattern.htm
pole
-- 
ammentos - a lightweight persistence framework for JDK5
http://ammentos.biobytes.it
Flash tutorial: 
http://ammentos.biobytes.it/quickstart/quickstart.htm

 opporuna
Eh?
Non ho ben capito... quale scritta? quelle parole da dove vengono?
Saluti
CarMas


Usa il pattern tempate:
in sintesi:
nel padre:
String toString() {
	return "\nReceiver: " + getReceiver() + "\ncontent: " + getContent();
}
abstract String getReceiver();
abstract String getContent();
nelle classi figlie implementi i due metodi

dunque c siam capiti abbastanza però m sembra ke tale pattern nn possa
essere bene applicato al mio caso provo a chiarire
1)ho una classe astratta messaggio
2)La classe astratta messaggio ha i campi (privati) mittente
destinatario di tipo "persona" e altri campi (ora direi ininfluent) con
relativi metodi di set  e get e uno stringTO che stampa succintamente
il valore dei campi
3)La classe persona ha due campi stringa "nome" e "lavoro" i relativi
metodi di set e get e uno tostring che stampa un'ottput dei volori
sulla stessa linea
4)Messaggio è esteso da 3 classi messaggiopertutti messaggioperuno
messaggioperlavoro. il campo destinatario (di tipo persona) sarà
differente nelle tre classi .in sostanza in pertutti entrambi i campi
valgono null, in peruno c sia aspetta due stringhe, mentre in perlavoro
il campo nome del destinatario è a null
ora se io stampo messaggio (che può essere allocato di uno delle sue
tre sottoclassi) nel caso in cui si tratti di messaggiopertutti e
messaggioperlavoro in cui l'oggetto destinatario avrà i suoi campi
(uno o tutti e due a null) voglio ridefinire il metodo tostring: di
messaggio nelle sottoclassi in modo che:
si chiami nella redifinizione il metodo stringto di messaggio
(super.tostring() ) in un caso (in messaggiopertutti) scriva la
costante "per tutte le persone" (che rimane in
MEZZO alla  stringa restituita da super.tostring e dopo la parola
"receiver:" mentre nell'altro (mesaggioperlavoro) scriva (sempre nello
stesso punto) solo il campo lavoro dell'oggetto receiver di tipo
persona.
Penso si tratti di operazioni con le stringhe
super mi da un'espressione regolare deltipo: campo1: * campo2: * ....
campon:*
io voglio sostituire un * sapendo il nome del campo (la parola che
precede) intuitivamente la lunghezza della parola che voglio sostituire
(dove inizia campo successivo)
campo nel caso è "/nReceiver: " e campo successivo "/ncontent: "
Dovrei aver chiarito il dubbio.

 Dovrei aver chiarito il dubbio.
Uno dei principii fondamentali dell'OOD e' che le classi astratte
non abbiamo dipendenze (ne' esplicite ne' tantomento implicite) con
le eventuali classi da esse derivate.
Io vedo due possibilita':
1) la classe astratta di base (Messaggio) *non* implementa il
    metodo toString() perche' non ha sufficienti responsabilita'
    per comporre la stringa da ritornare.
    In questo caso sono solo le classi derivate che *sanno* come
    (e quindi *devono* preoccuparsi di) costruire *tutta* la stringa
    e quindi sono loro che reimplementano "da zero" il metodo toString()
2) la classe astratta di base definisce un contratto di implementazione
    che delega, alle classi derivate, la composizione *solo* di alcune parti
    della stringa che deve essere ritornata da toString().
    In questo caso si applica il pattern Template (come suggerito in altri
    post) ed e' sicuramente una soluzione piu' "pulita" di quella da te
    suggerita: andare a "lavorare" di sostituzioni di stringhe ti puo' creare
    solo problemi in fase di manutenzione del codice e non rende sufficientemente
    esplicite le responsabilita' della classe base e di quelle derivate.
Vai di Template! ;)
Ciao!
Roberto

guardando emglio la classe string una soluzione l'ho trovata spero si
possa fare un pò meglio magari con espressioni regolari o un metodo +
semplice...
int indexOf(String str): scandisce la stringa dall'inizio alla fine, e
verifica se contiene o meno la stringa specificata come parametro. Se
la trova, restituisce l'indice del primo carattere della sotto stringa
cercata, altrimenti restituisce -1
posso scannare la stringa di super e cercare "receiver:" ottengo
l'index della r (lo chiamo r)
stessa cosa con "content:"  ottengo l'index della c (lo chiamo c)
la sottostringa di super da 0 a r+7 + NUOVA STRINGA +la sottostringa di
super da c a finestringa

i getreceiver devono darmi un'oggetto persona nn una stringa
getreceiver().getnome()
ne ho necessità per altre classi.. il receiver è in ogni messaggio
deve solo fare un  return
io direi visto quanto detto prima sulle stringhe :
implemento to string con quello di comune a tutte (nn stampo il valore
receiver) dopo la stringa receiver: .
nelle singole classi ridefinsco (esistesse un solo metodo o cmq
un'espressione succinta per farlo sarebbe meglio) in modo da
completarlo opportunamente (ho delle specifiche che prevedono ciò)
comunque la dipendenza tra classe astratta e sue classi di
implemntazioni sta nella relazione di generalizzazione ereditarietà
quindi è intuitivo mettere qualcosa in più... .

amntcx wrote:

Credo che tutti coloro che ti hanno risposto conoscano bene
i metodi della classe String ed in particolare anche indexOf(String):
semplicemente non te l'hanno suggerito perche' la strada che vuoi
percorrere e' una "accrocchiata" che sta su con lo scotch...
E' molto meglio una soluzione piu' strutturale, che ti permette una
migliore manutenibilita' ed estendibilita' del codice.
Poi sei ovviamente libero di procedere come credi...
Ciao!
Roberto

 quindi è intuitivo mettere qualcosa in più... .
E' evidente che una classe derivata ha una dipendenza con quella
da cui deriva! Quello che ti ho detto io e' che la dipendenza *non*
deve invece esistere tra la classe base e le sue derivate: tu *devi* poter
utilizzare la classe base in altri contesti *senza* essere costretto
a "portarti dietro" (come codice o come vincoli impliciti) le classi derivate.
Occhio, perche' la differenza e' sostanziale!
Ora, se tu scrivi all'interno del metodo toString() della classe
base una stringa "pattern" che contiene "segnaposti" per dati
che la classe base stessa non definisce di possedere (nemmeno in
modo astratto), ecco che hai creato una dipendenza implicita!
Ogni volta che ci si trova di fronte a situazioni analoghe,
dovrebbe sempre suonare un campanello di allarme in testa che
dovrebbe stimolare a rivedere il design.
Poi lo ripeto: fai come ti pare...
Ciao!
Roberto

mi rendo perfettamente conto del fatto che è accrocchiata infatti
penso che comunque esista qualcosa di più rapido e pulito per fare una
simile sostituzione... (qualche metodo di manipolazione più potente)
il template però nn posso applicarlo proprio così alla lettere (forse
m sbaglio ma.. ?)
il metodo getreceiver() stampato (... ..lo stringto di persona..) nn
restituisce la stringa che vado a stampare (se nn in un caso:
messaggioperuno) e nn lo devo (nn posso) toccarlo, negli altri deve
essere la costante "messaggio per tutti" o il campo lavoro.
-i metodi di mesaggio di get receiver restituisce una persona.
-lo stringto di persona deve stampare i 2 campi (lo uso in messagigio
per uno)
per applicare il template dovrei aggiunger un nuovo metodo (ho delle
specifiche molto dettagliate in cui nn è previsto ciò ma al più
sottintende la possibilità di ridefinire to string di messaggio nelle
sue classi di implementazione fare) così:
in string to (di message) dove stampo la stringa ingriminata scrivo
getreceiver()
abstract string getreceiver() sarà un nuovo (!) metodo implementato
differenetemente nelle tre calssi (che userà probabilmente il
getreceiver che restituisce l'oggetto receiver persona) e a seconda
della classe stampa una cosa diversa.
ammesso che l'implementazione di cui sopra sia tale da seguire il
pattern (spero di sì :) se ho ben compreso :| )
la mia soluzione (più che altro la direzione che prendevo con essa) di
sola sostituzione del pezzettino e riuso di qullo maggiore era guidata
più che altro dal risparmi di scrittura di cosdice nuovo e maggiore
riusabilità di quello vecchio.

 essere la costante "messaggio per tutti" o il campo lavoro.
Non vedo dove sta il problema: il getReceiver() sarebbe *comunque*
da ridefinire in tutte le classi derivate da Messaggio.
In piu' non mi sembra ci sia bisogno di "toccare" la classe Persona.
Io la vedo cosi' (per come l'hai raccontata...):
[...]
/** Questa non la tocchiamo... */
public class Persona
{
    private String nome;
    private String lavoro;
    [...]
    public String getNome() { return nome;}
    public String getLavoro() { return lavoro;}
    [...]
}
[...]
/** Utilizza il Template pattern per comporre
     la stringa ritornata da toString() */
public abstract class Messaggio
{
    protected Persona mittente;
    protected Persona destinatario;
    [...]
    public Persona getDestinatario() { return destinatario;}
    [...]
    protected abstract String getReceiver();
    protected abstract String getContent();
    String toString() {
     return "\nReceiver: " + getReceiver() + "\ncontent: " + getContent();
    }
}
[...]
public class MessaggioPerUno
{
    [...]
    protected String getReceiver()
    {
       return destinatario.getNome();
    }
    protected String getContent()
    {
       [...]
    }
}
[...]
public class MessaggioPerTutti
{
    [...]
    protected String getReceiver()
    {
       return "per tutte le persone";
    }
    protected String getContent()
    {
       [...]
    }
}
[...]
public class MessaggioPerLavoro
{
    [...]
    protected String getReceiver()
    {
       return destinatario.getLavoro();
    }
    protected String getContent()
    {
       [...]
    }
}
Vedi tu...
Ciao!
Roberto

beh .. ci penso su.. .. :)
grazie cmq

 
Mi sono accorto che, nel codice che ho scritto, ci sono
alcuni errori *sostanziali*:
[...]
public class MessaggioPerUno extends Messaggio
                              ^^^^^^^^^^^^^^^^^^ MANCAVA!
[...]
public class MessaggioPerTutti extends Messaggio
                                ^^^^^^^^^^^^^^^^^^ MANCAVA!
[...]
public class MessaggioPerLavoro extends Messaggio
                                 ^^^^^^^^^^^^^^^^^^ MANCAVA!
[...]
Ciao!
Roberto