Scarica Polimorfismo e Interfacce in Java: Esercizi Pratici e più Appunti in PDF di Programmazione Java solo su Docsity!
1
polimorfismo à interfacce
a.a. 2018 - 2019
esempio
class Animale { public void verso () { System.out.println("Io sono un Animale"); } } class Pesce extends Animale { public void verso() { System.out.println(”glug glug");} } class Uccello extends Animale { public void verso() { System.out.println(”tweet tweet"); } } class Cane extends Animale { public void verso() { System.out.println(“woof woof"); } public void ringhiare() { System.out.println("Arf Arf"); } } tanto per dire che “un animale avrà un verso” non certo per scrivere un codice che valga nelle varie classi derivate --- MA NON POTREI EVITARE DI SCRIVERE QUESTO CODICE ?? ha poco senso senza sapere di che animale sto parlando!! nel contratto!
3
interfacce
considerazioni su ADT ● una classe fornisce la definizione di un tipo astratto (ADT):
- sia le proprietà visibili, che la relativa implementazione à non è possibile dare una “ pura specifica” di interazione di un ADT senza definirlo concretamente ● Alcuni linguaggi permettono l’eredità multipla delle classi (es. C++) ● l’eredità multipla fornisce una grande flessibilità … ma anche una grande confusione , perchè possono essere presenti metodi con lo stesso nome ereditati da classi distinte, e quindi con semantica probabilmente differente considerazioni su multiple iheritance considerazioni sul polimorfismo
● una “ classe polimorfica” potrebbe nascere col solo scopo di poter poi essere
specializzata per diverse applicazioni, ● potrebbe prevedere solo la forma astratta ma non l’implementa
● potrebbe avere, nelle classi figlie, diverse realizzazioni
concrete /implementazioni polimorfiche
● Sarebbe utile definire classi per cui si prevedono tipologie di comportamento che solo le sottoclassi sono chiamate ad implementare in base alla loro forma
- con diverse implementazioni di una stessa interfaccia
interfacce
utile evitarlo requisiti in sintesi
1. definire un tipo nella sua forma astratta senza dover necessariamente definire l’implementazione concreta
- poter caratterizzare classi polimorfe che per un unico modo d’interagire hanno molteplici implementazioni possibili 3. potere supportare una forma di ereditarietà multipla senza conflitti è utile disporre di un costrutto che - se da un lato, come la classe, consente di definire il "modo di interagire" di un'entità̀ ... - dall’altra è privo di implementazioni ● e non è legato alla gerarchia di ereditarietà delle classi, con i relativi vincoli. c contrattoontratto colcol clientclient potere definire un ADT senza doverlo implementare
7 interfaccia ● Un interfaccia è una collezione di header di metodi senza la loro definizione
- ha lo scopo di definire un “protocollo del comportamento” che deve essere fornito ad una classe. ● le interfacce non contengono nessuna implementazione Ø qualsiasi classe che implementi una specifica interfaccia è obbligata a fornire il body di tutti i metodi elencati Ø non è possibile creare istanze di un'interfaccia ● le classi possono espandere i propri tipi implementando una o più interfacce
- i.e. una classe deriva da una sola superclasse ma può implementare tante interfacce fino alle versioni più recenti di Java, da java 8 in poi polimorfismo ● è possibile avere un comportamento polimorfo di una stessa interfaccia
- avere diverse realizzazioni concrete di una interfaccia ● Il Polimorfismo risponde al concetto generale noto come
Una Interfaccia Tanti Modi
● Uso della stessa rappresentazione (forma/struttura della interfaccia - what) per effettuare operazioni (comportamenti) “simili”:
- uguali nella interfaccia, ma differenti ( concretamente nel modo – how)
9 eredità vs polimorfismo ● L’Ereditarietà impone una Interfaccia - WHAT- e anche un Comportamento - HOW. ● Il Polimorfismo impone solamente una Interfaccia - WHAT
eredità polimorfismo
superclasse interfaccia
sottoclassi implementazioni
eredità vs polimorfismo
● Il polimorfismo impone una Interfaccia senza obbligare a
fornirne una implementazione
● Con il Polimorfismo dico il COSA, lasciando ai casi specifici l’opportunità di dire il COME , mentre ● con l’Ereditarietà dico sia il COSA che il COME una volta soltanto per tutti i moduli sia Padre che Figlio. ● L’Ereditarietà impone una Interfaccia - il COSA - e anche un Comportamento - il COME. ● Il Polimorfismo impone solamente una Interfaccia - il COSA. nell’inheritance di classi: polimorfismo : capacità di un oggetto di assumere forme molteplici
- come oggetto della propria classe
- come oggetto di una qualunque classe che estende la sua classe (da cui deriva)
13 implementazione ● polimorfismo ß quando più classi realizzano la stessa interfaccia, ciascuna realizza i metodi in modo diverso ● in che modo viene eseguito il metodo corretto? ● il meccanismo delle Interfacce è molto simile al meccanismo “è un”/IsA associato alle SuperClassi nell’Ereditarietà ● per evidenziare la differenza, java chiama interface l’interfaccia e usa la parola chiave implements al posto di usare la parola chiave extends nella classe derivata. public class Cerchio implements Forma{ … }
● ovviamente: una interfaccia non è istanziabile come oggetto !!!
- L’oggetto sarà sempre creato come istanza di una classe concreta che implementa una interfaccia (o deriva da una classe astratta) !!!!
● una variabile di tipo interfaccia, durante il suo ciclo di vita,
può polimorficamente riferirsi a diversi tipi concreti
- il tipo effettivo (la classe concreta ) dell’oggetto determina il
metodo da chiamare
implementazione di interfacce ● Una classe può implementare i metodi di un'interfaccia in qualunque modo il progettista della classe scelga. ● Un'interfaccia quindi può avere molte implementazioni possibili di una classe. ● Ogni ‘classe importante’ in un'applicazione dovrebbe essere l'implementazione di un interfaccia che “catturi” il contratto di quella classe. ● Le classi possono implementare più di un'interfaccia.
● una classe implementa 1/+ interfacce tramite keyword implements ;
- in tal caso, la classe deve implementare tutti i metodi richiesti, pena errore di compilazione. ● Il linguaggio di programmazione Java permette l'ereditarietà multipla di interfaccia , ma l'ereditarietà di una singola classe di implementazione
- cioè una classe può estendere al più una sola classe.
15 una interfaccia e più implementazioni interface Animale { void verso ();} class Pesce implements Animale { public void verso() { System.out.println("Glug glug");} } class Uccello implements Animale { public void verso() { System.out.println("Tweet tweet"); } } class Cane implements Animale { public void verso() { System.out.println("woof woof");} public void ringhiare() { System.out.println("Arf Arf"); } } classe test public class Zoo { public static void main (String[] argv) { Animale[] zoo = new Animale[ 3 ]; zoo[0] = new Uccello( ); zoo[1] = new Cane( ); zoo[2] = new Pesce( ); for (Animale animale : zoo) { animale.verso(); if (animale instanceof Cane){ Cane c = (Cane) animale; c.ringhia(); } } } }
19 note di linguaggio: dichiarazione di interfaccia ● una interfaccia è dichiarata usando la parola chiave interface, dandole un nome ed una lista di membri di interfaccia tra {}. modificatore interface nomeInterfaccia { listaMembri } ● una interfaccia può dichiarare I tipi di membri:
- costanti (fields) ● sono definite come campi, ● sono implicitamente public , static , e final (per convenzione, i modificatori sono omessi dalle dichiarazioni di campo)
- metodi ● sono implicitamente public e abstract ● ovviamente non possono essere static (visto che sono abstract) ● non possono essere synchronized (modificatore che caratterizza l’implementazione) o final (non sono ancora stati implementati!) ● le implementazioni di queste interfacce potranno specificare i modificatori che qui sono senza senso ● tutti i membri dell’interfaccia sono implicitamente public (per convenzione, il modificatore public si omette). estensione delle interfacce – multiple ihneritance ● le interfacce possono essere estese da altre interfacce
- come per le classi si usa la parola chiave extends ● diversamente dalle classi una interfaccia può estendere più interfacce public interface SerializableRunnable extends java.io.Serializable, Runnable{…….} ● l’ interfaccia SerializableRunnable estende sia java.io.Serializable che Runnable ● tutti i metodi e le costanti definite da entrambe le interfacce sono parte del contratto SerializableRunnable, insieme agli eventuali nuovi metodi e costanti che essa definisce. ● le interfacce che vengono estese sono super-interfacce della nuova interfaccia e la nuova interfaccia è la sub-interfaccia delle interface estese. ● poichè le interfacce non definiscono alcuna implementazione di metodi, e non forniscono campi per lo specifico oggetto, non ci sono problemi di semantica per questa forma di multiple inheritance.
21 eredità multipla tra interfacce ● Java supporta eredità multipla fra interfacce una interfaccia contiene solo dichiarazioni di metodi ● Tradizionalmente Java (prima di Java 8 ) non aveva implementazioni di metodi à nessun problema di collisione fra metodi omonimi ● non ha variabili nessun problema di collisione fra dati omonimi ● È un potente strumento di modellazione ● public interface Worker { ... } public interface Student { ... } public interface WorkerStudent extends Worker, Student { ... } ● Dopo extends può esservi un elenco di più interfacce gerarchie di interfacce ● La gerarchia delle interfacce:
- è una gerarchia separata da quella delle classi
- era slegata dagli aspetti implementativi
- esprime le relazioni concettuali della realtà
- guida il progetto del modello della realtà. ● Come nella gerarchia di classe, le interfacce derivate:
- possono aggiungere nuove dichiarazioni di metodi
- possono aggiungere nuove costanti
- non possono eliminare nulla fino alle versioni più recenti di Java, da java 8 in poi
25 Metodi static ● Non c’è motivo tecnico per imporre che una interfaccia non abbia metodi static
- Semplicemente non si adattavaalla visione di interfaccia come specifica astratta
novità di java 8
Metodi di default ● Qualsiasi metodo di interfaccia può avere una implementazione di default ● Questi metodi devono essere contrassegnati con il modificatore default Risoluzione dei conflitti della multiple inheritance ● Se una classe implementa 2 interfacce, InterfaceA e InterfaceB, che implementano entrambe un metodo, methodName(…) di default con la signature(nome e parametri)
- Può eredita i 2 metodi delle 2 interfacce, cui può accedere tramite ● InterfaceA.super.methodName(…) e InterfaceB.super.methodName(…) rispettivamente
- Può implementare un suo nuovo metodo methodName(…) ● Se una classe estende una superclasse e implementa una interfaccia, ereditando da entrambe un metodo con la stessa signature, la regola è che
- Conta solo il metodo della superclasse e il metodo di default presente nella interfaccia è ignorato ● Se le interfacce che una classe implementa non forniscono comuni metodi di default à nessun conflitto ● La classe potrà implementare i metodi ereditati o dichiararli abstract
novità di java 8
27 classi astratte e concrete ● le classi astratte definiscono solo una parte di un'implementazione , lasciando alle classi derivate il compito di fornire specifiche implementazioni di alcuni o di tutti i metodi. ● per contro, la classe concreta ha solo metodi concreti, comprese le implementazioni di tutti i metodi astratti ereditati dalle superclassi ● le classi astratte definiscono parte del comportamento di oggetti di un certo tipo ● le classi astratte ed i metodi che esse non implementano sono dichiarati abstract
● un oggetto di una classe abstract non si può creare
- ha una implementazione imcompleta, ● alcuni metodi non si possono invocare (non hanno una definizione valida) nota: ogni classe può ridefinire i metodi della sua superclasse per dichiararli abstract trasformandoli di fatto da concreti ad astratti a partire da quel punto della gerarchia delle classi (albero dei tipi)
- utile quando l’implementazione della classe non è più valida per la gerarchia delle classi derivate un esempio di figure geometrche public abstract class Figura { private String name; public Figura (String name){ this.name = name; } public String getName () { return (name); } public abstract double area (); }
metodo
astratto
classe astratta
31 esempio di figure geometriche, un test public class FigureTest { public static void main(String[] args) { Figura r = new Rettangolo( 10 , 12 ); Figura q = new Rettangolo( 10 , 10 ); Figura c = new Cerchio( 4 ); System.out.println(c); System.out.println(r); System.out.println(q); Figura f = q; System.out.println("ho assegnato a una figura un rettangolo"); boolean b = f instanceof Cerchio; System.out.println("Figura è una Cerchio" + b); b = f instanceof Rettangolo; System.out.println("Figura è una Rettangolo" + b); System.out.println(" Rettangolo è una figura" + (r instanceof Figura) ); } } sulle Classi Astatte ● le Classi Astratte si usano su oggetti dove si può beneficiare dell’Ereditarietà ...Ovvero se ci sono aspetti comuni
● Le classi astratte non sono istanziabili.
… anche se possono e devono definire costruttori …da usare per inizializzare i propri campi nell’istanza di classi concrete
Ereditarietà vs Classi Astratte
● meglio NON usare l’astrazione quando si possono estendere classi concrete. ● meglio non usare ereditarietà su oggetti concreti + overriding se questo implica una violazione del Principio di Sostituzione di Liskov.
- in questo caso meglio usare una classe astratta.
33 un esempio di classe astratta public abstract class Animale { private String nome; Animale(String nome) { this.nome=nome; } //costruttore public abstract String attivita(); public abstract String vive(); public abstract String mangia(); public void presentati(){ System.out.println("Mi chiamo "+nome+ " mi piace "+attivita()+", "+ "vivo "+vive()+ " e mangio "+mangia()); } } l’unico metodo concreto l’unico metodo che accede al campo nome: Nelle sottoclassi l’avvesso è negato: nome e private e Non ho qui un getter delle classi concrete public class Scoiattolo extends Animale { public Scoiattolo(String s){super(s);} public String attivita(){ return "saltare tra i rami";} public String vive(){ return "nei boschi";} public String mangia(){ return "ghiande";} } public class Leone extends Animale { public Leone(String s) {super(s);} public String attivita(){return "cacciare";} public String vive(){return "in Africa";} public String mangia(){return "carne";} }
