Virtual,abstract .NET

dna_programmer

il 27 ago 2012, 17:08

48 risposte

48 Risposte - Pagina 3

B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
03 set 2012, 09:17
Se una classe è abstract non puoi istanziarla (e infatti istanzi un rettangolo) ma l' oggetto creato lo puoi usare attraverso l' interfaccia di Figura.

Avrai tra le mani un oggetto che puoi usare come una Figura, quindi richiamare tutti i metodi che la classe Figura espone (ad esempio Draw). Non potrai richiamare gli eventuali metodi aggiunti dalla classe Rettangolo, perchè per te quella è solo una Figura. Però quando richiami il metodo Draw vedrai disegnare un rettangolo.

In un ipotetico form che contiene un insieme di Figure vedrai cerchi, rettengoli ecc, però probabilmente a te basta manipolarli con i metodi della classe Figura per cui avrai semplicemente un List<Figura>, e la classe Figura esporrà i metodi per disegnarli, spostarli, ridimensionarli ecc.

Altrimenti come faresti? Come potresti gestire un insieme (di dimensione non prefissata) di oggetti simili ma di tipo diverso?
D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
03 set 2012, 12:45
Si ma ora mi sorge un dubbio , quando ho:
```
 figura c= new rettangolo()
```
io in memoria ho una figura o un rettangolo? Se punto al rettangolo perché posso usare solo i metodi di figura?
B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
03 set 2012, 13:10
In memoria hai un Rettangolo, ma dato che lo stai puntando con un Figura puoi usare solo i metodi di Figura. Se fai un cast a Rettangolo potrai usarlo come un Rettangolo.
D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
03 set 2012, 13:26
Oddio, mi è venuta un pò di confusione, scusa allora che ci guadagno a usare il polimorfismo

se io ho una classe astratta figura e ho un metodo disegna astratto, poi questo lo implemento i rettangolo per disegnare un rettangolo, come faccio
```
figura x=new rettangolo();
```
poi se faccio
```
x.disegna();
```
sta richiamando il metodo disegna di figura che è astratto, cosa succede, non è implementato
scusami ma mi potresti chiarire questo concetto.Grazie ancora
B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
03 set 2012, 13:39
Non è che ci guadagni, è che in certe circostanze lo 'devi' utilizzare. In particolare quando la creazione degli oggetti avviene a run-time e non sai cosa potrà essere creato.

Supponi che la creazione della figura avvenga a run-time, ad esempio hai tre bottoni, se premi il primo crei un cerchio, col secondo un triangolo e col terzo un trapezio.

Immagina poi di dover assegnare questa figura ad un puntatore e di doverla disegnare, come fai? Di che tipo è il puntatore a cui la assegni?

Poi ricorda che un metodo astratto è anche virtual, per cui viene chiamato quello ridefinito.

dna_programmer

Utente Attivo

Iscritto da: apr, 2012

Messaggi:: 373

Re: Virtual,abstract .NET

03 set 2012, 13:48

Quindi nel caso dei tre bottoni più o meno è così(dimmi se sbaglio)

codice C++



class figure
{
  public:
           virtual void disegna()=0;
}
//---------------------------------------------//
class rettangolo:public figure
{
  public:
           virtual void disegna()
           {
             drawrettangle();
           }

         float area_rettangolo()
         {
           return b*h;
        }
}
//e altre figure
//-----------------------------------------------------------------//
int main()
{
   //ipotizzando evento click del button dei rettangoli

  figura * x= new rettangolo();
  
  x->drawrettangle();//disegno un rettangolo

  //x essendo una figura , lo punto a rettangolo , però posso solo richiamare i metodi che stanno
 //sia in figura che in rettangolo(in questo caso drawrettangle) giusto?
 //per richiamare ad esempio il metodo area_rettangolo devo avere un oggetto di tipo rettangolo
// esempio

   rettangolo * y=new rettangolo();

   cout<< y->area_rettangolo()<<endl;
}

B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
03 set 2012, 13:53
Esatto, tutto giusto.

Poi, visto che l' area è un concetto che appartiene a tutte le figure, la classe Figura potrebbe anche avere in metodo virtuale Area.
D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
03 set 2012, 14:07
Oyeahh !! xD
si,era solo per evidenziare la differenza.

Per quanto riguarda le interfacce è sempre lo stesso concetto?
B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
03 set 2012, 14:08
Esatto, puoi istanziare una classe e poi usarla con un puntatore ad una delle sue interfacce.
D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
19 set 2012, 23:59
Scusate se riprendo il post dopo un po di tempo, volevo chiedervi, io piu o me ho capito questi due concetti, peró mi potreste fare un esempio pratico( anche semplice) di quando è meglio usare un abstract e quando usare un'interfaccia. Vi ringrazio sempre per la pazienza
B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
21 set 2012, 11:48
Riassumendo, una classe abstract è una classe che non vuoi che sia istanziata, una interfaccia non è una classe ma un elenco di metodi, una classe che implementa una interfaccia è obbligata a implementare questi metodi.

