Ereditarietà - modificatore "protected"

1 visualizzazione
Passa al primo messaggio da leggere

Giulio Petrucci

da leggere,
23 gen 2007, 05:09:4823/01/07
a
Ciao a tutti,

sto sviluppando delle utilities per il riutilizzo interno. Mi capita di
dover "imporre" che tutte le classi che ereditano da qualche altra
classe implementino un certo metodo "protected". Ora, ho letto da
qualche parte che è bene preferire le interfacce alle classi astratte
(per motivi ovvi), ma come faccio tramite interfaccia ad imporre
l'implementazione di un metodo protected? Devo necessariamente passare
per una classe astratta?

Ciao,
Giulio

Marco Minerva

da leggere,
23 gen 2007, 06:15:1523/01/07
a
> "Giulio Petrucci" <giulio....@thisisafakedomain.com> ha scritto nel
> messaggio news:efBpaat...@TK2MSFTNGP03.phx.gbl...

Ciao!

I metodi definiti in un'interfaccia devono necessariamente essere public,
quindi credo che nel tuo caso serva proprio una classe astratta.

--
Marco Minerva, marco....@gmail.com
http://blogs.ugidotnet.org/marcom

GLuca

da leggere,
23 gen 2007, 07:41:0123/01/07
a

"Giulio Petrucci" ha scritto:
...


>Ora, ho letto da
> qualche parte che è bene preferire le interfacce alle classi astratte
> (per motivi ovvi)

scusate se mi intrometto ma prendo come spunto questa affermazione per
chiedervi se potreste darmi qualche parere per il quale preferire le
interfacce alle classi

ciao e grazie

Giulio Petrucci

da leggere,
23 gen 2007, 08:10:0723/01/07
a
Ciao GLuca,

GLuca ha scritto:
> scusate se mi intrometto

Prego, prego... c'è posto... ;-)

> ma prendo come spunto questa affermazione per
> chiedervi se potreste darmi qualche parere per il quale preferire le
> interfacce alle classi

Credo perchè mentre non puoi ereditare da due classi diverse (in quanto
linguaggi come C# o Java non ammettono l'ereditarietà multipla), puoi al
contrario implementare tutte le interfacce che vuoi. Tuttavia,
rileggendo le "Design Guidelines" di Cwalina, ho letto:

"Do prefer classes over interfaces."

La cosa mi pare strana. Credo comunque che la scelta giusta nel mio caso
sia quella di definire classi astratte, poi di estrarre le interfacce
(http://www.refactoring.com/catalog/extractInterface.html) e dare a chi
riutilizzerà il package le indicazioni per ereditare da queste classi
astratte, oppure di usarle wrappate nelle loro classi che comunque
implementino le interfacce di cui sopra.

Ciao,
Giulio

--
OnAir: the Gathering - "In Between"

Riccardo

da leggere,
23 gen 2007, 09:46:1723/01/07
a
Giulio Petrucci ha scritto:

> rileggendo le "Design Guidelines" di Cwalina, ho letto:
> "Do prefer classes over interfaces."
> La cosa mi pare strana.

Non e' strana. Anzi, spesso e' piu' comodo usare delle classi in quanto
e' possibile arricchirle con delle implementazioni mentre come ben si
sa le interfacce permettono soltanto di definire dei membri public.
Quindi, usando le classi in alcuni casi puoi scrivere meno codice. In
altri invece e' necessario usare le interfacce ad es. per la
possibilita' di implementarne piu' di una e/o perche' e' necessario
evitare di fornire implementazione.

Ciao
Riccardo

Corrado Cavalli [MVP]

da leggere,
23 gen 2007, 14:30:1323/01/07
a
Personalmente sono della stessa opinione espressa da Cwalina, vedo molto
spesso un abuso di interfacce perche' "i testi di riferimento" indicano di
"programmare verso un interfaccia e non verso la sua implementazione",
peccato che spesso, queste affermazioni vengono da puristi che di codice e
"mondo reale" ne hanno visto poco (l'esempio relativo a Stream e' una
motivazione per utilizzare una classe astratta rispetto ad un interfaccia)
Personalmente applico spesso quando citato da Richter: "Define an Interface
first and an abstract class that implements it" cosi come come ritengo
quanto mai corretto usare per la scelta di interfaccia verso classe astratta
la relazione "Is-a" vs "Can-Do" (Pag.83)

--
Corrado Cavalli [Microsoft .NET MVP-MCP]
UGIdotNET - http://www.ugidotnet.org
Weblog: http://blogs.ugidotnet.org/corrado/


Andrea Saltarello [UGIdotNET][MVP]

da leggere,
23 gen 2007, 16:55:1723/01/07
a
> Personalmente sono della stessa opinione espressa da Cwalina, vedo molto
> spesso un abuso di interfacce perche' "i testi di riferimento" indicano di
> "programmare verso un interfaccia e non verso la sua implementazione",
Oh, come mi piacciono questi discorsi... <g> Ecco un paio di considerazioni:
http://blogs.ugidotnet.org/pape/archive/2007/01/23/ClassiVsInterfacce.aspx

> Personalmente applico spesso quando citato da Richter: "Define an
> Interface first and an abstract class that implements it"

+1


--
.A [Microsoft MVP .NET]
UGIdotNET - User Group Italiano .NET
http://www.ugidotnet.org
Read my blog at: http://blogs.ugidotnet.org/pape

Rispondi a tutti
Rispondi all'autore
Inoltra
0 nuovi messaggi