Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
vuoi
o PayPal
tutte le volte che vuoi
Utilizzo dei tipi parametrici in Java
public class Esempio<T> {
private T dati;
public void setDati(T nuovoValore) {
dati = nuovoValore; }
public T getDati( ) {
return dati; }}
Si noti la presenza delle parentesi angolari intorno a <T> nell'intestazione della classe.
Inoltre per convenzione, i tipi parametrici iniziano con una lettera maiuscola.
Quando si scrive una classe o un metodo che utilizza un tipo parametrico, si può utilizzare tale parametro in quasi qualsiasi punto in cui si può utilizzare un tipo classe. Non si può utilizzare per creare un nuovo oggetto o quando si alloca memoria per un array.
NO! Dati = new T( );
NO! nomeArray = new T[20];
SI! T[ ] nomeArray;
SI! Perché non è usato come tipo parametrico ma come nome di costruttore
NO! T[ ] a = new T[10];
Una definizione di classe che utilizza un tipo parametrico viene memorizzata in un file compilato come qualsiasi altra classe. Una volta compilata occorre specificare il tipo di classe che costituisce il tipo.
parametrico.NomeClasse<tipobase> nomeOggetto = new NomeClasse<tipobase>( );
Esempio<String> sc = new Esempio<String>( );
sc.setDati(“Ciao”);
ArrayList è una classe parametrica. classe specializzata
Quando si definisce il tipo base, non è più una classe generica ma una che
si può usare per definire oggetti come le classi normali.
Analogamente si può definire un'interfaccia generica, mentre i tipi enumerativi non possono
essere generici.
Es.
public class Coppia<T> {
private T primo;
private T secondo;
le dichiarazioni dei costruttori non includono
public Coppia( ) {
il tipo parametrico tra < >
primo = null;
secondo = null;
}
public Coppia(T primoElemento, T secondoElemento) {
primo = primoElemento;
secondo = secondoElemento;
}
public void setPrimo (T nuovoPrimo) {
primo = nuovoPrimo;
}
public void setSecondo (T nuovoSecondo) {
secondo = nuovoSecondo;
}
public T getPrimo( ) {
return primo;
}
}
Uso della classe Coppia
import
```html
java.import.Scanner;
public class CoppiaGenericaDemo {
public static void main (String args[ ]) {
Coppia<String> coppiaSegreta = new Coppia<String>(“Buona”,”Giornata);
Scanner tastiera = new Scanner(system.in);
System.out.println(“Inserire due parole”);
String parola1 = tastiera.next( );
String parola2 = tastiera.next( );
Coppia<String> coppiaDiInput = new Coppia<String>(parola1,parola2);
…
}
}
Un tipo parametrico può essere utilizzato come parametro per un costruttore, ma l'intestazione
del costruttore non include il tipo farà metrico tra parentesi angolari:
public Coppia(T primoElemento, T secondoElemento)
Quando sei stanze una classe parametrica specificando un tipo da sostituire a quello parametrico,
tale tipo deve essere indicato tra parentesi angolari dopo il nome del costruttore, come nel
seguente esempio:
Coppia<String> coppiaSegreta = new Coppia<String> (“Buona”,
```“Giornata”);
Quando si crea un oggetto di una classe che è un tipo parametrico, non si può sostituire il tipo parametrico con un tipo primitivo.
ArrayList<int> unaLista = new ArrayList<int> (20);
Non si può avere un oggetto di tipo ma se ne può avere uno di tipo Coppia<int>, che grazie alla conversione automatica (boxing) può essere utilizzato con Coppia<Integer>, valori di tipo .int
Le definizioni di array come la seguente non sono ammesse: NO!
Coppia<String>[ ] a = new Coppia<String>[10];
11.2.2 Vincoli su tipi parametrici
Si supponga di voler aggiungere un metodo che costituisca il massimo tra i due valori nella coppia ordinata. Si potrebbe aggiungere alla classe coppia la definizione del seguente metodo:
public T massimo( ) {
if (primo.compareTo(secondo) <= 0)
return primo;
else return secondo;
Il metodo è richiesto in ogni classe che implementi l’interfaccia compareTo Comparable.
Questa è
un'interfaccia della libreria standard di Java e richiede la presenza del solo metodo: ```java public int compareTo(Object altro) ``` Quando si definisce una classe che implementa l'interfaccia, è necessario definire il metodo `compareTo` in modo che restituisca: - un numero negativo se l'oggetto sul quale è stato chiamato il metodo viene prima del parametro `altro` - zero se l'oggetto sul quale è stato chiamato è uguale al parametro `altro` - un numero positivo se l'oggetto sul quale è stato chiamato viene dopo il parametro `altro` Tutto questo funziona solo se il tipo sostituito al parametro rispetta l'interfaccia `T, Comparable`, ma Java consente di inserire qualunque tipo al posto del tipo parametrico `T`. In Java è possibile esprimere restrizioni sui possibili tipi sostituibili a un tipo parametrico. Per garantire che si possono sostituire solo classi che implementino l'interfaccia, si inizia la definizione della classe come segue: ```java public class MyClassgenerico può essere un metodo di una classe regolare o generica. Quando lo si dichiara, il parametro tipo viene posto dopo i modificatori (es. public, static) prima del tipo di ritorno.
public static <T> void nomeMetodo(argomenti);
public static <T> void swap(T[ ] array, int i, int j);
Quando si chiama un metodo generico, non è necessario specificare il parametro tipo, ma se lo si vuole fare si può fare prima del nome del metodo:
Arrays.<tipo>nomeMetodo(parametri);
Arrays.<String>swap(friends, 0, 1);
CAPITOLO 12. ECCEZIONI
Un modo per scrivere programmi consiste nel presupporre che durante l'esecuzione non si presentino situazioni anomale. Una volta che il programma funziona correttamente, si aggiunge il codice che gestisce i casi eccezionali.
Java fornisce gli strumenti per dividere un programma in due sezioni: quella che gestisce il normale funzionamento e quella che gestisce il caso eccezionale.
Un'eccezione (exception) è un oggetto
Che segnala l'accadere di un evento anomalo durante l'esecuzione di un programma. Il processo di creazione di questo oggetto è chiamato eccezione. Il codice che rileva e si occupa dell'eccezione si dice che gestisce l'eccezione. Un metodo può segnalare la presenza di un problema "sollevando" (throw) un'eccezione. Il vantaggio fondamentale della gestione delle eccezioni è che disaccoppia i processi di rilevamento e di gestione degli errori. Questo avviene mediante l'utilizzo del gruppo di tre istruzioni: try-throw-catch.
Il blocco try:
try {
codice da provare
eventuale_generazione_di_eccezione
altro codice
}
È il blocco "prova" e contiene il codice che viene eseguito nelle situazioni normali. Nel caso qualcosa andasse storto, si vuole lanciare un'eccezione, che è un modo per indicare che sono sorti dei problemi.
import java.util.Scanner;
public class PrendiLatteConEccezioni {
public static void
main(String[] args) {
Scanner tastiera = new Scanner(system.in);
try {
System.out.println("Inserire numero ciambelle:");
int conteggioCiambelle = tastiera.nextInt();
System.out.println("Inserire numero bicchieri:dilatte:");
int conteggioLatte = tastiera.nextInt();
if (conteggioLatte < 1)
bloccotry throw new Exception("Eccezione: Niente latte!");
double ciambellePerBicchiere = conteggioCiambelle / (double) conteggioLatte;
System.out.println(conteggioCiambelle + " ciambelle.");
System.out.println(conteggioLatte + " bicchieri di latte.");
System.out.println("Hai " + ciambellePerBicchiere + " ciambelle per ogni bicchiere di latte.");
} catch (Exception e) {
blocco System.out.println(e.getMessage());
} catch System.out.println("Vai a comprare del latte.");
}
System.out.println("Fine programma.");
}}throw
L'oggetto eccezione viene costruito con un messaggio di debug.
Quando viene eseguita un'istruzione il normale corso di esecuzione viene throw, immediatamente interrotto, viene creato un nuovo oggetto della classe predefinita Exception mediante l'espressione: e lancia l'oggetto creato.
throw new Exception("Eccezione: Niente latte!");
throw new Exception("Messaggio");
Questa istruzione non specifica solamente un'azione che viene eseguita e subito dopodimenticata. Crea un oggetto che contiene un messaggio.
Quando viene lanciata una eccezione, l'esecuzione del codice all'interno del blocco viene try arrestata e viene eseguita un'altra porzione di codice, chiamata blocco catch (catturare l'eccezione).
Questa parte somiglia alla definizione di un metodo dotato di un parametro. Per questo motivo, nonostante non sia un metodo, l'identificativo viene chiamato parametro del blocco catch.
Esso fornisce un nome.all'eccezione è catturata. È possibile considerarlo come il nome dell'oggetto eccezione lanciato. Ogni oggetto eccezione è un metodo chiamato e agetMessagemeno che non lo si ridefinisca, questo metodo restituisce la stringa fornita al costruttore come argomento in fase di creazione dell'oggetto eccezione. Nell'esempio restituisce: "Eccezione: Niente latte!" nomeEccezione.getMessage(); Al termine dell'esecuzione del codice del blocco catch, il programma prosegue con il codice postale esterno dell'ultimo blocco non ritorna al blocco catch, try.
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo
