Docsity
Docsity

Prepara i tuoi esami
Prepara i tuoi esami

Studia grazie alle numerose risorse presenti su Docsity


Ottieni i punti per scaricare
Ottieni i punti per scaricare

Guadagna punti aiutando altri studenti oppure acquistali con un piano Premium


Guide e consigli
Guide e consigli


Programmazione II (Java), 2° anno del corso di informatica, Appunti di Programmazione Java

Sono riportate le classi di librerie utili e alcuni argomenti: concetti di base della sintassi, metodi, classe e oggetto, variabili, costruttori, dati primitivi, dati complessi: reference (this), passaggio di parametri, modificatori, parole chiavi, metodo statico, array, operatori, costrutti, interfacce, polimorfismo, gestione delle eccezioni, enumerazioni, le collezioni, espressioni lambda, stream, descrizioni di varie classi (String, Object, Vectors, ArrayList, hashMap, hashSet, Scanner), metodi (toString, Varrargs, equals, hashCode) e interfacce (iterable, closeable, Iterator, map, comparable, comparator, consumer, supplier, function, unaryOperator)

Tipologia: Appunti

2023/2024

In vendita dal 03/07/2024

lisa-benini-1
lisa-benini-1 🇮🇹

4.8

(8)

48 documenti

1 / 19

Toggle sidebar

Questa pagina non è visibile nell’anteprima

Non perderti parti importanti!

bg1
libreria java.lang.String = classe immutabile, nel senso che i suoi oggetti non sono più modificabili dopo la creazione
String() = costruttore: crea una sequenza di caratteri vuota
char charAt(int index) = mi cerca il carattere di una stringa in posizione index
int compareTo(String other) = confronta due stringhe lessicograficamente (ritorna negativo, zero, oppure positivo)
int compareToIgnoreCase(String other) = Concatena la stringa specificata alla fine di questa stringa (ritorna negativo, zero, oppure
positivo)
String concat(String other) = Concatena la stringa specificata alla fine di questa stringa
boolean endsWith(String suffix) = Verifica se questa stringa termina con il suffisso specificato
boolean equals(Object other) = Confronta questa stringa con l'oggetto specificato.
boolean equalsIgnoreCase(String other) = compara due stringhe senza tener conto di minuscole e maiuscole
static String format(String format, Object... args) = Restituisce una stringa formattata utilizzando la stringa di format e gli argomenti
specificati
int indexOf(int character) = Restituisce l'indice all'interno di questa stringa della prima occorrenza del carattere specificato
int indexOf(String what) = Restituisce l'indice all'interno di questa stringa della prima occorrenza della sottostringa specificata
boolean isEmpty() = Restituisce truese, e solo se, length() è 0
int length() = lunghezza
boolean startsWith(String prefix) = Verifica se questa stringa inizia con il prefisso specificato
String substring(int start) = Restituisce una stringa che è una sottostringa di questa stringa (da start incluso)
String substring(int start, int end) = Restituisce una stringa che è una sottostringa di questa stringa (da start incluso ad end escluso)
String toLowerCase() = trasforma le maiuscole in minuscole
String toUpperCase() = trasforma le minuscole in maiuscole
String trim() = Restituisce una stringa il cui valore è questa stringa, con eventuali spazi iniziali e finali rimossi.
static String valueOf(int i) = Restituisce la rappresentazione di stringa dell'argomento int. (esegue una conversione esplicita di tipo;
esiste per tutti i tipi primitivi, non solo per int; implicitamente usato per la concatenazione con +)
libreria java.lang.System
err = costante della classe che fa riferimento allo standard error
in = costante della classe che fa riferimento allo standard input
out = costante della classe che fa riferimento allo standard output
static long currentTimeMillis() = ritorna il numero di millisecondi passati
libreria java.util.Scanner
Scanner(source) = costruttore, che crea uno Scanner legato alla sorgente indicata
void close() = chiude lo Scanner: dopo non può più essere usato
double nextDouble() = prende l’input messo fino all’andata a capo
float nextFloat() = prende l’input messo fino all’andata a capo
int nextInt() = prende l’input messo fino all’andata a capo
String nextLine() = prende l’input messo fino all’andata a capo
long nextLong() = prende l’input messo fino all’andata a capo
libreria java.util.Random
boolean nextBoolean() = restituisce il successivo valore pseudocasuale
double nextDouble() = restituisce un numero casuale tra 0 e 1
float nextFloat() = restituisce un numero casuale tra 0 e 1
int nextInt() = restituisce il successivo valore pseudocasuale
int nextInt(int max) = restituisce un numero casuale tra 0 e max escluso
long nextLong() = restituisce il successivo valore pseudocasuale
libreria java.lang.Math
static double E = double valore che più si avvicina a e , la base dei logaritmi naturali
static double PI = Il double valore più vicino di ogni altro a pi greco , il rapporto tra la circonferenza di un cerchio e il suo diametro
static int abs(int i) = Restituisce il valore assoluto di un int valore
static double cos(double d) = Restituisce il coseno trigonometrico di un angolo
static double log(double d) = Restituisce il logaritmo naturale (base e ) di un double valore.
static double log10(double d) = Restituisce il logaritmo in base 10 di un double valore.
static int max(int a, int b) = maggiore tra due int valori
static int min(int a, int b) = minimo tra due int valori
static double sqrt(double d) = radice quadrata
static double tan(double d) = tangente
static double toDegrees(double radiants) = Converte un angolo misurato in radianti in un angolo approssimativamente equivalente
misurato in gradi
static double toRadiants(double degrees) = Converte un angolo misurato in gradi in un angolo approssimativamente equivalente
misurato in radianti.
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13

Anteprima parziale del testo

Scarica Programmazione II (Java), 2° anno del corso di informatica e più Appunti in PDF di Programmazione Java solo su Docsity!

libreria java.lang.String = classe immutabile, nel senso che i suoi oggetti non sono più modificabili dopo la creazione

  • String() = costruttore: crea una sequenza di caratteri vuota
  • char charAt(int index) = mi cerca il carattere di una stringa in posizione index

• int compareTo(String other) = confronta due stringhe lessicograficamente (ritorna negativo, zero, oppure positivo)

• int compareToIgnoreCase(String other) = Concatena la stringa specificata alla fine di questa stringa (ritorna negativo, zero, oppure

positivo)

• String concat(String other) = Concatena la stringa specificata alla fine di questa stringa