Detto questo fare degli esempi belli è difficile, e poi non ci sono regole ferree la stessa cosa spesso puoi farla in maniere differenti.

Se hai una gerarchia di animali li fai discendere da una classe Animale, pero istanziare un animale non ha senso, istanzi Cani, Gatti e Cavalli. Quindi la classe Animale è astratta. Stesso discorso per FigureGeometriche da cui derivi Cerchio e Quadrato, o per Control da cui derivi Button, ComboBox, Image.

A un array di elementi ordinati cosa passi?, beh a questo array basterebbe sapere che la classe che gli passi ha un metodo 'Compare', in questo modo riesce a ordinarli. Per cui potrebbe accettare tutte le classe che implementano l' interfaccia IComparable che dichiara il metodo compare.

Se stai facendo il programma di uno zoo probabilmente userai la classe astratta Animale, pero potresti aver anche bisogno di tener in ordine alfabetico gli elenchi di animali per cui dichiari 'abstract class Animale: IComparable', è una classe astratta che inoltre implementa una interfaccia.
D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
20 ott 2012, 15:10
Ok,ma cosa vuol dire è "una classe astratta che implementa un interfaccia"?

in pratica la classe astratta si porta dietro anche magari alcuni metodi implementati , mentre invece implementando un'interfaccia, la classe non si porta dietro niente, ma solo di rispettare il fatto di dover PER FORZA implementare tutti i metodi dell'interfaccia che si sta implementando.
Ho capito bene?

barba59

Molto attivo

Iscritto da: feb, 2012

Messaggi:: 1353

Re: Virtual,abstract .NET

21 ott 2012, 17:53

Ciao dna_programmer

Hai capito giusto, ecco un esempio tanto per rendere le cose concrete:


    abstract class Animal: IComparable
    {
        public string Name { get; set; }

        protected Animal(string name)
        {
            Name = name;
        }

        public int CompareTo(object o)
        {
            Animal other = o as Animal;
            return Name.CompareTo(other.Name);
        }
    }

    class Cat: Animal
    {
        public Cat(string name)
            : base(name)
        {
        }
    }

    class Dog : Animal
    {
        public Dog(string name)
            : base(name)
        {
        }
    }

    class AnimalFarm
    {
        public List<Animal> Animals { get; set; }

        public AnimalFarm()
        {
            Animals = new List<Animal>();

            Animals.Add(new Cat("Minou"));
            Animals.Add(new Cat("Matisse"));
            Animals.Add(new Dog("Lessie"));

            Animals.Sort();
        }
    }

D
dna_programmer
Utente Attivo
Iscritto da
apr, 2012
Messaggi:
373
Re: Virtual,abstract .NET
27 dic 2012, 22:19
Ciao barba, scusa se riprendo l'argomento dopo un sacco di tempo solo che rilegendo mi è venuto un dubbio:

quando faccio
```
Array x = Array.CreateInstance(typeof(int), 10);
```
come dici tu vedendo col debugger mi ritorna "System.Array {int[]}".
Ecco quest'ultimo cosa sarebbe, una classe?
E poi una cosa, il metodo "CreateInstance" come fa a sapere se deve ritornare un "System.Array {int[]}" oppure un "System.Array {double[]}" ecc, all'interno ci sono una serie di IF?

Mi scuso ancora per aver ripreso l'argomento dopo tanto tempo e spero che non mi prenderai a male parole
Ciao e grazie ancora
B
barba59
Molto attivo
Iscritto da
feb, 2012
Messaggi:
1353
Re: Virtual,abstract .NET
30 dic 2012, 17:36
Ciao dna_programmer,
dna_programmer ha scritto:
spero che non mi prenderai a male parole
Figurati è un piacere, l' unico problema è che in questo periodo sono molto preso dal lavoro (e questo è un bene) e mi rimane pochissimo tempo da dedicare al forum (e questo è un male).

Metodi come CreateIstance si chiamano 'Factory metod' se leggi qualcosa sui design pattern li trovi sotto i pattern creazionali (è una lettura interessante e te la consiglio).

Il loro scopo è quello di creare un opportuno derivato di una certa classe, se ne scriverai qualcuno probabilmente lo farai scrivendo una serie di if (ed è un sistema giusto).

Questo in particolare (Array.CreateInstance) è un po più problematico e ad essere sincero non so come è implementato, sicuramente non è una serie di if perchè può creare array di classi che inventi tu. Ad esempio:
```
class Pippo
{
   int a;
}

....

Array x = Array.CreateInstance(typeof(Pippo), 10);
```
Probabilmente userà qualche sistema legato alla 'reflection' (prova a leggere qualcosa anche su questo che è interessante e potentissimo).

Ciao e buone feste!

Devi accedere o registrarti per scrivere nel forum

48 risposte