[Domanda] Polimorfismo

di il
16 risposte

[Domanda] Polimorfismo

Buongiorno ,

Ho creato un esempio per capire meglio l'importanza di questo concetto che ovviamente non metto in dubbio ,ma non mi convince.
Forse è l'esempio che ho creato che non rende bene l'idea.

Nell'esempio che segue posso creare attraverso l'istanza della classe brick , un mattone oppure una riga di mattoni con rowBrick

Di istinto mi viene da pensare che avrei potuto creare due classi distinte assegnando ai metodi lo stesso nome anche se con differente signature
Forse l'esempio è troppo banale per cogliere l'importanza del polimorfismo ?
l'overload di un metodo si usa solo nel polimorfismo?
Nella classe rowBrick , dove richiama il costruttore della classe super

   super("Questo è una riga di mattoni");
Eventualmente posso leggere il valore della stringa della classe brick(super class) tramite apposito metodo ?

Grazie mille


main

public class Polymorphism {
    public static void main(String[] args) {
        
        brick mattone = new brick("Mattone rosso");
        rowBrick rigaMattoni = new rowBrick();
        
        mattone.setPosX(100);
        rigaMattoni.setPosX(100,10);
    }
}     
subclass

public class rowBrick extends brick{

    public rowBrick() {
        super("Questo è una riga di mattoni");
    }

    public void setPosX ( int value, int howmany) {
        this.posX = value;
        System.out.println("from PosX: "+ this.posX + " to n brick: " + howmany);
    }
    public void setPosY ( int value, int howmany) {
        this.posY = value;
        System.out.println("from PosY: "+ this.posY + " to n brick: " + howmany);
    }    
}
super class

public class brick {
    
    String name;
    int posX;
    int posY;
    
    public brick(String name) {
            this.name = name;
    }
    
    protected void setPosX ( int value) {
        this.posX = value;
        System.out.println("PosX: "+ this.posX);
    }
    protected void setPosY ( int value) {
        this.posY = value;
        System.out.println("PosY: "+ this.posY);
    }
}