• boolean endsWith(String suffix) = Verifica se questa stringa termina con il suffisso specificato

• boolean equals(Object other) = Confronta questa stringa con l'oggetto specificato.

• boolean equalsIgnoreCase(String other) = compara due stringhe senza tener conto di minuscole e maiuscole

• static String format(String format, Object... args) = Restituisce una stringa formattata utilizzando la stringa di format e gli argomenti

specificati

• int indexOf(int character) = Restituisce l'indice all'interno di questa stringa della prima occorrenza del carattere specificato

• int indexOf(String what) = Restituisce l'indice all'interno di questa stringa della prima occorrenza della sottostringa specificata

• boolean isEmpty() = Restituisce truese, e solo se, length() è 0

• int length() = lunghezza

• boolean startsWith(String prefix) = Verifica se questa stringa inizia con il prefisso specificato

• String substring(int start) = Restituisce una stringa che è una sottostringa di questa stringa (da start incluso)

• String substring(int start, int end) = Restituisce una stringa che è una sottostringa di questa stringa (da start incluso ad end escluso)

• String toLowerCase() = trasforma le maiuscole in minuscole

• String toUpperCase() = trasforma le minuscole in maiuscole

• String trim() = Restituisce una stringa il cui valore è questa stringa, con eventuali spazi iniziali e finali rimossi.

• static String valueOf(int i) = Restituisce la rappresentazione di stringa dell'argomento int. (esegue una conversione esplicita di tipo;

esiste per tutti i tipi primitivi, non solo per int; implicitamente usato per la concatenazione con +) libreria java.lang.System

• err = costante della classe che fa riferimento allo standard error

• in = costante della classe che fa riferimento allo standard input

• out = costante della classe che fa riferimento allo standard output

• static long currentTimeMillis() = ritorna il numero di millisecondi passati

libreria java.util.Scanner

• Scanner(source) = costruttore, che crea uno Scanner legato alla sorgente indicata

• void close() = chiude lo Scanner: dopo non può più essere usato

• double nextDouble() = prende l’input messo fino all’andata a capo

• float nextFloat() = prende l’input messo fino all’andata a capo

• int nextInt() = prende l’input messo fino all’andata a capo

• String nextLine() = prende l’input messo fino all’andata a capo

• long nextLong() = prende l’input messo fino all’andata a capo

libreria java.util.Random

• boolean nextBoolean() = restituisce il successivo valore pseudocasuale

• double nextDouble() = restituisce un numero casuale tra 0 e 1

• float nextFloat() = restituisce un numero casuale tra 0 e 1

• int nextInt() = restituisce il successivo valore pseudocasuale

• int nextInt(int max) = restituisce un numero casuale tra 0 e max escluso

• long nextLong() = restituisce il successivo valore pseudocasuale

libreria java.lang.Math

• static double E = double valore che più si avvicina a e , la base dei logaritmi naturali

• static double PI = Il double valore più vicino di ogni altro a pi greco , il rapporto tra la circonferenza di un cerchio e il suo diametro

• static int abs(int i) = Restituisce il valore assoluto di un int valore

• static double cos(double d) = Restituisce il coseno trigonometrico di un angolo

• static double log(double d) = Restituisce il logaritmo naturale (base e ) di un double valore.

• static double log10(double d) = Restituisce il logaritmo in base 10 di un double valore.

• static int max(int a, int b) = maggiore tra due int valori

• static int min(int a, int b) = minimo tra due int valori

• static double sqrt(double d) = radice quadrata

• static double tan(double d) = tangente

• static double toDegrees(double radiants) = Converte un angolo misurato in radianti in un angolo approssimativamente equivalente

misurato in gradi

• static double toRadiants(double degrees) = Converte un angolo misurato in gradi in un angolo approssimativamente equivalente

misurato in radianti.

E definite tramite enum

  • static E[] values() = ritorna l'array di tutti gli elementi dell'enumerazione
  • static E valueOf(String name) = ritorna l'elemento dell'enumerazione che ha il nome indicato
  • int compareTo(E other) = determina chi viene prima nell'enumerazione
  • int ordinal() = ritorna il numero d'ordine di un elemento dell'enumerazione classe java.util.Arrays

• static int binarySearch(int[] arr, int key) = ritorna la posizione di key dentro arr, oppure un numero negativo se arr non contiene key.

Assume che l'array arr sia ordinato. Questo metodo esiste anche per gli altri tipi primitivi numerici e per i tipi riferimento, nel qual caso chiama compareTo() per decidere l'ordine

• static boolean equals(int[] arr1, int[] arr2) = controlla che arr1 e arr2 abbiano stessa lunghezza e contengano gli stessi elementi nello

stesso ordine. Questo metodo esiste anche per gli altri tipi primitivi nonché per array di tipi riferimento, nel qual caso chiama equals() fra tutte le coppie di oggetti da confrontare

• static void fill(int[] arr, int val) = assegna val a tutti gli elementi di arr. Questo metodo esiste anche per tutti gli altri tipi primitivi e per

array di tipi riferimento

• static void sort(int[] arr) = ordina arr in senso crescente, in tempo O(n log n). Questo metodo esiste anche per tutti gli altri tipi primitivi

numerici e per i tipi riferimento, nel qual caso chiama compareTo() per decidere l'ordine

• static String toString(int[] arr) = ritorna una stringa che riporta gli elementi di arr, nel loro ordine. Questo metodo esiste anche per gli

altri tipi primitivi e per array di tipi riferimento, nel qual caso chiama toString() sugli elementi dell'array e concatena il risultato classe java.lang.Comparable

• int compareTo(T other): ritorna un numero negativo se viene prima this, un numero positivo se viene prima other e 0

se this e other sono equivalenti. classe java.lang.Integer (classe immutabile, nel senso che i suoi oggetti non sono più modificabili dopo la creazione)

• static int MAX_VALUE = costante che contiene il massimo int utilizzabile in Java

• static int MIN_VALUE = costante che contiene il minimo int utilizzabile in Java

• Integer(String value) throws java.lang.NumberFormatException

• int intValue() = restituisce il valore int corrispondente

• int compareTo(Integer other)

• static int parseInt(String s) throws java.lang.NumberFormatException = traduce la stringa s in int

• static String toBinaryString(int i) = ritorna la rappresentazione binaria di i

• static String toHexString(int i) = ritorna la rappresentazione esadecimale di i

