Scarica Fondamenti del linguaggio java e più Schemi e mappe concettuali in PDF di Fondamenti di informatica solo su Docsity!
JAVA
- (^) INTERFACCIA- -> funzionalità di un oggetto e come si usano; costituita da un insieme di metodi.
- (^) INCAPSULAMENTO --> possibilità di utilizzare un oggetto in un unico modo ed evitare modi non previsti dalla sua interfaccia;
- (^) CLASSE --> insieme di oggetti dello stesso tipo;
- (^) OGGETTI --> istanze di una classe; gli oggetti hanno cicli di vita indipendenti e in ogni momento ogni oggetto ha un diverso stato (una diversa configurazione dei dati). Due oggetti sono simili perché hanno gli stessi attributi e lo stesso comportamento, ma sono diversi per il ciclo di vita indipendente. CLASSE ATTRIBUTI METODO Descrive come sono fatti gli oggetti (attributi, campi) e cosa sanno fare (metodi). Definiscono le proprietà strutturali degli oggetti della classe. Definisce una funzione che un oggetto può svolgere. Non può contenere caratteri speciali e il primo carattere non può essere una cifra. Ogni attributo memorizza un valore di un certo tipo: è una variabile. * Tipo dell’attributo e nome identificativo * Tipi primitivi: interi, reali, caratteri e booleano; Tipi riferimento: per ogni classe di nome C esiste un tipo di nome C; un attributo di tipo C può memorizzare solo riferimenti ad oggetti di tipo C. Tipo int (interi); Tipo double (reali in virgola mobile); Classe String; Stesse regole della classe Definito da: * intestazione (nome del metodo, cosa sa fare...) * Corpo (sequenza di istruzioni che l’oggetto deve svolgere è anche detto implementazione )* PROTOTIPO DEL METODO ‒ nome del metodo: definito con le stesse regole e convenzioni degli attributi ‒ parametri formali: variabili usate per passare dati di input al metodo; similmente agli attributi, ogni parametro ha un tipo e un nome ‒ tipo di ritorno: il tipo di valore eventualmente restituito dal metodo al termine della sua esecuzione; se un metodo non restituisce valori, il suo tipo di ritorno si indica con void _CONVENZIONI CONVENZIONI_** Metodo di accesso= non modifica lo stato di un oggetto, lo accede solo in lettura Metodo di modifica=modifica lo stato di un oggetto CLASSE
- (^) INVOCAZIONE DEI METODI Nel corpo di un suo metodo, un oggetto ogg1 può invocare un altro metodo su un oggetto ogg2 , attraverso un’apposita istruzione di invocazione : ‒ ogg1 è detto oggetto chiamante ‒ ogg2 è detto oggetto ricevente Un’istruzione di invocazione di un metodo su un oggetto ricevente deve specificare : ‒ il nome del metodo che esso deve eseguire ‒ il valore dei parametri formali del metodo Il nome del metodo e la lista dei suoi parametri si chiama anche signature (firma) del metodo, parte del prototipo che esclude il tipo di ritorno. In una classe non possono esserci due metodi con la stessa signature. L’invocazione di un metodo che ha un tipo di ritorno diverso da void costituisce un’espressione: - (^) il valore dell’espressione è il valore restituito dal metodo al termine della sua esecuzione - (^) si dice anche che all’invocazione del metodo rimane associato il valore che il metodo restituisce
- (^) ATTRIBUTI E METODI DI UN OGETTO --> sono anche detti “di istanza”;
- (^) ATTRIBUTI E METODI DI CLASSE/STATICI --> attributo riferito allo stato della classe, non ai suoi oggetti. Non viene creata una copia per ogni oggetto. Un metodo di classe deve essere invocato sulla classe. Per distinguere attributi e metodi di classe Java richiede la parola chiave static. Nella notazione grafica sono sottolineati. **PROGRAMMA IN JAVA
Classe OutputWindow** Un suo oggetto rappresenta una finestra grafica su cui è possibile scrivere messaggi; Per chiedere a un oggetto di questo tipo di scrivere un messaggio nella finestra basta utilizzare questo metodo: void write (String s) //s è il messaggio da visualizzare - La classe offre altri tre costruttori: - (^) OutputWindow (String s): permette di specificare il titolo della finestra di output; - (^) OutputWindow (int altezza, int larghezza): permette di specificare le dimensioni della finestra di output; - (^) OutputWindow (String s, int altezza, int larghezza): permette di specificare titolo e dimensioni della finestra di output; - Metodi della classe OutputWindow: - (^) write: ogni tipo di dato che si vuole visualizzare - (^) Writeln: cambia linea alla fine del dato visualizzato - (^) Void setFont(String f, int dim): modifica il tipo e la dimensione del font;
- (^) Se il nome ha una sola parola il primo carattere deve essere maiuscolo e il resto minuscolo.
- (^) Se il nome ha più parole la prima lettera di ogni parola deve essere maiuscola, il resto minuscolo e le parole sono concatenate tra loro. Il primo carattere è sempre minuscolo. CLASSE ATTRIBUTI METODO
Gli oggetti possono essere creati solo tramite i costruttori. È necessario usare la parola chiave “new” seguita dal nome del costruttore e da eventuali parametri attuali. new () L’operatore new è unario: applicato a un solo operando, restituisce il riferimento dell’oggetto affinché questo possa essere utilizzato. La creazione di un oggetto tramite il new è un’espressione. Il riferimento restituito da new può essere memorizzato in una variabile precisa definita “variabile riferimento”. Il tipo di questa variabile è la classe degli oggetti che la variabile può referenziare e il suo valore è il riferimento a un oggetto del tipo della variabile. OutputWindow out //OutputWindow è il tipo della variabile //Out è il nome della variabile Per assegnare un valore a una variabile riferimento si utilizza il simbolo “=” out = <un riferimento OutputWindow Poiché in java non c’è modo di accedere e manipolare i riferimenti una variabile riferimento può essere usata senza l’operatore di indirezione.
Invocazione di metodi La sintassi generale per invocare un metodo su un oggetto è: .() Quando si invoca il metodo write gli si passa il riferimento a un oggetto della classe String tra apici doppi. Ex. out.write("il mio primo programma”); >Classe EquazioneDiSecondoGrado Disponibile nel package fond.esempi.capitolo5; >Metodi statici . () TIPI RIFERIMENTO TIPI PRIMITIVI Associati alle classi Modellano tipi di dati particolarmente frequenti in ogni programma C Si definiscono allo stesso modo di quelle riferimento Una variabile riferimento può memorizzare il valore null. A una variabile di tipo C si può assegnare il valore di un’espressione di tipo C: var= Dati di tipo numerico, caratteri e boolean. Le variabili primitive si definiscono ugualmente a quelle di riferimento. ESPRESSIONI RIFERIMENTO TIPI RIFERIMENTO
ESPRESSIONI INTERE E LETTERALI
Le espressioni intere hanno valori di tipo byte, short, int o long.
Letterali interi (costanti intere) ‒ ogni numero in base 10 -->automaticamente considerato come una espressione di tipo int; ‒ se un letterale è assegnato ad una variabile byte o short (che può contenerlo)--> è considerato espressione di tipo byte o short; ‒ una costante terminata da una l o L viene considerata espressione di tipo long; ‒ I prefissi 0 o 0x indicano costanti in base 8 o 16 OPERATORI ARITMETICI DI BASE
- moltiplicazione / divisione intera (tronca la parte decimale) % resto della divisione intera Ogni espressione intera che fa uso di operatori viene considerata come espressione: ‒ di tipo int , se non contiene operandi long
- Variabili di tipo c e null;
- Istruzioni di creazioni di oggetti;
- Invocazioni di metodi che restituiscono un riferimento di tipo c; si può invocare un metodo di istanza di C (se est è di tipo C) con la sintassi: . () Se ha valore null viene generato un errore di esecuzione chiamato: NullPointerException TIPI RIFERIMENTO TIPI PRIMITIVI
- (^) Si può invece scrivere c = (char)(c+1) TIPO BOOLEAN Tipo per rappresentare i valori di verità. Una espressione boolean viene anche chiamata predicato: i letterali true o false sono i predicati più elementari. E’ possibile costruire predicati più complessi attraverso l’uso di due tipi di operatori: ‒ operatori logici : operano tra valori boolean e restituiscono un valore boolean. ‒ operatori relazionali : operano tra valori numerici (inclusi i char) e restituiscono un valore boolean. >Operatori logici ‒ && AND logico ‒ || OR logico (inclusivo) ‒^ OR logico esclusivo (XOR) ‒! NOT (negazione)
Precedenze L’operatore NOT ha precedenza rispetto agli altri e l’operatore AND ha precedenza rispetto agli OR
- E’ possibile usare parentesi per forzare le regole di precedenze (come nelle espressioni numeriche)
- Nelle espressioni a && b oppure a || b, la JVM valuta il secondo operando solo se necessario ‒ cioè a meno che il valore del primo non sia già sufficiente a dedurre il risultato dell’espressione >Operatori relazionali ‒ == uguale a ‒ != diverso da ‒ > maggiore di ‒ < minore di ‒ >= maggiore o uguale a ‒ <= minore o uguale a Gli operatori relazionali == e != possono anche essere usati per confrontare riferimenti tra oggetti ‒ Se a e b sono variabili riferimento di tipo C, l’espressione a == b vale true se e solo se a e b
referenziano lo stesso oggetto ‒ Viceversa, a != b vale true se e solo se a e b referenziano oggetti diversi COSTANTI Una costante viene dichiarata come una variabile (tipo + nome), ma la dichiarazione è preceduta dalla parola chiave final. final double PIGRECO = 3.14159; CLASSI Wrapper Sono classi che rappresentano le tipologie di dati riconducibili a dati primitivi e si trovano nel package java.lang. **Ogni oggetto wrapper in Java è immutabile, cioè il suo stato non può essere cambiato.
Creazione oggetti wrapper** Un oggetto di tipo W può essere creato con un costruttore al quale si specifica il valore di tipo w che esso rappresenterà Integer i=new Integer (100); In realtà nelle versioni più recenti di Java l'uso del costruttore è deprecato e si consiglia di utilizzare il metodo statio valueOf(w) Integer i=Integer.valueOf (100); Ad eccezione di Character si può usare un costruttore al quale passare il valore primitivo descritto come stringa. Integer i=new Integer (“100”); Integer i=Integer.valueOf(“100”); Metodi delle classi wrapper Ogni classe wrapper W, tranne Character, ha un metodo di classe parseX(String s) che restituisce il valore primitivo w descritto da s (X appartiene a {Int, Double, Boolean,…}) Integer.parseInt (“100” ); //come si passa da stringa a int con parseint AUTOBOXING Meccanismi automatici di conversione implicita utilizzati per agevolare il passaggio da un dato di tipo W ad un dato di tipo primitivo w e viceversa.
- Si può ad esempio scrivere: ‒ int i = ogg dove ogg è un Integer (unboxing); ‒ Integer ogg = 100 (inboxing); CLASSE Math Definita nel package java.lang e offre solo metodi pubblici statici. ‒ Math.PI il valore di pigreco, con la migliore approssimazione possibile sotto forma di double ‒ Math.E la costante e, cioè il numero di Nepero
int length(); char charAt(int index); boolean equals (String s) il parametro formale è un oggetto della classe Object int compareTo(String s); restituisce: ‒ un valore negativo se il ricevente precede s lessicograficamente ‒ un valore positivo se il ricevente segue s lessicograficamente ‒ 0 se le stringhe hanno lo stesso valore “mondo”.length() ha valore 5 System.out.print(“mond o”.charAt(2)) stampa a video il carattere ‘n’ String str1 = new String(“ciao mondo!”); String str2 = new String(“ciao mondo!); System.out.print(str1.eq uals(str2)); L’espressione str1.equals(str2) vale true perché gli oggetti referenziati da str1 e da str2 , sebbene siano diversi, hanno lo stesso valore
Class StringBuilder , come la classe String permette di lavorare con i dati di testo.
Se ho un oggetto con una certa sequenza di caratteri questa classe permette di appendere
o rimuovere nuovi caratteri sullo stesso oggetto, senza la creazione di nuovi oggetti.
Ex.
StringBuilder strB = new StringBuilder();
strB.append(“Rettangolo:\n”);
strB.append(“nome: ” + this.nome + “\n”);
REALIZZAZIONE CLASSI -Classificazione di variabili Dal punto di vista del tipo di dato associato si distinguono in: primitive e riferimento. Dal punto di vista di dove si trova nel codice si classificano in:
- (^) variabili di istanza e di classe--> definite fuori dei metodi;
- (^) Variabili locali--> definite nei metodi;
- (^) Parametri formali--> costituiscono i parametri di un metodo; -Campo di visibilità: scope Data una classe e una variabile definita al suo interno, il campo di visibilità indica in quali porzioni del codice la variabile può essere richiamata (acceduta). Questo dipende solo da dove la variabile è definita, non dal suo contenuto. Le variabili usate per definire gli attributi degli oggetti (istanze) di una classe si chiamano (rappresentano “la memoria di un oggetto”, cioè il suo stato nel tempo) variabili di istanza. Nella definizione di una classe, le variabili di istanza e di classe si dichiarano all’interno del corpo della classe ma al di fuori dei corpi dei metodi (tipicamente all’inizio del corpo della classe, prima dei metodi). Struttura di una classe di nome Rettangolo public class Rettangolo{ // attributi ... // costruttori ... // metodi indexOf substring toUpperCase e toLowerCase Split verifica se una stringa è contenuta in un’altra Estrae una sottostringa da una stringa creare stringhe con sole lettere maiuscole o sole lettere minuscole Suddivide una stringa in «pezzi» in corrispondenza di un separatore int indexOf(String s) restituisce la posizione iniziale di s all’interno della stringa ricevente, se s è contenuta nella stringa ricevente, altrimenti restituisce - ‒ String substring (int a, int b) ‒ String substring (int a): La prima restituisce la sottostringa dell’oggetto ricevente dalla posizione a (inclusa) alla posizione b (escluso); La seconda restituisce la sottostringa dell’oggetto ricevente dalla posizione a alla fine; ‒ String toUpperCase() ‒ String toLowerCase () String[] split(String sep) Il tipo restituito è un array di stringhe; Il parametro è in generale un’ espressione regolare , in questo caso descrive come è fatto il separatore. “ -” una stringa formata dal carattere - ‒ “ \s” una stringa formata da un qualunque carattere di spaziatura “ciao”.indexOf(“ia”) vale 1 ‒ “ciao”.indexOf(“cio”) vale- “ciao mondo!”.substring(2, 6) vale “ao m” ‒ “ciao mondo!”.substring(5) vale “mondo!” ‒“cIAo”.toLowerCase() vale “ciao” ‒ “cIAo”.toUpperCase() vale “CIAO” -“25-7-19”.split(“-”) restituisce l’array {“25”, “7”,“19”} ‒ “ciao mondo”.split(“
\s+”) restituisce l’array {“ciao”,“mondo”}
Nel corpo di una classe, si usa definire costruttori dopo le variabili di istanza e prima degli altri metodi. Davanti alla definizione del costruttore si mette il modificatore di accesso public. Ex. public class Rettangolo{ private double base, altezza; private static int numIstanze=0; /* costruttore:crea un oggetto Rettangolo con base b e altezza a / public Rettangolo (double b, double a){ ... } / metodi */ ... } -Variabili di classe Definite tramite la parola static e sono precedute da private. L’inizializzazione di queste variabili avviene contestualmente alla definizione. Non esiste un costruttore di classe che possa inizializzarle. Ex. Conteggio delle parole create public static int rettCreati(){ return Rettangolo.numIstanze; } Ogni variabile di classe nasce e muore con la classe a cui si riferisce ed è visibile a tutti i metodi definiti nella classe. Siano essi statici o di istanza. Una variabile y della classe C è accessibile a tutti i suoi metodi tramite il costrutto C.y e se in un metodo non è presente nessuna variabile locale con il nome di y, si può accedere alla variabile di istanza anche direttamente con il suo nome, y. -Variabili locali Visibili solo all’interno del metodo in cui sono definite e non una variabile locale appena dichiarata non ha nessun valore di default associato (diversamente dalle variabili di istanza). Quando si legge una variabile locale per la prima volta, ad essa deve essere già stato assegnato un valore. Ex. public int metodoErrato (){ int x; x = x+1; return x; } In questo codice si ha un errore perché la variabile locale x non è stata inizializzata. -Parametri formali Sono variabili che conterranno i valori passati al metodo/costruttore all’atto della sua invocazione. Come in c si tratta di variabili locali. -Passaggio di parametri Avviene sempre per valore -Parola chiave This
This indica l’oggetto su cui si sta lavorando (su cui il metodo è stato invocato). Un metodo o un costruttore può riferirsi a una variabile di istanza dell’oggetto su cui è invocato usando la parola this seguita da un punto e dal nome della variabile. Ex. public Rettangolo (double b, double a){ this.base = b; this.altezza = a; } L’istruzione this.base=b è un’ istruzione di assegnazione : ‒ il valore di b (espressione a destra di “=”) è copiato nella variabile di istanza this.base ‒ analogamente, this.altezza = a copia il valore di a nella variabile di istanza this.altezza Se una classe ha più di un costruttore la parola this può essere usata per richiamare un costruttore all’interno di un altro costruttore. Ad esempio, supponiamo di voler dotare la classe Punto di un secondo costruttore public Punto(Punto p) tale costruttore crea un punto con le stesse coordinate di quello passato per parametro. Un costruttore di questo tipo è chiamato costruttore di copia. Il costruttore copia può essere così implementato: ‒ richiamando il costruttore precedentemente definito ‒ passando ad esso come parametri x ed y i valori p.coordX e p.coordY Tale costruttore si può richiamare con la sintassi this(), dove sono i parametri richiesti dal costruttore che si vuole richiamare. Ex. Implementazione costruttore copia public Punto(Punto p){ this(p.coordX, p.coordY); } Ex. Implementazione tradizionale del costruttore copia public Punto(Punto p){ this.coordX = p.coordX; this.coordY = p.coordY; } -Dichiarazione del metodo Come per il costruttore si usa il modificatore di accesso public. In molti casi è importante definire metodi private a supporto di metodi pubblici. Quando un metodo pubblico ha un’implementazione complessa può risultare utile spostare ed incapsulare parti del suo codice in metodi privati che vengono poi richiamati nell’ambito del metodo pubblico. -L’istruzione return Deve essere usate in ogni metodo che vuole restituire un valore che deve essere coerente con il tipo di dato di ritorno.Causa la terminazione immediata del metodo. -Attributi e variabili Anche gli attributi di classe possono essere realizzati tramite l’uso di variabili dette variabili di classe/ statiche. Come quelle di istanza si dichiarano all’interno del corpo della classe ma fuori dei corpi dei metodi.
L’assegnazione di un letterale array di tipo T a una variabile di tipo T[] deve avvenire contestualmente alla definizione della variabile. Ex. int[] a={1,2,3} //OK int[] b; b={4,5,6} // Errore!! -Copia di array Copiare un array a significa creare un nuovo array b i cui elementi hanno lo stesso valore di quelli di a La copia avviene in due passi: ‒ si crea l’array b con la stessa dimensione di a ‒ si copiano gli elementi di b uno alla volta in a Ex. int [] b = new int [a.length]; for (int i=0; i<a.length; i++) b[i] = a[i] b=a in Java, a differenza di C, si può fare, ma l’effetto non è lo stesso perché in questo caso sto solo copiando il riferimento all’array. -Parametro del metodo main Il parametro “String[] args” è un array di stringhe. All’avvio del programma è possibile passare al main come parametro una sequenza di stringhe che verranno salvate nell’array args. Se ad esempio si scrive: java C <stringa 1> <stringa 2>... Viene invocato il metodo main della classe C passandogli come parametro un array args di dimensione k tale che: ‒ args[0] è pari a <stringa 1>, args[1] è pari a <stringa 2>,..., args[k-1] è pari a Le stringhe <stringa 1> <stringa 2>... vengono chiamate parametri della linea di comando. -Array bidimensionali Usati prevalentemente per modellare matrici. Un array bidimensionale matriciale di tipo T con m righe e n colonne può essere creato con la seguente istruzione: new T[m][n] Il tipo dell’array creato è array di array di tipo T oppure array bidimensionale di tipo T. Tale tipo di dato si indica con T[][] e gli elementi dell’array vengono inizializzati con il valore di default del tipo T. Ex. int [][] a=new int [m][n]; L’istruzione precedente crea un array bidimensionale di interi con m righe e n colonne e ne memorizza il riferimento nella variabile a. Gli elementi creati saranno inizializzati con il valore 0.
Per accedere a un elemento di un array bidimensionale è necessario specificare l’indice di riga e quello di colonna. Più precisamente: ‒ a[i] denota l’array monodimensionale corrispondente alla riga i-esima ‒ a[i][j] denota il j-esimo elemento dell’array a[i] a[i] è a tutti gli effetti un riferimento ad un array monodimensionale. Scrivendo a[i].length mi da la lunghezza della riga i-esima, quindi il numero di colonne dell’array. Scrivendo invece solo a.length conosco il numero delle righe dell’array. Anche gli array bidimensionali si possono inizializzare attraverso letterali array. Ex. int[][] a={{10, 0}, {0, 71}, {-3, 0}}; -Array bidimensionali non matriciali Sono anche detti array frastagliati perché ogni elemento dell’array ha una lunghezza diversa. Ex. double[][] a = { {11.2, 0.5, 1.0}, {0.0, 44.5},{-3.5, 5.5, 7.0}, {13.5} }; Lo stesso array può essere creato come segue: double[][] a = new double[4][]; viene specificata solo una dimensione (numero di righe) a[0] = new double[ 3 ]; a[1] = new double[ 2 ]; a[2] = new double[ 3 ]; creazione esplicita delle singole righe a[3] = new double[ 1 ]; a[0][0] = 11.2; a[0][1] = 0.5; a[0][2] = 1.0; a[1][0] = 0.0; a[1][1] = 44.5; a[2][0] = -3.5; a[2][1] = 5.5; a[2][2] = 7.0; a[3][0] = 13.5; Per visitare gli elementi di un array bidimensionale si utilizzano due cicli annidati. Ex. public static void stampaElementi(double[][] a){ for (int i = 0; i<a.length; i++) for (int j = 0; j<a[i].length; j++){ System.out.print("Elem. in posiz. "+"("+i+","+j+"): "); System.out.println(a[i][j]); } }
- (^) a.length denota la lunghezza dell’array referenziato da a, quindi il numero di righe
- (^) a[i].length denota la lunghezza dell’array referenziato da a[i], quindi il numero di elementi sulla riga i-esima.
Nell’esempios del tennista l’invocazione del costruttore della super-classe serve anche perché le variabili nome e nazione sono private. Una sotto-classe eredita i membri privati della sua super- classe ma non può accederli. -Overriding di metodi Una classe può ridefinire un metodo ereditato se vuole che il metodo presenti un comportamento diverso da quello ereditato. Ad esempio, la classe Tennista ridefinisce il metodo toString(). Una classe derivata può avere quindi: ‒ metodi ereditati (e non sovrascritti); ‒ metodi ereditati (e sovrascritti); ‒ metodi propri. -Adombramento di variabili Analogamente ai metodi anche le variabili ereditate possono essere ridefinite. Se ad esempio, nella classe Tennista definissimo un variabile nome, questa adombrerebbe la variabile nome di Atleta. Un oggetto Tennista le avrebbe entrambe e si potrebbe distinguerle, all’interno di Tennista, usando this e super. L’adombramento di variabili viene usato limitatamente. -Modificatore protected Una classe estesa eredita i membri privati della classe ma non può accederle ad essi. Oltre a public e a private, esiste il modificatore protected. Un membro definito protected è accessibile alla classe in cui è definito, a tutte le classi dello stesso package e a tutte le sue sotto-classi definite in altri package. Una sotto-classe può essere usata come classe base da un’altra classe derivata. Posso creare gerarchie di ereditarietà, ma non è ammessa l’ereditarietà multipla , cioè la possibilità che una classe estenda due o più classi base. È possibile definire una classe in maniera che non sia estendibile. Per farlo è necessario utilizzare il modificatore final nella definizione della classe. Ex. public final class Inestendibile{ ... } Il modificatore final può essere applicato anche ad un metodo che, a questo punto, non può essere sovrascritto. POLIMORFISMO -Istanze e tipi Un’istanza di una classe derivata è anche un’istanza della classe base, ciò significa che in un qualunque punto ci si aspetta un’istanza della classe base si può utilizzare un’istanza della classe derivata. La seguente istruzione è quindi corretta: Atleta a = new Tennista("Roger Federer", "Svizzera", 1); I metodi che è possibile invocare su a sono tutti e soli i metodi definiti nella classe Atleta. Quindi:
System.out.println(a.getNazione()); // corretto System.out.println(a.getRanking()); // errore!!!! Consideriamo adesso il seguente codice: Atleta a = new Tennista("Roger Federer", "Svizzera", 1); System.out.println(a.toString()); A seguito dell’invocazione a.toString() viene eseguito il metodo della classe Tennista. Il metodo da eseguire viene stabilito a tempo di esecuzione sulla base del tipo effettivo dell’oggetto su cui il metodo viene invocato. Questo fenomeno è detto binding dinamico (se avviene a tempo di esecuzione) binding statico (se avviene a tempo di compilazione). Ex. Atleta a = new Atleta("Usain Bolt", "Jamaica"); Tennista t = new Tennista("Roger Federer", "Svizzera", 1); C.stampa(a); C.stampa(t); Il risultato è: Nome: Usain Bolt, nazione: Jamaica (per il primo) Nome: Roger Federer, nazione: Svizzera, ranking ATP: 1 (per il secondo) Grazie al polimorfismo possiamo scrivere codice facilmente estendibile: ‒ si scrive un programma facendo riferimento al comportamento definito da una super-classe (o, come vedremo in seguito, da una interface) ‒ si scrivono poi varie sotto-classi che forniscono implementazioni diverse di tale comportamento In questo modo, le sotto-classi possono essere utilizzate per personalizzare e modificare il comportamento del programma senza bisogno di modificarne il codice. CLASSE Object definisce un super-tipo per tutte le classi Java e viene utilizzata quando si vuole scrivere un codice che deve poter operare su un oggetto di qualunque tipo. Ex. public class Coppia{ private Object el1; private Object el2; public Coppia(Object el1, Object el2){ this.el1 = el1; this.el2 = el2; } public Object primoElemento(){ return this.el1; } public Object secondoElemento(){ return this.el2;}} La classe Coppia permette di rappresentare coppie di oggetti di qualunque tipo. Ex. Coppia c1 = new Coppia("primo", "secondo"); Atleta a1 = new Atleta("Usain Bolt", "Giamaica"); Atleta a2 = new Atleta("Asafa Powell", "Giamaica") Coppia c2 = new Coppia(a1, a2);