16 Risposte

  • Re: [Domanda] Polimorfismo

    Due metodi, anche se anno lo stesso nome, ma hanno parametri diversi, sono A TUTTI GLI EFFETTI metodi distinti.

    Brick e RowOfBrick non vanno bene perche RowOfBrick e' una COLLEZIONE di Brick: l'esempio non e' ideale.

    Esempio migliore: Animale (classe base), Cane (deriva da Animale), Gatto (deriva da Animale).

    Ogni Animale 'mangia', MA Cane 'mangia' la carne, Gatto 'mangia' il pesce.

    Se aggiungi Umano (deriva da Animale), Umano 'mangia' TUTTO (compresi i cani ed i gatti )
  • Re: [Domanda] Polimorfismo

    Buongiorno ,

    Ho seguito il tuo esempio. Spero sia giusto. Mentre per la stringa che e contenuta in super()...Viene letta dal costruttore della super classe?
    che fine fa?
    come posso leggerla? A cosa serve?

    scusate il 3° grado eh :9
    Grazie

    Main
    
    public class Polymorphism {
        public static void main(String[] args) {
            
            gatto gatto  = new gatto("Gatto");
            cane  cane = new cane("Cane");
            uomo  uomo = new uomo("uomo");
            
            Animale Animale = new Animale("Animale");
            
            gatto.Mangia("Pesce");
            cane.Mangia("Gatto");
            uomo.Mangia("Cane e Gatto");
            
            Animale.Mangia("Specifica quale animale");
        }
    }
    
    Super classe
    
    public class Animale {
        
        private String name;
        private String cosaMangia;
        
        public Animale(String name) {
                this.name = name;
        }
        protected void Mangia ( String cosaMangia) {
            this.cosaMangia = cosaMangia;
            System.out.println(name + " mangia :" + this.cosaMangia);
        }
    }
    
    classe cane
    
    public class cane extends Animale{
    
        private String cosaMangia;
        private String name;
        
        public cane(String name) {
            super("Questo è un cane");
            this.name = name;
        }
    
        protected void Mangia ( String cosaMangia) {
            this.cosaMangia = cosaMangia;
            System.out.println(this.name + " mangia :" + this.cosaMangia);
        }
    }
    
    classe gatto
    
    public class gatto extends Animale{
    
        private String cosaMangia;
        private String name;
        
        public gatto(String name) {
            super("Questo è un gatto");
            this.name = name;
        }
        protected void Mangia ( String cosaMangia) {
            this.cosaMangia = cosaMangia;
            System.out.println(this.name + " mangia :" + this.cosaMangia);
        }
    }
    
    classe uomo
    
    public class uomo extends Animale{
    
        private String cosaMangia;
        private String name;
        
        public uomo(String name) {
            super("Questo è un Uomo");
            this.name = name;
        }
        protected void Mangia ( String cosaMangia) {
            this.cosaMangia = cosaMangia;
            System.out.println(this.name + " mangia :" + this.cosaMangia);
        }
    }
    
  • Re: [Domanda] Polimorfismo

    Cyrano ha scritto:


    l'overload di un metodo si usa solo nel polimorfismo?
    L'overloading è un caso di polimorfismo ma solo nel senso basilare e letterale del termine (poli-morfo = più forme). Cioè un concetto che è implementato con più metodi con lo stesso nome ma con "input" differenti. E tra l'altro la risoluzione dell'overloading avviene a tempo di compilazione, da parte del compilatore.
    Ma NON è il polimorfismo come inteso e reso possibile dalla ereditarietà.


    La ereditarietà invece permette il "vero" polimorfismo. Cioè un tipo che può essere visto anche come altri tipi. Detto in generale, la ereditarietà permette di definire una relazione di generalizzazione/specializzazione tra due tipi. Il supertipo è un caso più generale mentre il sottotipo è un caso più specifico, particolare.

    Dato un GattoPersiano che deriva da Gatto, che deriva da Animale, GattoPersiano è un caso particolare di Gatto e Gatto è un caso particolare di Animale. Quindi un GattoPersiano è-un Gatto ma anche è-un Animale.

    Per farti capire meglio il concetto ti faccio un esempio (classico) di ereditarietà sbagliata. Facciamo una classe Punto2D:
    public class Punto2D {
        private double x;
        private double y;
    
        // ... costruttore/i, metodi getter/setter, ecc...
    }
    Fin qui tutto ok e tutto corretto. Qualcuno potrebbe pensare (e l'ho visto fare sui forum) di estendere Punto2D così:
    public class Punto3D extends Punto2D {
        private double z;
    
        // ... costruttore/i, metodi getter/setter, ecc...
    }
    Quindi ogni oggetto Punto3D ha effettivamente 3 campi x/y/z e i relativi metodi getter/setter. Ha senso?
    Se ci fosse da qualche parte un metodo es.

    public boolean verificaDistanza(Punto2D p1, Punto2D p2)

    per il compilatore sarebbe perfettamente lecito che tu possa passare es. un Punto2D come primo argomento e un Punto3D come secondo. Ma cosa potrebbe fare verificaDistanza? Non userebbe certo lo 'z' del secondo Punto3D. E se invece verificaDistanza fosse anche scritto per sapere e testare che gli argomenti possono essere dei Punto3D, comunque non potrebbe fare nulla di utile/sensato con Punto2D e Punto3D.

    Tutto questo infatti è SBAGLIATO e non ha senso. E per un motivo molto semplice: un punto in 3D NON è un "caso particolare" di punto in 2D .... è proprio un'altra cosa!

    Quindi se vuoi che una classe B estenda una classe A, devi sempre domandarti: il tipo B è un caso particolare di A ?
  • Re: [Domanda] Polimorfismo

    Penso di aver capito grazie

    esempio
    
    public class MapPaintPanel extends JPanel {
    
    edit:
    MapPaintPanel è un caso particolare di JPanel perchè è basato su JPanel ma può fare anche altre cose, ad esempio decidere come e cosa disegnare
  • Re: [Domanda] Polimorfismo

    Buonasera ,

    Riprendo questo argomento , sperando che il topic che non sia considerato troppo vecchio:
    in Java2d ,ho tentato più volte di disegnare più figure geometriche utilizando sempre una sola riga dove compare il metodo draw
    Nel codice che segue , il programma scandisce una lista di oggetti e poi li disegna. Sono tutti quadrati.
    
    for (int u =0 ; u < elementList.size(); u++)
        {
            Element square;
            square= elementList.get(u);
            square.draw(dbg,id);
        }  
        
    
    Qui dove aggiungo oggetti alla lista;
    
                square = new Element(xCoord,yCoord,gridCellWidth,gridCellHeight);
                square.setColor(Color.WHITE);
                square.setTickness( 1.0f);
                elementList.add(square);
    
    Dovessi scrivere al posto del codice di sopra , come segue:
    
                square = new Element(xCoord,yCoord,gridCellWidth,gridCellHeight);
                square.setColor(Color.WHITE);
                square.setTickness( 1.0f);
                elementList.add(square);
    
    
                oval = new Oval(xCoord,yCoord,gridCellWidth,gridCellHeight);
                oval.setColor(Color.RED);
                oval.setTickness( 1.0f);
                elementList.add(oval);
    
    
    e ipotizzando che abbiano il metodo draw() Overloaded
    Quando scandisco nuovamente la lista per disegnare gli oggetti ( qui sotto riprendo il codice di prima per comodità) devo scrivere:
    
    for (int u =0 ; u < elementList.size(); u++)
        {
            Element square;
            square= elementList.get(u);
            square.draw(dbg,id);
        }  
    
    Come faccio a disegnarli tutti visto che non conosco in anticipo la natura dell'oggetto?
    Esiste una soluzione che si basa su OOP , oppure devo iniziare a scrivere delle IF..
    non so se mi sono spiegato bene , grazie
  • Re: [Domanda] Polimorfismo

    Cyrano ha scritto:


    e ipotizzando che abbiano il metodo draw() Overloaded
    No, overridden, vedi sotto.

    Cyrano ha scritto:


    Come faccio a disegnarli tutti visto che non conosco in anticipo la natura dell'oggetto?
    Esiste una soluzione che si basa su OOP , oppure devo iniziare a scrivere delle IF..
    L'approccio "se tipo X fai x, se tipo Y fai y ecc... " con if-else è appunto anti-OOP.

    Quello che serve in questi casi è un tipo base più generalizzato. Ad esempio un tipo es. FiguraDisegnabile, da cui deriveranno poi i sottotipi es. Ovale, Quadrato, ecc...
    Ora, l'unica questione (molto "fine") è se il tipo base deve essere una interfaccia oppure una classe (astratta o no). Dipende .... dal concetto rappresentato, da cosa deve eventualmente contenere come dati base e altri aspetti.

    FiguraDisegnabile fa pensare alla sola capacità di saper disegnare una figura. Quindi un "comportamento" abbastanza trasversale a più categorie di oggetti. E si potrebbe pertanto definire con una interfaccia, per esempio:
    public interface FiguraDisegnabile {
        void draw(Graphics2D g2d);
    }
    Quindi poi avrai N implementazioni es.
    public class Quadrato implements FiguraDisegnabile {
        // es. campi x, y, width, height ecc...
        // ...
    
        public void draw(Graphics2D g2d) {
            // qui disegni
        }
    }
    Il draw in Quadrato non è un overload ... è una implementazione del draw dell'interfaccia che tecnicamente deve seguire le regole dell'overriding.

    Quando avrai le tue N implementazioni, userai es. un List<FiguraDisegnabile> ( o array FiguraDisegnabile[] ) e dentro ci potrai inserire QUALUNQUE oggetto che implementa FiguraDisegnabile, anche in modo eterogeneo (es. un Quadrato, due Ovale, ecc...)

    Quando scansionerai lista/array "vedrai" gli oggetti solo come FiguraDisegnabile che è sufficiente per vedere il draw, che negli oggetti sarà per certo implementato. E quando il draw verrà invocato, sarà eseguito quello dell'oggetto realmente istanziato (se l'oggetto i-esimo è un Quadrato, sarà il suo draw, se un Ovale, sarà il suo draw, ecc..).

    Questo è il polimorfismo.
  • Re: [Domanda] Polimorfismo

    Che bello ! Molto interessante. Se non chiedo troppo rispondi quando ti va , che differenza ci sarebbe stata con una classe astratta in questo caso.
    Grazie mille
  • Re: [Domanda] Polimorfismo

    Cyrano ha scritto:


    che differenza ci sarebbe stata con una classe astratta in questo caso.
    La differenza tecnica è che con una interfaccia base le classi avranno implements InterfacciaBase mentre con una classe base avranno ovviamente extends ClasseBase

    Se usare interfaccia o classe base ... è molto più fine. Dipende dal concetto e senso del tipo base. Un FiguraDisegnabile fa più pensare alla capacità di saper disegnare una figura e potrebbe quindi essere un concetto trasversale a molte tipologie di oggetti, es. quadrati, ovali ma anche ad esempio icone.

    Se invece penso ad un nome Figura2D e magari voglio che già tutti gli oggetti abbiano sempre un campo Color, potrei pensare Figura2D come classe astratta con un campo colore e il draw() astratto:
    public abstract class Figura2D {
        private Color colore;
    
        // getter ecc...
    
        public abstract void draw(Graphics2D g2d);
    }

    Ma anche in questo caso sarebbe possibile "astrarre" di più avendo una interfaccia al livello più astratto:
    public interface FiguraDisegnabile {
        Color getColore();
        void draw(Graphics2D g2d);
    }
    poi una classe intermedia di "convenienza" (per non ripetere il campo):
    public abstract class Figura2D implements FiguraDisegnabile {
        private Color colore;
    
        // .....costruttore ecc...
        // implementa il getColore()
    }
    E poi Quadrato, Ovale ecc.. che estendono da Figura2D.
  • Re: [Domanda] Polimorfismo

    Grazie ci rifletterò sopra
  • Re: [Domanda] Polimorfismo

    Scusami ma mi viene ancora di istinto usare le IF in questo altro caso:

    Tramite un Keyevent scelgo se creare un quadrato o un ovale.Ad esempio premento [O] per ovale e la lettera [Q] per quadrato.
    Il problema e che quando devo inserire l'oggetto nella lista , devo comunque fare un IF per decidere se inserire un oggetto Quadrato o Ovale.
    Non ho un riferimento 'vuoto' al quale inserire l'indirizzo dell'oggetto ovale o quadrato a seconda della scelta con keyevent.
    Non posso nemmeno passare l'oggetto ad una funzione incaricata di inserirlo nella lista , perchè gli oggetti sono di diverso tipo.
    Ovvero non so se c'e un ref o un contenitore per ospitare oggetti differenti.( mi viene da dire puntatore , ma probabilmente sbaglio anche perchè non esistono in java)
    Forse mi sono spiegato male

    Edit:
    Ad esempio questo è un errore:
    
              if (Collision(xCoord,yCoord,elementList))
                  addElement = false;
              else
                  addElement = true;
    
              if (addElement && !removeOnCollision)
              {
                if (id == 1)
                {
                    square = new Oval (xCoord,yCoord,gridCellWidth,gridCellHeight);  // <<-----
                }
                else
                {
                    square = new Element(xCoord,yCoord,gridCellWidth,gridCellHeight); // <<-----
                }    
                   /* metodi in comune */        
                    square.setColor(Color.WHITE);   
                    square.setTickness( 1.0f);
                
                   /* aggiorno lista */
                    elementList.add(square);
              }      
     
  • Re: [Domanda] Polimorfismo

    Cyrano ha scritto:


    Tramite un Keyevent scelgo se creare un quadrato o un ovale.Ad esempio premento [O] per ovale e la lettera [Q] per quadrato.
    Il problema e che quando devo inserire l'oggetto nella lista , devo comunque fare un IF per decidere se inserire un oggetto Quadrato o Ovale.
    Questo è un punto in cui effettivamente una catena di if-else "sembrerebbe" necessaria. Da un certo punto di vista qui, in questo punto, non sarebbe un grosso problema avere gli if-else se: a) hai pochi elementi (3, 4 ... 7, 8 ), insomma, relativamente pochi elementi e b) la costruzione degli oggetti differisce abbastanza (un rettangolo avrà x/y/w/h mentre un cerchio avrà es. x/y/raggio o diametro, ecc...).
    Questa scelta tra l'altro la fai una-tantum, solo quando l'utente sceglie una figura. Quindi NON ci sono problemi di performance particolari.

    Quello che è importante è che poi in seguito, quando dovrai ripetutamente disegnare gli elementi, NON andrai più a fare una catena di if-else ma sfrutterai il polimorfismo come già detto in precedenza. Qui, è importante evitare menate poco OOP.

    E comunque, se proprio si volesse, si potrebbe generalizzare anche la scelta/creazione degli oggetti specifici. Semplicemente mettendo a frutto di nuovo la ereditarietà/polimorfismo. Ma bisogna valutare COSA astrarre. Come ho detto, per costruire gli oggetti potrebbero essere necessari dati differenti (vedi il caso rettangolo vs cerchio). Possiamo generalizzarlo? Ad esempio stabilire che per creare una figura si deve specificare un rettangolo di "bounding box" (in cui la figura è inscritta) e ad esempio un colore.

    Possiamo definire una interfaccia che descrive una "factory" per costruire oggetti di un certo tipo:
    public interface FiguraDisegnabileFactory<T extends FiguraDisegnabile> {
        T creaFigura(Rectangle rect, Color color);
    }
    (Rectangle/Color sono ora per comodità quelli di java.awt)

    Poi nella applicazione tieni una mappa di stringhe associate alle factory.
    Map<String,FiguraDisegnabileFactory<? extends FiguraDisegnabile>> mappaFactory = new HashMap<>();
    Poi puoi popolare questa mappa "una-tantum" ovvero solo UNA volta (magari all'inizio della applicazione). Lo puoi fare con una anonymous inner-class.
    mappaFactory.put("R", new FiguraDisegnabileFactory<Rettangolo>() {
        @Override
        public Rettangolo creaFigura(Rectangle rect, Color color) {
            return new Rettangolo(rect.x, rect.y, rect.width, rect.height, color);
        }
    });
    Oppure in Java 8 con una lambda expression:
    mappaFactory.put("R", (rect,color) -> new Rettangolo(rect.x, rect.y, rect.width, rect.height, color));

    Quando nell'evento avrai un codice stringa es. "R", potrai fare un lookup (ricerca) nella mappa.
    String codice = //...scelto dall'utente
    FiguraDisegnabileFactory<? extends FiguraDisegnabile> factory = mappaFactory.get(codice);
    FiguraDisegnabile figura = factory.creaFigura(unRettangolo, unColore);
    Questo di fatto SOSTITUISCE una catena di if-else !! Chiaramente unRettangolo/unColore li dovrai costruire o comunque avere in qualche modo prima di creare la figura.

    Ovviamente c'è ben più codice da scrivere ma è molto lineare e sicuramente più "object-oriented" rispetto ad una catena di if-else. Specialmente se avessi 20, 30, ecc.. tipi di figure.

    Il fatto di avere un'altra gerarchia (FiguraDisegnabileFactory e N implementazioni) è servito per uno scopo: "appiattire" le differenze nella costruzione delle varie figure. A questo infatti serve spesso la ereditarietà/polimorfismo.

    Così come FiguraDisegnabile serve per "appiattire" le differenze nei confronti del disegno delle figure.

    Cyrano ha scritto:


    Non ho un riferimento 'vuoto' al quale inserire l'indirizzo dell'oggetto ovale o quadrato a seconda della scelta con keyevent.
    Non posso nemmeno passare l'oggetto ad una funzione incaricata di inserirlo nella lista , perchè gli oggetti sono di diverso tipo.
    Ovvero non so se c'e un ref o un contenitore per ospitare oggetti differenti.( mi viene da dire puntatore , ma probabilmente sbaglio anche perchè non esistono in java)
    Forse mi sono spiegato male
    Forse stai cercando di fare cose "avanzate" ma senza avere ancora chiare le basi sulla OOP.

    Se ho una variabile di tipo FiguraDisegnabile (la interfaccia di cui ho già parlato):

    FiguraDisegnabile figura;

    a questa variabile posso assegnare il riferimento a un QUALUNQUE oggetto che implementa questa interfaccia. Se Rettangolo, Cerchio, Ovale ecc.. la implementano, posso fare:

    figura = new Rettangolo( ..... );
    poi dopo
    figura = new Cerchio( ...... );

    ecc...

    E in maniera similare, se ho un List<FiguraDisegnabile> ciascun elemento può essere un QUALUNQUE oggetto che implementa FiguraDisegnabile.


    Questo, ripeto, è il "polimorfismo", derivante dalla ereditarietà.
  • Re: [Domanda] Polimorfismo

    Buongiorno ,

    Grazie per le lunghe risposte. Preferirei rimanere sulle if , perchè non ho molti tipi di oggetti da disegnare e vorrei concludere questo programmino nato come programmino didattico. Le hash map non le ho mai utilizzate è sarà sicuramente oggetto di studio più avanti.
    Non sapevo fosse possibile creare delle liste di tipo interfaccia. Appena ne ho creata una, sono riuscito ad aggiungere nella lista due oggetti differenti. Da ieri sera sono alla prese con un altro problema ovvero devo accedere ad un metodo di un oggetto che non sia draw. (getPosX e getPosY).
    Per ora riesco ad accedere solo a draw e disegnare con esso.Pero ora andiamo off topic grazie mille

    Per dare seguito al topic:

    Attribute
    
      private List<drawable> elementDrawable; 
    
    Interface
    
    public interface drawable {
        void draw(Graphics g);
    } 
    
    Add elements to List elementDrawable
    
              if (addElement && !removeOnCollision)
              {
                System.out.println(id);
                if(id == 1 )
                {
                    square = new Element(xCoord,yCoord,gridCellWidth,gridCellHeight);
                    square.setColor(Color.WHITE);
                    square.setTickness( 1.0f);
                    elementDrawable.add(square);
                }
                else
                {
                    oval = new Oval(xCoord,yCoord,gridCellWidth,gridCellHeight);
                    oval.setColor(Color.WHITE);
                    oval.setTickness( 1.0f);
                    elementDrawable.add(oval);
                }
              }        
    
    Rendering
    
        for(int index = 0; index < elementDrawable.size(); index++)
        {
            elementDrawable.get(index).draw(dbg);
        }  
    
    Class element = oval
    
    public class Element extends Room implements drawable{
    
        /* attribute Element */
        private int posX;
        private int posY;
        private int width;
        private int height;
        private Color color;
        private float thickness;
        static int contElement;
        
        public Element ( int posX, int posY, int width, int height) {
            
            this.posX = posX;
            this.posY = posY;
            this.width = width;
            this.height = height;
            contElement++;
        }
        public int getContElement(){
            
            return contElement;
        }
        public int getPosX() {
            return posX;
        }
        public int getPosY() {
            return posY;
        }
        public int getWidth() {
            return width;
        }
        public int getHeight() {
            return height;
        }
        public Color getColor (){
            return color;
        }
        public void setPosX( int posX) {
            this.posX = posX;
        }
        public void setPosY( int posY) {
            this.posY = posY;
        }
        public void setWidth( int width) {
            this.width = width;
        }
        public void setHeight( int height) {
            this.height = height;
        }
        public void setColor ( Color value){
            this.color = value;
        }
        public void setTickness( float t){
            this.thickness = t;
        }
     
        @Override
        public void draw(Graphics g) {
           Graphics2D g2d = (Graphics2D) g;
            g2d.setStroke(
                   new BasicStroke(thickness));
           color = new Color(25, 55, 55); 
           g2d.setColor(color);
           g2d.drawRect(posX, posY, width-1, height-1);
        }
    }
    
  • Re: [Domanda] Polimorfismo

    Cyrano ha scritto:


    Non sapevo fosse possibile creare delle liste di tipo interfaccia.
    Sì, così come anche array che hanno come tipo una interfaccia.

    FiguraDisegnabile[] = new FiguraDisegnabile[10];

    qui NON sto istanziando una interfaccia (che non si può, infatti) ma un array che ha come tipo degli elementi FiguraDisegnabile e in cui si potranno assegnare riferimenti a qualunque oggetto che soddisfa la relazione IS-A ("è un") FiguraDisegnabile.

    Cyrano ha scritto:


    Da ieri sera sono alla prese con un altro problema ovvero devo accedere ad un metodo di un oggetto che non sia draw. (getPosX e getPosY).
    La interfaccia serve per "astrarre" e vedere in modo generalizzato tutti i vari tipi di figure.
    Può aver senso che già a livello della interfaccia siano noti i getPosX/getPosY? Beh, io credo proprio di sì!

    Insomma, Drawable (nota D maiuscola, così dovrebbe essere per convenzione) descrive a livello generale qualcosa che si può disegnare. Descrive la capacità della figura di saper disegnare (draw) e potrebbe anche descrivere la capacità di fornire la posizione.
    Poi è ovvio che dovresti stabilire cosa sono questi x/y. Se per un rettangolo fossero l'angolo in alto-sinistra mentre per un cerchio il centro .... ci potrebbero essere problemi, dipende da come/dove usi queste informazioni.
  • Re: [Domanda] Polimorfismo

    Credo di aver capito. L'interfaccia determina un comportamento quindi delle azioni e quindi dei metodi. Si interfaccia verso qualcosa.
    Non tutti i metodi di una classe sono necessari , dipende da cosa dobbiamo fargli fare.
    Nel mio caso le classi element e oval hanno apparentemente tutto in comune , ma nel metodo draw assumono un comportamento diverso, cioè l'intenzione è la stessa (disegnare), ma lo fanno in modo diverso e quindi si dice che si interfacciano.
    Per quanto riguarda getPosX e getPosy si interfacciano entrambe le classi allo stesso modo( per drawOval , x e y, sono sempre le coordinate per l'angolo in alto a sinistra) , ma ho dovuto includerle nell'interfaccia perchè altrimenti non avrei avuto accesso.
    Sarebbe stato diverso se avessi voluto disegnare qualcosa di più complesso di drawOval .In quel caso avrei dovuto oltre a fare l'override anche cambiare il corpo del metodo confermando quanto ho scritto nelle prime righe. Spero di aver capito
    Non avevo mai programmato in oop , è una potenza
Devi accedere o registrarti per scrivere nel forum
16 risposte