• static Integer valueOf(int i) = ritorna new Integer(i) ma usa una cache per chiamate ripetute

classe java.lang.Character (classe immutabile, nel senso che i suoi oggetti non sono più modificabili dopo la creazione)

• static char MAX_VALUE = costante che contiene il massimo char utilizzabile in Java

• static char MIN_VALUE = costante che contiene il minimo char utilizzabile in Java

• char charValue() = restituisce il valore char corrispondente

• int compareTo(Character other)

• static boolean isDigit(char c)

• static boolean isLetter(char c)

• static boolean isLetterOrDigit(char c)

• static boolean isLowerCase(char c)

• static boolean isUpperCase(char c)

• static boolean isWhitespace(char c)

• static char toLowerCase(char c)

• static char toUpperCase(char c)

• static Character valueOf(char c) = ritorna new Character(c) ma usa una cache per chiamate ripetute

interfaccia java.util.Collection (estende Iterable) = collezione rappresenta un gruppo di oggetti, conosciuti come i suoi elementi

  • boolean add(E element) = ritorna true se l'elemento viene aggiunto
  • boolean addAll(Collection other) = ritorna true se almeno un elemento viene aggiunto
  • boolean contains(Object element) = Restituisce truese questa raccolta contiene l'elemento specificato
  • boolean containsAll(Collection<?> other) = Restituisce true se questa raccolta contiene tutti gli elementi nella raccolta specificata
  • boolean isEmpty() = Restituisce truese questa raccolta non contiene elementi.
  • boolean remove(Object element) = ritorna true se l'elemento viene rimosso
  • boolean removeAll(Collection<?> other) = ritorna true se almeno un elemento viene rimosso
  • boolean retainAll(Collection<?> other) = Mantiene solo gli elementi di questa raccolta contenuti nella raccolta specificata (operazione facoltativa)
  • int size() = numero di elementi in questa raccolta interfaccia java.util.List (estende Collection) = Una raccolta ordinata (nota anche come sequenza ). L'utente di questa interfaccia ha un controllo preciso su dove viene inserito ciascun elemento nell'elenco. L'utente può accedere agli elementi tramite il loro indice intero (posizione nell'elenco) e cercare elementi nell'elenco
  • boolean add(E element) = aggiunge element in fondo alla lista, anche se la lista già lo conteneva; ritorna sempre true
  • void add(int index, E element) = piazza l'elemento alla posizione index, che deve essere fra 0 e size() inclusi, spostando di una posizione a destra l'elemento che c'era precedentemente e quelli alla sua destra

• V remove(Object key) = ritorna il vecchio valore, se era presente; altrimenti null

• int size()

• Collection values()

classe java.util.HashMap<K,V>

• HashMap()

• HashMap(Map<? extends K,? extends V> parent) = crea una mappa e la riempie con le coppie contenute in parent

interfaccia java.util.SortedMap<K,V> (oltre a tutti quelli di Map) = prevede un ordinamento totale sulle proprie chiavi. La mappa viene ordinata secondo l' ordine naturale delle sue chiavi, o secondo un ordine Comparator generalmente fornito al momento della creazione della mappa ordinata. Questo ordine si riflette quando si esegue l'iterazione sulle visualizzazioni della raccolta della mappa ordinata

• K firstKey()

• K lastKey()

classe java.util.TreeMap<K,V> = Un'implementazione basata su albero rosso-nero. La mappa viene ordinata in base all'ordine naturale delle sue chiavi o in base a un Comparator valore fornito al momento della creazione della mappa, a seconda del costruttore utilizzato. Si noti che l'ordinamento mantenuto da una mappa ad albero, come qualsiasi mappa ordinata, e se viene fornito o meno un comparatore esplicito, deve essere coerente con equals se questa mappa ordinata deve implementare correttamente l' Map interfaccia.

• TreeMap()

• TreeMap(Map<? extends K,? extends V> parent) = crea una mappa e la riempie con le coppie contenute in parent

classe astratta java.io.Reader

• int read() throws java.io.IOException = blocca l'esecuzione finché non c'è un carattere da leggere; a quel punto ritorna il codice

Unicode del prossimo carattere letto; ritorna - 1 se la sorgente di lettura è terminata

• int read(char[] buffer) throws java.io.IOException = blocca l'esecuzione finché non arriva qualche carattere da leggere; a quel punto

scrive i caratteri nel buffer e ritorna il numero di caratteri letti; ritorna - 1 se la sorgente di lettura è terminata classe java.io.FileReader (oltre quelli ereditati da java.io.Reader)

• FileReader(String fileName) throws java.io.FileNotFoundException = crea un lettore di file che legge i caratteri dal file di testo col

nome indicato classe java.io.BufferedReader (oltre quelli ereditati da java.io.Reader)

• BufferedReader(Reader parent) = crea una vista bufferizzata di parent

classe astratta java.io.Writer

• void write(int c) throws java.io.IOException = interpreta i 16 bit meno significativi di c come codice Unicode di un carattere e lo

scrive nel file

• void write(char[] buffer) throws java.io.IOException = scrive nel file i caratteri contenuti nell'array buffer

• void write(String s) throws java.io.IOException = scrive nel file i caratteri della stringa s

classe java.io.FileWriter (oltre quelli ereditati da java.io.Writer)

• FileWriter(String fileName) throws java.io.IOException = crea uno scrittore di file che scrive i caratteri nel file di testo col nome

indicato classe java.io.BufferedWriter (oltre quelli ereditati da java.io.Writer)

• BufferedWriter(Writer parent) = crea una vista bufferizzata di parent

classe java.io.PrintWriter (oltre quelli ereditati da java.io.Writer)

• PrintWriter(String fileName) throws java.io.FileNotFoundException = crea uno scrittore di file che scrive i caratteri nel file di testo col

nome indicato

• void print(int i) = scrive i caratteri della rappresentazione decimale dell'intero i nel file. Questo metodo esiste anche per gli altri tipi

primitivi

• void println(int i) = scrive i caratteri della rappresentazione decimale dell'intero i nel file. Questo metodo esiste anche per gli altri tipi

primitivi

• void print(String s)

• void println(String s)

• PrintWriter printf(String format, Object... args) = scrive il formato nel file, in stile linguaggio C

interfaccia java.lang.Iterable

• Iterator iterator() = ritorna un iteratore, cioè un oggetto capace di restituire gli elementi dell'iterabile, uno alla volta

interfaccia java.util.Iterator

• boolean hasNext()

• T next()

classe java.lang.Thread

• Thread() = costruisce un thread che, quando verrà mandato in esecuzione, eseguirà il codice del suo metodo run()

• Thread(Runnable runnable) = costruisce un thread che, quando verrà mandato in esecuzione, eseguirà il codice del

metodo run() del runnable

• void start() = manda in esecuzione il metodo run() del thread e ritorna immediatamente il controllo al chiamante; i due thread

continueranno in parallelo

• void run() = specifica il codice che viene eseguito in parallelo quando si chiama start()

• void join() throws java.lang.InterruptedException = sospende il chiamante finché il thread destinatario non termina; se il chiamante

viene interrotto mentre aspetta, viene lanciata una InterruptedException

• static void sleep(long milliseconds) throws InterruptedException = sospende il chiamante per il numero di millisecondi indicato; se il

chiamante viene interrotto mentre aspetta, viene lanciata una InterruptedException

• static Thread currentThread() = ritorna il thread che sta eseguendo il codice chiamante

interfaccia java.util.function.Consumer

• void accept(T t) = esegue del codice che usa t

interfaccia java.util.function.Predicate

• boolean test(T t) = determina se t soddisfa il predicato

interfaccia java.util.function.Supplier

• T get() = fornisce un oggetto di tipo T

interfaccia java.util.function.Function<T,U>

• boolean U apply(T t) = ritorna il valore della funzione applicata a t

§ lista di modificatori § tipo di ritorno: o se ritorna dei valori bisogna specificare il tipo o se non ritortna dei valori, viene usata la parola chiave void § identificatore § una coppia di parentesi tonde con all’interno una lista di parametri: possono contenere informaziuoni che possono essere passati al metodo quando esso viene invocato, e rappresentano quindi l’input del metodo § corpo del metodo: è l’insieme di istruzioni che verranno eseguite quando il metodo verrà invocato esempio: public class VariazioniDiVariabile { public static void main (String args[] ) { double tassoDiConversione=1.1; System.out.println(“Valore attuale del tasso di conversione: ” + tassoDiConversione); tassoDiConversione=1.3; System.out.println(“Valore attuale del tasso di conversione: ” + tassoDiConversione); tassoDiConversione=tassoDiConversione- 0 .3; System.out.println(“Valore attuale del tasso di conversione: ” + tassoDiConversione); } } Il codice contiene varie ripetizioni. Senza modificare l'output del programma, modifichiamo il codice aggiungendo un metodo che si occupi di stampare il valore della variabile tassoDiConversione public class VariazioniDiVariabile { public static void main (String args[] ) { double tassoDiConversione=1.1; stampaTasso(tassoDiConversione); tassoDiConversione=1.3; stampaTasso(tassoDiConversione); tassoDiConversione=tassoDiConversione-0.3; stampaTasso(tassoDiConversione); } public static void stampaTasso(double tasso) { System.out.println(“Valore attuale del tasso di conversione: ” + tassoDiConversione); } } quindi l’invocazione di un metodo, in questo caso avviene usando la seguente sintassi: stampaTasso(tassoDiConversione); Questo significa che il valore della variabile tassoDiConversione aveva nel momento della chiamata, verrà copiato nella variabile parametro tasso del metodo stampaTasso.

  • classe = astrazione indicante un insieme di oggetti che condividono le stesse caratteristiche e le stesse funzionalità
  • oggetto = istanza di una classe esempio: ho creato la classe Punto public class Punto { public int x; public int y; } una classe dovrebbe limitarsi a definire la struttura che avranno gli oggetti da essa istanziati. Istanziare = object oriented che si usa in un luogo di creare fisicamente, ed il risultato di un’istanziazione viene chiamato oggetto esempio: public class TestOggettiPunto { public static void main (String args[]) { Punto punto1; punto1=new Punto(); punto1.x=2; punto1.y=6; Punto punto2=new Punto(); punto2.x=0; punto2.y=1; System.out.println(punto1.x + punto1.y + punto2.x + punto2.y); } } Andiamo nel dettaglio:
  • “Punto punto1;” à dichiarazione di un oggetto, non significa crearlo, ma solo definirne il nome (identificatore) ed associargli il tipo. La sintassi per dichiarare un oggetto quindi, consiste nel far precedere al nome dell'oggetto la dichiarazione del suo tipo
  • “punto1=new Punto();” à crea l’oggetto punto1 della classe Punto. Due istruzioni: un’assegnazione e l’espressione “new Punto()”, che istanzia l’oggetto, mentre l’operatore = assegna l’oggetto creato al nome punto1. Quindi new istanzia la classe Punto, e a questa istanzia viene assegnato il nome punto
  • “punto1.x=2” e “punto1.y=6” à per accedere alle variabili x e y abbiamo utilizzato l’operatore dot. L’istruzione punto1.x = 2, assegna il valore intero 2 alla variabile x dell’oggetto punto1. Le variabili x e y sono state dichiarate nella classe Punto

L’operatore “.” = sinonimo di appartenenza. Le variabili dichiarate nella classe sono quindi possedute dagli oggetti e saranno chiamate variabili di d’istanza, ovvero variabili dell'oggetto. Infatti due oggetti istanziati avevano valori diversi per x e y, il che significa che ognuno dei due oggetti punto 1 e punto 2 ha la sua variabile x la sua variabile y

  • ci consentono di memorizzare i dati
  • è una porzione di memoria in cui è immagazzinato un valore di un certo tipo.
  • il tipo di dato che viene definito per una variabile è un vincolo per il valore assegnabile alla variabile stessa due fasi distinte: dichiarazione e assegnazione Nella dichiarazione, le variabili vengono definite da: § lista di modificatori § tipo di dato [modificatori] tipo_di_dato identificatore [= valore] ; § identificatore § valore à variabile senza valore non avrebbe senso Non è possibile utilizzare una variabile se non è stata prima inizializzata, e non è possibile definire una variabile al di fuori di una classe. 3 diverse tipologie di variabili:
  1. variabili d’istanza:
  • se è dichiarata in una classe, ma al di fuori di un metodo
  • condividono il proprio ciclo di vita con l’oggetto a cui appartengono
  • quando un oggetto di una classe è istanziato, viene allocato spazio in memoria per tutte le variabili d’istanza che vengono inizializzate ai relativi valori nulli
  • smetterà di esistere quando smetterà di esistere l’oggetto a cui appartiene
  1. variabili locali:
  • se è dichiarata all’interno di un metodo
  • smetterà di esistere quando terminerà il metodo
  • non saranno inizializzate a valore nullo, non vengono inizializzate automaticamente, è necessario farlo esplicitamente
  • condividono il loro ciclo di vita con il blocco di codice in cui sono dichiarate
  • non ha senso anteporre un modificatore d’accesso
  1. parametri:
  • dichiarate all’interno delle parentesi tonde che si trovano alla destra dell’identificatore nella dichiarazione di un metodo
  • saranno inizializzati nel momento della chiamata del metodo stesso
  • si può considerare anche come variabile locale, essendo visibile solo all’interno del metodo e condividendo con esso il ciclo di vita, l’unica differenza è la loro posizione nel metodo definiscono un blocco di codice in cui possiamo definire una sequenza di istruzioni, e possiamo definire dei parametri di input da utilizzare all’interno del proprio blocco di codice
  • devono avere lo stesso nome della classe
  • non dichiarano alcun tipo di ritorno à non può considerarsi un metodo ordinario à non si può chiamate tramite l’operatore dot ma con l’utilizzo dell’operatore new
  • può avere una lista di parametri
  • sono invocati automaticamente ogni volta che è istanziato un oggetto, relativamente a quell’oggetto
  • almeno un costruttore è sempre presente in ogni classe
  • viene definito allo scopo di inizializzare le variabili d’istanza 8 tipi:
  • interi: vengono memorizzati tramite il metodo del completamento a due, tutti possono immagazzinare numeri interi positivi o negativi, ma differiscono per quanto riguarda il proprio intervallo di rappresentazione Per immagazzinare un intero è possibile utilizzare quattro tipi di sistemi numerici: o decimale: non è necessario utilizzare prefissi o binaria: è necessario anteporre uno 0 e una b o ottale: è necessario anteporre uno 0 o esadecimale: è necessario anteporre uno 0 e una x esempio: byte b=10; //notazione decimale short s=022; // notazione ottale long l=0x12aCd; //notazione esadecimale int i=10000; //notazione decimale int n=0b1010001101001011; //notazione binaria
  • floating point: o float : tipo a 32 bit o double : tipo a doppia precisione che usa 64 bit
  • testuale: char permette di immagazzinare caratteri, uno per volta, ogni carattere deve essere incluso tra apici singoli
  • logico booleano: boolean utilizza solo un bit per memorizzare un valore e gli unici valori che può immagazzinare sono true e false Tipo Intervallo di rappresentazione Byte 8 bit Short 16 bit Int 32 bit long 64 bit

Final:

  • dichiara costanti, inteso come “non modificabile”
  • una variabile diventa una costante
  • un metodo non può essere riscritto in una sottoclasse
  • una classe non può essere estesa
  • si può utilizzare anche per variabili locali e parametri locali di metodi. I valori di queste variabili non saranno modificabili localmente Protected:
  • definisce per un membro il grado più accessibile dopo quello definito da public
  • sarà accessibile all’interno dello stesso package, e verrà anche ereditato in tutte le sottoclassi della classe in cui è definito, anche se non appartenenti allo stesso package Abstract:
  • può essere applicato solo a classi e metodi, mentre non può essere utilizzato con record e variabili
  • metodo astratto non implementa un proprio blocco di codice e quindi è privo di comportamento. Non possedendo un blocco di codice termina con un punto e virgola. Esempio: public abstract void dipingiQuadro(); à questo non potrà essere invocato ma potrà essere soggetto a riscrittura in una sottoclasse
  • una classe dichiarata astratta non può essere istanziata à significa voler indirizzare lo sviluppo verso la creazione di sottoclassi della classe astratta
  • le sottoclassi devono ridefinire il metodo astratto
  • opposto di final perché non può essere estesa, invece abstract sì MODIFICATORE STESSA CLASSE STESSO PACKAGE SOTTOCLASSE OVUNQUE Public SI SI SI SI Protected SI SI SI NO Nessun modificatore SI SI NO NO private SI NO NO NO Extends:
  • sottoclasse = è una classe che stende un’altra classe ereditandone le caratteristiche
  • due classi possono essere messe in relazione di ereditarietà tra loro scrivendo semplicemente che una classe estende l’altra
  • può ereditare i metodi pubblici dell’altra classe
  • ci permette di implementare l’ereditarietà à ci consente di mettere in relazione di estensione le due classi implements: le classi implementano le interfacce
  • si adopera in modo analogo ad extends, e produce lo stesso risultato: ereditare i membri dell’interfaccia implementata Super: reference implicito all’intersezione tra l’oggetto corrente e la sua superclasse
  • con costruttori : in ogni costruttore, è sempre presente una chiamata al costruttore della superclasse, mediante una sintassi che sfrutta super. Esempio: che sfrutta la classe LibroSuJava, il costruttore sarà modificato: public class LibroSuJava extends Libro { il costruttore della classe Libro (senza public LibroSuJava { parametri) viene invocato dal costruttore super(); //istruzione implicita se non fornita esplicitamente della classe LibroSuJava. Possiamo System.out.println(“Java”); esplicitare la chiamata a super(), ma se non } lo facciamo il compilatore considererà } questa istruzione implicita. Supponiamo ora di voler dotare la superclasse Libro di un costruttore che imposti un valore alla variabile titolo public class Libro { public Libro (String titolo) { questa compilerà ma LibroSuJava non compilerà più. Quindi l’istruzione this.titolo = titolo; super(), inserita automaticamente nella sottoclasse LibroSuJava, prova a } chiamare il costruttore della superclasse senza parametri, quindi, occorre } modificare il costrutto di LibroSuJava in modo tale da fargli invocare il costruttore della superclasse Libro che prende come parametro di input il titolo: public class LibroSuJava extends Libro { public LibroSuJava (String titolo) { super(titolo); } }
  • può essere usata solo come prima istruzione in un costruttore à solo un’istruzione tra super e this sarà presente in un costruttore
  • con metodi : esempio: public class Anagrafica { public class Cliente extends Anagrafica { private String nome, cognome; private String indirizzo, tel; public Anagrafica(String nome, String cognome){ public Cliente (String nome, String cognome, setNome(nome); String indirizzo, String tel) { setCognome(cognome); super(nome, cognome); } setIndirizzo(indirizzo); public void stampaAnagrafica() { setTel(tel); System.out.println(nome + “ “ + cognome); } } public void stampaAnagraficaCliente () { } super.stampaAnagrafica(); System.out.println(indirizzo + “\nTel:

“ + tel); } Codice : } Cliente cliente = new Cliente (“Vince”, “Papa”, “Via Gramsci”, “666”); cliente.stampaAnagraficaCliente(); Output : Vince Papa \n Via Gramsci \n Tel: 666 coincide con il reference all’oggetto corrente, viene implicitamente aggiunto al bytecode compilato

  • con variabili: fino a d’ora, per il parametro passato, siamo stati spinti ad inventare un identificatore differente da quello della variabile d’istanza da inizializzare. Invece possiamo usare il reference this per risolvere varie ambiguità esempio: public class Cliente { private String nome, indirizzo, numeroTel; public void setNumeroTel (String numeroTel) { this.numeroTel = numeroTel; } public void setIndirizzo (String indirizzo) { this.indirizzo = indirizzo; } public void setNome (String nome) { this.nome = nome; } }
  • con metodi: rappresenta l’oggetto corrente e può quindi referenziare le variabili d’istanza. E’ possibile anche invocare metodi esempio: public class Cliente { private String nome; private String indirizzo; private String numeroTel; public Cliente (String nome, String indirizzo, String numeroTel) { this.setNome(nome); this.setIndirizzo(indirizzo); this.setNumeroTel(numeroTel); } public void setNumeroTel (String numeroTel) { this.numeroTel = numeroTel; } public void setIndirizzo (String indirizzo) { this.indirizzo = indirizzo; } public void setNome (String nome) { this.nome = nome; } }
  • con i costruttori: la sintassi cambia visto che per un costruttore l’operatore dot non è utilizzabile. esempio: public class Cliente { public Cliente(String nome, String indirizzo) { E’ stato invocato dal primo this(nome, indirizzo, “sconosciuto”); costruttore il secondo } costruttore. In questo public Cliente(String nome, String indirizzo, String numeroTel){ modo si è riusato il codice this.setNome(nome); del secondo costruttore, this.setIndirizzo(indirizzo); senza scrivere di nuovo le this.setNumeroTel(numeroTel); stesse istruzioni } } è un metodo che è condiviso da tutti gli oggetti istanziati dalla classe in cui è dichiarato. Appartiene alla classe stessa e non ad un’istanza particolare. Variabile statica:
  • essendo condivisa da tutte le istanze della classe assumerà lo stesso valore per ogni oggetto di una classe
  • se un’istanza modifica la variabile statica, essa risulterà modificata anche all’altra istanza
  • viene inizializzata al valore nullo del suo tipo quando viene caricata in memoria la classe, e non al momento dell’istanza dell’oggetto Per dichiarare basta posporre o anteporre, una coppia di parentesi quadre all’identificatore. Due dichiarazioni:
  1. array di tipo primitivo à esempio: char alfabeto []; oppure char [] alfabeto;
  2. array di tipo complesso à esempio: File files []; oppure File [] files; Va istanziato in modo speciale: è obbligatorio specificare, nel momento dell’istanza dell’array, la sua dimensione tra parentesi quadre. Una volta dichiarata, non è più modificabile à esempio: alfabeto = new char[21]; oppure files = new File[3]; Per inizializzare un array è necessario inizializzare singolarmente ogni elemento

variabile = (espressione-booleana)? espr1 : espr2;

  • cicli : o while: permette di eseguire più volte uno statement tante volte fino a quando una condizione booleana è verificata [inizializzazione;] esempio: public class WhileDemo { while(espressione-booleana) { public static void main(String args []) { istruzione-1; int i = 1; istruzione-2; while(i <= 10) { …………..; System.out.println(i); istruzione-i; i++; [aggiornamento iterazione;] } } }} o for: for(inizializzazione; espressione-booleana; aggiornamento) { istruzione-1; istruzione-2; …………..; istruzione-i; } o foreach: for(variabile_temporanea : oggetto_iterabile) { oggetto_iterabile = l’array su cui elementi si istruzione-1; vuole iterare istruzione-2; variabile_temporanea = variabile alla quale, …………..; durante l’esecuzione del ciclo, sarà assegnato istruzione-i; il valore dell’i-esimo elemento } dell’oggetto_iterabile all’i-esima iterazione viene usato soprattutto quando si vuole iterare su tutti gli elementi di un oggetto iterabile esempio: int [] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9}; for(int tmp : arr) { System.out.println(tmp); } o do-while: viene prima eseguito il blocco di codice e poi valutata l’espressione booleana. Se l’espressione booleana è verificata viene rieseguito il blocco di codice, altrimenti il ciclo termina [inizializzazione;] esempio: public class DoWhile { do { public static void main (String args[]) { istruzione-1; int i = 10; istruzione-2; do { …………..; System.out.println(i); istruzione-i; }while(i < 10); [aggiornamento iterazione;] } } while (espressione-booleana); } Break = comando capace far terminare qualsiasi ciclo Continue = fa terminare solo l’iterazione corrente di un ciclo, ovvero fa saltare alla prossima iterazione
  • evoluzione del concetto di classe astratta
  • classe senza la sua implementazione interna
  • vuole rappresentare quella che con l’incapsulamento è chiamata interfaccia pubblica à parte visibile dall’esterno, che nasconde la sua implementazione interna
  • possiede solo metodi dichiarati statici (non vengono erteditati), public e abstract e variabili dichiarate implicitamente public, static e final
  • ogni membro dell’interfaccia ha una visibilità pubblica
  • non si può istanziare e non può dichiarare costruttori
  • una classe può implementare una o più interfacce, ma può estendere un’unica classe. Un’interfaccia può estendere una o più interfacce, in qualsiasi caso però non può estendere una classe esempio: public interface Pesabile { String unita_di_misura = “kg”; double getPeso(); } realizzazione pratica sotto due forme: overload = sovraccarico, e override = riscrittura. Overload:
  • per metodi : ci permetterà di utilizzare lo stesso nome per metodi differenti. In un metodo, la coppia costituita dall’identificatore e dalla lista di parametri è detta firma. In una classe possono convivere metodi con lo stesso nome ma con differente firma

esempio: public class Aritmetica { public static int somma (int a, int b) { cinque metodi che hanno lo stesso nome ed return a + b; eseguono somme, in modo differente. La lista } dei parametri ha 3 criteri: public static float somma (int a, float b) { 1. di tipo return a + b; 2. numerico } 3. posizionale public static float somma (float a, int b) { return a + b; } public static int somma (int a, int b, int c) { return a + b + c; } public static double somma (int a, double b, float c) { return a + b + c; } }

  • per costruttori : overload di costruttori esempio: public class Cliente { private String nome; private String indirizzo; private String numeroTel; public Cliente () { //costruttore inserito esplicitamente (non di default) } public Cliente (String nome) { this.nome = nome; } public Cliente (String nome, String indirizzo) { this(nome); this.indirizzo = indirizzo; } public Cliente (String nome, String indirizzo, String numeroTel) { this(nome, indirizzo); this.numeroTel = numeroTel; } } Override: è il termine object oriented che descrive la possibilità che hanno le sottoclassi di ridefinire un metodo che hanno ereditato da una superclasse. Non esisterà override senza ereditarietà. Regole:
  1. il metodo riscritto nella sottoclasse deve avere la stessa firma (nome e parametri) del metodo della superclasse
  2. tipo di ritorno del metodo della sottoclasse deve coincidere con quello del metodo originale della superclasse
  3. il metodo ridefinito nella sottoclasse non deve essere meno accessibile del metodo originale della superclasse il nostro programma incontra un situazione imprevista durante il runtime, la JVM istanzia un oggetto della classe eccezione corrispondente al problema e lancia l’eccezione appena istanziata (throw). Se il nostro codice non cattura (catch) l’eccezione, il gestore automatico della JVM interromperà il programma generando un output stackOverflowError VirtualMachineError OutOfMemoryError Error ATWError Throwable ArithmeticException RuntimeException NullPointerException Exception EOFException IOException FileNotFoundException Eccezioni più comuni:
  • NullPointerException = quando viene chiamato un metodo su di un reference che invece punta a null, ovvero a nessun oggetto
  • ArrayIndexOutOfBoundsException = quando si prova ad accedere ad un elemento di un array specificando un indice non valido
  • ClassCastException = quando si prova ad effettuare un cast verso un tipo di classe inesatto Il simbolo “ | “ viene utilizzato per separare i nodi dei tipi di eccezione, ma viene dichiarato un unico reference abbiamo a disposizione cinque parole chiave:
  • try e catch: esempio senza try catch: esempio con try-catch: public class Ecc1 { public class Ecc2 { public static void main (String args[] ) { public static void main (String args[]) { int a = 10; Int a = 10; int b = 0; int b = 0;
  • interfaccia List = fa ereditare alle sue implementazioni concrete, le proprietà di essere collezioni indicizzate ridimensionabili à classi ArrayList e LinkedList
  • interfaccia Set = fa fa ereditare alle sue implementazioni concrete, le proprietà di essere collezioni ridimensionabili che non ammettono duplicati à classi HashSet e TreeSet
  • detta anche funzione anonima
  • uso di parametri che non sono variabili, e non sono variabili locali al blocco di codice che definisce l’espressione
  • sintassi: ([lista_di_parametri]) - > {blocco_di_codice}
  • l’unica cosa che può fare un’espressione lambda è sostituire l’implementazione di un’interfaccia funzionale Esempio: usando espressione lambda : new Threaad (new Runnable() { new Thread (() - > System.out.println(“Classe”)).start(); public void run () { System.out.println(“Classe”); } }).start(); è una sequenza di elementi su cui possiamo iterare, è unica e una volta terminata, lo stream non è più utilizzabile. Non immagazzina elementi, ma permette di operare su questi elementi attraverso pipeline = sequenza di operazioni fluent-style. è costituita da 3 elementi:
  1. sorgente: coincide con una collection o un array. Deve mettere a disposizione un metodo per ottenere un oggetto Stream
  2. zero o più operazioni di aggregazione: hanno la caratteristica di ritornare un nuovo oggetto Stream
  3. almeno un’operazione terminale: metodo che restituisce un risultato che non è un oggetto stream esempio: Collection smart = getSmart(); filter() = filtra e restituisce un valore stream double average = smart.stream() mapToDouble() = restituisce uno stream che .filter(s - > s.getMarca().equals(“Samsung”)) contiene solo elementi double .mapToDouble(Smartphone::getPrezzo).average():getAsDouble(); average() = esegue una media matematica degli elementi della collection di double e ritorna un’oggetto di tipo OptionalDouble. getAsDouble = ritorna il valore double che rappresenta la media matematica il seguente programma riesce a leggere ciò che l’utente scrive sulla tastiera, e dopo la pressione del tasto invio, ristampa quanto letto: public class KeyboardInput { public static void main (String args[] ) { String stringa = null; System.out.println(“Digita: “); try(InputStreamReader ir = new InputStreamReader(System.in); BufferedReader in = new BufferedReader(ir) { stringa = in.readLine(); while(stringa != null) { if(stringa.equals(“fine”)) { System.out.println(“Terminato”); break; } System.out.println(“Hai scritto: “ + stringa); stringa = in.readLine(); } } } } BufferedRead = mette a disosizione del programma diversi metodi: readLine() = che restituisce il contenuto dello stream sotto forma di stringa fino alla pressione del tasto invio un metodo che specifica un parametro di tipo varargs, può accettare un numero non precisato di argomenti evitando così un eccessivo overload di metodi. La sintassi fa uso di un’ellissi, rappresentata da puntini sospensivi “ “. E’ possibile dichiarare un unico varargs a metodo, e deve occupare l’ultima posizione nella lista di parametri. Sono considerati a tutti gli effetti degli array esempio: public class AritmeticaVarArgs { public static double somma (double … doubles) { double risultato = 0.0D; for(double tmp : doubles) risultato += tmp; return risultato; } } restituisce una stringa contenente la descrizione dell’oggetto , che solitamente coincide con la descrizione delle sue variabili d’istanza con i relativi valori. Nelle situazioni in cui un oggetto deve essere stampato a video sarà chiamato automaticamente il suo metodo toString esempio di codice: Object obj = new Date();

String descrizione = obj.toString(); //invocazione virtuae del metodo esempio di implementazione:public String toString() { return “(“ + getX() + “,” + getY() + “)”); }

  • metodo della classe Object
  • serve per confrontare due reference e restituire il valore booleano true se e solo se i due reference puntano ad uno stesso oggetto à questo è fattibile anche mediante “ == “
  • restituisce true nel caso di confronto tra due reference che puntano ad oggetti diversi ma con gli stesi contenuti ha un ruolo complementare a equals per confrontare l’uguaglianza di due oggetti presenti nella stessa collezione. Un hash code non è altro che un int che identifica un oggetto. Ha alcune regole:
  1. Se due oggetti sono uguali relativamente al loro metodo equals, allora devono avere anche lo stesso hash code. Quindi, dati due oggetti o1 e o2, se o1.equals(o2) restituisce true, allora tali oggetti devono avere anche lo stesso hash code
  2. Due oggetti con lo stesso, non devono essere obbligatoriamente uguali per il loro metodo equals. Questo significa che se o1.hashCode è uguale a o2.hashCode, non è necessario che o1.equals(o2) restituisca true
  3. Se il metodo hashCode è chiamato più volte all'interno della stessa esecuzione, il metodo deve ritornare sempre lo stesso valore intero
  4. Per calcolare l'hash code, il metodo hashCode è bene che utilizzi le stesse variabili d’istanza utilizzate nel metodo equals
  • il tipo stringa permette di immagazzinare un testo composto da caratteri, numeri o simboli
  • le stringhe sono oggetti , dovrebbe essere istanziate con la solita sintassi tramite la parola new à String nome = new String(“Lisa”); ma possiamo utilizzarle come se fosse un tipo di dato primitivo à String nome = “Lisa”;
  • per rendere una stringa costante è necessario dichiararla final
  • è possibile assegnare un nuovo oggetto ad una stringa Operazioni: ci garantisce la possibilità di poter usufruire di una serie di metodi di utilità: o charAt à ci permette di recuperare un carattere dalla stringa ad un certo indice specificato (indici iniziano da 0) o indexOf à permette di recuperare l’indice della prima occorrenza di un certo carattere specificato o lenght à restituisce il numero dei caratteri che costituiscono la stringa su cui è chiamato il metodo o toUpperCase à ogni carattere in maiuscolo o toLowerCase à ogni carattere in minuscolo Esistono tanti metodi definiti dalla classe string ma nessuno di essi può modificare un oggetto String à è immutabile: tali metodi non vanno a modificare l’oggetto su cui sono chiamati, semplicemente ne restituiscono un altro astrae il concetto di oggetto generico ed è di fatto la superclasse di ogni classe. E’ in cima alla gerarchia delle classi e quindi tutte le classi ereditano i membri di Object. Se definissimo una classe che non estende altre classi, essa automaticamente estenderebbe Object implementa un array espandibile di oggetti. Come un array, contiene componenti a cui è possibile accedere utilizzando un indice intero. Tuttavia, la dimensione di un vettore può aumentare o ridursi secondo necessità per consentire l'aggiunta e la rimozione di elementi dopo la creazione del vettore. Estende AbstractList e implementa le interfacce List. Costruttori:
  • Vector() = Crea un vettore predefinito, che ha una dimensione iniziale di 10
  • Vector(int size) = Accetta un argomento uguale alla dimensione richiesta e crea un vettore la cui capacità iniziale è specificata dalla dimensione
  • Vector (int size, int inc) = Crea un vettore la cui capacità iniziale è specificata da size e il cui incremento è specificato da incr. L'incremento specifica il numero di elementi da allocare ogni volta che un vettore viene ridimensionato verso l'alto.
  • Vector (Collection c) = Crea un vettore che contiene gli elementi della collezione c.
  • implementa l’interfaccia List, e quindi è una collezione i cui elementi sono indicizzati come array tradizionali
  • dichiarazione: ArrayList strings = new ArrayList(); ArrayList strings = nw ArrayList<>();
  • agli oggetti aggiunti in un arraylist, sarà assegnato un indice che parte da 0 à sono ordinati secondo l’ordine di inserimento segue un frammento di codice che dichiara una mappa generica, con il parametro chiave Integer e il parametro valore di tipo String: Map<Integer, String> map = new HashMap<Integer, String>();
  • collezione che estende l’interfaccia Set
  • non gestisce l’ordinamento dei suoi elementi
  • utilizza internamente un HashMap per mappare i suoi elementi e recuperarli velocemente, associando ad ognuno di essi un hash code
  • ammette anche l’elemento null ma non ammette dulicati
  • per il confronto à metodo equals à metodo hashCode

public int compareTo(T o); - un valore negativo se l’oggetto corrente è minore dell’oggetto in input } - il valore 0 se i due oggetti sono equivalenti

  • un valore positivo nel caso l’oggetto corrente sia maggiore dell’oggetto in input In generale, quando una classe implementa Comparable, significa che è ordinabile all’interno di una collezione o di un array
  • funzionale e generica
  • .compare() = viene chiamato su un’istanza di Comparator e prende in input le due istanze della classe
  • reverse() = serve per capovolgere le stringhe
  • asList() = riempire la lista con elementi di un array
  • sort() = prende come parametro in input un oggetto Comparator, e ordna secondo quanto specificato dalla classe creata da noi
  • esempio: public class Comp implements Comparator { public int compare (String s1, String s2) { StringBuilder sb1 = new StringBuilder(s1); StringBuilder sb2 = new StringBuilder(s2); s1 = sb1.reverse().toString(); s2 = sb2.reverse().toString(); return s1.compare(s2); }}
  • dichiarazione : public interface Consumer { void accept(T t); }
  • adatta per aggiornare lo stato dell’oggetto che viene passato al suo metodo, oppure per utilizzarlo
  • accept non ha tipo di ritorno
  • dichiarazione : public interface Supplier { T get(); }
  • serve per gestire una factory
  • get = restituisce un’istanza del tipo parametro dichiarato esempio: posso implementare Chitarrista con Supplier public class Chitarra { public class Chitarrista { private String marca; public void suoChi(Supplier marcaS){ public Chitarra(String marca) { Chitarra chitarra = marcaS.get(); this.marca = marca; chitarra.suona(); System.out.println(“Crea Chitarra “ + marca); } } } public void suona() { System.out.prinln(“sta suonando ” + marca); } }
  • dichiarazione : public interface Function<T, R> { R apply( T t); }
  • permette di astrarre il concetto di funzione dove c’è un input e un output
  • dichiarazione : public interface UnaryOperator extends Function<T, T> { }
  • un’estensione dell’interfaccia Function e quindi eredita il metodo astratto: T apply(T t);
  • estrae un’operazione che viene fatta su un singolo parametro e produce un risultato dello stesso tipo del parametro