Appunti Corso Java R02

APPUNTI CORSO JAVA
Luca Girotti,Dicembre 2021

Print R01
1
COMANDI RAPIDI:
1 – Commenta piu’ linee: Ctrl + shift +/

2 – Generare metodi getters and setters automaticamente (vedi sotto).
3 – Generare costruttori dai campi (tasto destro, source, Generate
Constructors from fields) - (vedi sotto).
4- UML per Eclipse

https://www.appuntisoftware.it/disegnare-diagrammi-uml-
in-eclipse/
5- Ctrl (dx) + “+” : ingrandisce e diminuisce testo.
2
3
LEZIONE 15:
Compilazione ed esecuzione del Programma:
1 – New  Java Project:
2 – New Package: identifica il percorso in cui è presenta la classe.
3 – New Class:
4
4 – Come eseguo un software in maniera alternativa da console.
5 - Dopo aver compilato un file lo trovo anche nel percorso sotto:
Il file .class contiene il bytecode che a noi è illeggibile.
5
COME CREARE IL JAR: tasto destro sul progetto  EXPORT  JAR EXECUTABLE FILE  SELEZIONARE CARTELLA
DOVE E’ il .class, / Selezionare cartella di uscita
6
LEZIONE 16:
Debug del software cin Eclipse:
LEZIONE 17:
Organizzazione di un programma: come alternativa a quella sotto le variabili
si possono mettere in basso sotto ai metodi.
7
LEZIONE 18:
Keyword ed espressioni:
8
9
LEZIONE 19:
Variabili e tipi di dato:
Variabili:
• Locali: definite in un metodo, create quando invocate e cancellate
quando il metodo termina. Il nome della variabile è univoco per ogni metodo,
esternamente posso invece riutilizzarlo a meno che non venga passato come parametro.
• Di Istanza: definite in una classe ma fuori dai metodi della classe stessa. Il
nome della variabile è univoco per ogni classe, esternamente posso invece riutilizzarlo a
meno che non venga passato come parametro.
• Di Classe: sono variabili di istanza ma definite come static.

• Parametri: variabili che vengono dichiarate all’interno delle parentesi
tonde di un determinato metodo.
10
Tipi di dato:
•Primitivi: boolean, char, byte, double, float, int, long, short; Ogni tipo ha in
valore di default.
•Riferimento: Classi, interfacce…..utilizzano quantita’ di memoria variabile

in funzione del numero di informazioni contenute. Vieni inizializzata per
default a NULL.
LEZIONE 20:
Dati primitivi:
•Boolean: rappresenta true o false. Default=false

•byte: rappresenta -128 a +127 (inclusi). Memoria= 8 bit; Default=0;
Occupa ¼ di int, si usa per array grandi per occupare poco, non sono
ammesse operazione aritmetiche.
•short: rappresenta -32768 a +32767 (inclusi). Memoria= 16 bit; Default=0;
Occupa 1/2 di int, si usa per array grandi per occupare poco, non sono
ammesse operazione aritmetiche.
•int: rappresenta -2^16 a +2^16 -1(inclusi). Memoria= 32 bit; Default=0;

Sono ammesse operazione aritmetiche.
•long: rappresenta -2^32 a +2^32 -1 (inclusi). Memoria= 64 bit; Default=0;

Sono tipi di dato intero ma occupano il doppio. Sono ammesse operazione
aritmetiche.Usati spesso come chiavi nei database.
•float: rappresenta -2^16 a +2^16 -1 (inclusi) IEEE754. Memoria= 32 bit;
Default=0.0f;
Sono tipi di dato reale in virgola mobile a 32 bit. Sono ammesse operazione
aritmetiche. Non utilizzarlo per numeri precisi usare invece
java.Math.BigDecimals.
11
ATTENZIONE: quando uso per scrivere dati del tipo:
float val3 = 100.45; /*qui mi da errore*/
devo usare la f finale o fare il cast

float val3 = 100.45f;
o fare il cast a (float)

float val3 = (float) 100.45;
•double: rappresenta -2^32 a +2^32 -1 (inclusi) IEEE754. Memoria= 64 bit;

Default=0.0f;
Sono tipi di dato reale in virgola mobile a 64 bit. Sono ammesse operazione
aritmetiche. Non utilizzarlo per numeri precisi java.Math.BigDecimals.
•char: carattere unicode UTF, varia da ‘\u0000’ a ‘\uffff’ . Memoria= 16 bit;

Default= u0000 , cioe’ 0;
Il char si inizializza tra APICI. Es. char a = ‘a’;

L’operatore “+” su 2 char indica la somma dei valori esadecimali.
La Stringa si inizializza tra VIRGOLETTE. Es.
String a = “prov”
String b = “a” ;
L’operatore “+” su 2 String indica la concatenazione. A+B = “prova”
Operazione per aggiungere un PATH (classe dentro un’altra classe).
Cliccare Project e aggiungere il progetto che si vuole.
12
LEZIONE 21: La Classe String
Stringa = sequenza finita di caratteri racchiusa tra “ “ , si rappresentano con
l’oggetto string.
Se ho il carattere “ nella stringa lo devo far precedere da \:
"Lorem Ipsum.\"......."
Come si dichiara:
String s1 = "Lorem Ipsum.\"......."
Java non ha il primitivo String, questo si trova nel pacchetto java.lang.
Concatenazione:
1) Operatore +:
String s1 = "ciao";
String s2 = "mare";
String test = s1+s2;
2) Concat:
String s1 = "ciao";
String s2 = "mare";
String test = s1.concat(s1);
Trasformazione:
1) Minuscolo:
String s1 = "ciao";
System.out.println(s1.toLowercase());
2) Maiuscolo:
String s1 = "ciao";
System.out.println(s1.toUppercase());
3) Rimozione spazi:
String s1 = " ciao ";
System.out.println(s1.trim());
13
Sostituzione:
String t = "Questo è il corso Java AVANZATO";
1) Replace: sostituisce tutte le sottostringhe target con quella

replacement: replace(target, replacement);
String t1 = t.replace("ava", "!");
System.out.println(t1);
/*Questo è il corso J! AVANZATO*/
2) ReplaceAll: sostituisce tutte le sottostringhe che

corrispondono all’espressione regolare REGEX con quella
replacement: replaceAll(target, replacement);
String t2 = t.replaceAll("[a-n]", "4");

/*Qu4sto è 44 4orso J4v4 AVANZATO*/
3) ReplaceFirst: sostituisce la prima sottostringa che corrisponde

all’espressione regolare REGEX con quella replacement:
replaceAll(target, replacement);
String t3 = t.replaceFirst("[a-n]", "P");

/*QuPsto è il corso Java AVANZATO*/
Estrazione:
String t = "Questo è il corso Java AVANZATO";
1) Substring (beginIndex): estrae la sottostringa che va dal

carattere beginIndex espresso come intero(posizione del
carattere dal quale si vuole estrarre, escluso), fino alla fine
della stringa;
String t4 = t.substring(6);
/* è il corso Java AVANZATO*/
14
2) Substring (beginIndex, endIndex): estrae la sottostringa che va
dal carattere beginIndex, fino al carattere endIndex;
String t5 = t.substring(6,9);
/* è*/
LUNGHEZZA:
System.out.println(t.length());
Restituisce la lunghezza in INT della stringa t.
Estrazione:
String t6 = "TEST";
String t7 = "TEST";
System.out.println(t6.equals(7));
System.out.println(t6.equalsIgnoreCase(t7));
/* Compara le stringe e ritorna TRUE o
FALSE,la versione IgnoreCase non tiene conto del
case del carattere*/
Manipolazione: SPLIT, divide una striga in un array di stringhe,

secondo l’espressione regolare indicata;
String t8 = "Luca Girotti";

String[] tArr = t8.split(" ");
for(int i=0; i < tArr.length; i++) {
System.out.println(tArr[i]);
Manipolazione: starts/endsWith,
String t8 = "Luca Girotti”;

System.out.println(t8.startsWith("Lu"));
System.out.println(t8.endsWith("ti"));
15
LEZIONE 22: GLI OPERATORI
PUNTO (.): serve per accedere a:
-Campi di una classe;
-Metodi di una classe;
-Oggetti;
OPERATORI Aritmetici ( +, -, *, /, % (modulo)).

Due modi di usarli:
Somma tra a e b
1) c = a+b; /*v contiene la somma a + b*/
2) a += b; /*a contiene la somma con b*/
OPERATORI LOGICI: AND, OR, NOT.

Restituiscono TRUE or FALSE.
AND  &&; Esempio A && B
OR  || ; Esempio A || B | simbolo pipe
NOT  ! Esempio !A
OPERATORI RELAZIONALI:
>, >=,
<, <=,
==,
!=
Restituiscono TRUE or FALSE.
16
CASTING: permette passaggio da un tipo di dato ad altro.
ESPLICITO : (int) myvar
Converte il tipo della variabile in int.
IMPLICITO: se l’insieme di dati del quale voglio effettuare il

passaggio al nuovo tipo è piu’ piccolo di quello del nuovo tipo , allora
posso fare il passaggio implicito (Esempio da int a long è implicito)
altrimenti devo usare il metodo esplicito (Esempio da long a int).
Esempio:
long l1 = a;
int f = l1; /* Da errore perché l1 è long e lo sto portando a int*/
Devo fare il cast esplicito.

long l1 = a;
int f = (int)l1;
17
LEZIONE 23: METODI E VARARGS
• Cosa sono i metodi e come usarli;
• Come cambia l’accesso ai metodi in base al modificatore;
METODI: blocchi di codice che possono essere riutilizzati per rappresentare il

comportamento di classi di oggetti.
Esempio 1:
Classe = Umano
Metodo = Cammina
Esempio 2: scrivere un blocco di codice che recupera da un DB una riga da

una tabella in base alla chiave primaria.
• Senza metodo: ogni volta dobbiamo riscrivere il codice che fa
l’operazione;
• Con metodo: ogni volta possiamo richiamare il metodo, cioè il
blocco di codice che fa quella operazione, passando magari dei
parametri.
18
DEFINIZIONE DI UN METODO IN JAVA:
[modificatore di accesso] [altri modif.] Tipo Ritornato NomeMetodo (parametri) [Trows

Eccezioni]
private static Void = Niente Nome del Lista dei Lista delle classi
metodo scelto parametri delegate alle
protected final Tipo primitivo separati da azioni in caso di
public static final Classe virgole: errori:
(In base al param1, ClasseEcc1,
default valore param2,… ClasseEcc2 ,…
ritornato) param n. ClasseEccn.
Struttura della Sintassi:

Definizione {
/*Codice del metodo*/
return variabile, classe;
}
Metodo Main:
public static void main(String[] args)
| modificatori | |nome| | Parametri|
Signature del Metodo = Nome + Parametri

Posso avere metodi con lo stesso nome ma non sono uguali perché hanno
parametri diversi. Con questo struttura possiamo operare l’OVERLOADING DEI
METODI, quindi come detto sopra piu’ metodi con lo stesso nome ma parametri
diversi.
Esempio calcolatrice: 2 metodi sottrazione ma hanno parametri diversi.
public double sottrazione(double a, double b) {
return a-b;
}
public int sottrazione(int a, int b) {
return a-b;
}
19
VARARGS: Variable Arguments
Dalla Java 1.5 è possibile definire metodi con numero formale di parametri
indefinito (variable arguments).
Si usa operatore “…” (tre punti). In questo modo è possibile passare al
metodo da 0 a N parametri di tipo String.
Il VARARGS è come se fosse un ARRAY di parametri che passo al metodo.
/*MAIN*/
public static void main(String[] args) {
CorsoJava c = new CorsoJava();

//c.esempioStringa();
String d = c.concatena("Luca"," Girotti"," Corso Java");
System.out.println(d);
/*metodo concatena: a questo metodo viene passata una sequenza

di stringhe, lui le concatena e poi nel main lo stampo*/
public String concatena(String... vars) {

String out ="";
for (int i= 0; i < vars.length; i++) {
out += vars[i];
}
return out;
}
Accesso ai metodi: modificatori di visibilita’ del metodo.

•Public: metodo visibile a tutte le classi;
•Private: metodo visibile solo alla classe che lo definisce;
•Protected: metodo visibile solo alle classi contenute nello
stesso package della classe che lo definisce e dalle classi
derivate da essa;
•Default: metodo visibile solo alle classi contenute nello
stesso package della classe che lo definisce;
20
Altri modificatori: final & static
21
LEZIONE 24: MODIFICATORI
Keyword riservata Java da scrivere prima della dichiarazione di Classi,
metodi, variabili.
*Variabili di Istanza= definite in una classe ma fuori dai metodi.
•Public:
Rende visibile Classi, metodi o variabili di instanza* a qualsiasi classe in qualsiasi
package;
•Protected: leggermente piu’ restrittivo di Public.

Rende visibile Classi, metodi o variabili di instanza* a qualsiasi classe definita nello
stesso package o a tutte le sottoclassi o derivate in qualsiasi package;
•Default (o senza modificatore): piu’ restrittivo di Protected.

Rende visibile Classi, metodi o variabili di instanza* a qualsiasi classe definita nello
stesso package;
•Private: piu’ restrittivo di tutti.

Rende visibili Metodi o variabili di instanza* solo all’interno classe che li definisce;
Visibile dall’interno di
Modificatore Classe Package Derivate Ovunque
Public Si Si Si Si
Protected Si Si Si No
Default Si Si No No
Private SI No No No
22
Esempio
La classe Persona è public, quindi visibile a tutte le classi in qualsiasi package;
Le variabili e stringhe sono tutte Private quindi visibili solo nella classe Persona;
Il metodo Cammina è public, quindi visibile a tutte le classi in qualsiasi package;
Il metodo Mangia è protected, quindi visibile a tutte le classi nello stesso package o derivate;
Il metodo Dormi è default, quindi visibile a tutte le classi nello stesso package ma non alle
derivate;
Il metodo Bevi è private, quindi visibile solo alla classe in cui è definito.
Essendo CAMMINA e MANGIA con accesso Public o Protected allora è possibile fare OVERRIDE dentro
altra classa Persona2.
23
•Final: utilizzabile su classi, metodi e variabili, string invece è immutabile.
Classe final non puo’ essere estesa.
Metodo final non puo’ essere sovrascritto (no override).
Variabile final è una costante, non puo’ essere modificata e si scrivono per
convenzione in maiuscolo.
•Static: utilizzabile solo su metodi e variabili, string invece è immutabile.

Appartengono alla classe e non all’oggetto (istanza), vengono caricati in memoria
insieme alla classe.
Esempio: il MAIN è STATIC ed è la prima cosa che viene eseguita anche se non esiste
una istanza della classe.
24
LEZIONE 25: SINTASSI
Classi ed Interfacce
 I file che contengono Classi ed Interfacce devono iniziare con la
dichiarazione del package.
 Prima del Nome dell’elemento specificare Visibilita’ & Tipo.
 Il contenuto di classe o interfacce va tra graffe { }.
 Dopo il nome si puo’ inserire Implements/Extends di altri elementi.
package it.corso.java;
public Class Nomeclasse Extends Classe A{
/*Contenuto*/
}
public Interface Nomeinterfaccia Implements InterfacciaB {
/*Contenuto*/
}
 Una classe puo’ contenere Variabili o Metodi con sua implementazione.

Se la classe è astratta basta definire il metodo senza implementazione.
public Class Nomeclasse {
private String varA;
public String getVarA(){

return this.varA;
}
 Una Interfaccia puo’ contenere Variabili e solo definizione dei Metodi.
public Interface Nomeinterfaccia Extends InterfacciaB {

private String varA;
public String getVarA(); /*Solo definizione*/

}
25
Metodi e Variabili
 Prima del nome Metodi e Variabili sempre la visibilita’, se si omette è
Default ma si sconsiglia, e il Tipo.
 Dopo il nome specifica argomenti in input tra ( ), se non ci sono
argomenti le parentesi sono vuote.
 Le istruzioni del metodo sono tra graffe { }.
 Se la variabile è fuori dai metodi allora bisogna specificarne la visibilita’,
se all’interno dei metodi allora non è necessario.
package it.corso.java;
public Class Nomeclasse {

public int calcolaSomma(int a, int b) {
int c
return a+b+c;
}
public void Inseriscivalore(int val) {
return;
}
private int id;
}
LEZIONE 26: I PACKAGES

Un package è uno strumento per raggruppare ed organizzare nel nostro SW gli
elementi. Obiettivo è semplificare lettura del codice evitando concorrenza tra classi.
Java ha dei suoi package, esempi sono:

java.lang: classi di linguaggio (String, Object….);
java.util: classi di utilita’ (Date, List, Array…..);
java.io: classi per la gestione di input e output (File, Input stream…)
26
Quando sviluppiamo un software è bene che anche i nostri elementi siano raggruppati
in package.
Naming convention
 Solo minuscole;
 Iniziano con domini o con lettere che identificano la nazione;
 Avere package strutturati permette di gestire al meglio le classi;
Esempio: 3 package sotto ampli con ognuno una classe.

package it.test.ampli.outputstage;
package it.test.ampli.protections;
package it.test.ampli.powersupply;
IMPORT:Serve per usare librerie esterne al package per portarle nella nostra classe o
per usare Classi esterne al nostro package.
 Indicare al progetto dove si trova il JAR della libreria esterna (se non fornita
da JAVA);
 Dichiarare l’IMPORT per utilizzare gli elementi nel package esterno, seza
prefisso del package;
Gli import vanno dichiarati subito dopo i packages.
27
LEZIONE 27: Naming e Code Conventions
Insieme di indicazioni di sintassi Non obbligatorie ma CONSIGLIATE per rendere il
sorgente di un software leggibile a chi non lo ha scritto, soprattutto se si lavora in team.
 Regole sul package, vedi lezione 26;
 Nome classe: espresso con sostantivo e la prima lettera con la maiuscola,
se sono piu’ sostantivi ognuno con prima lettera maiuscola.
Sono ammesse tutte maiuscole per acronimi.
 Variabili: il nome deve indicare cosa rappresenta, usare nomi brevi e chiari,
sempre con lettera minuscola, se composto da piu’ nomi a partire dal
secondo nome usare la maiuscola per la prima lettera.
Sono ammesse variabili tutte in maiuscolo solo se sono costanti (STATIC);

public static final int LUNGHEZZA.
Lettere utilizzate comunemente:
i,j,k,m,n  Numeri interi e indici;
c,d,e  Caratteri
 Metodi: iniziare con verbi, prima lettera minuscola, se composto da piu’
nomi a partire dal secondo nome usare la maiuscola per la prima lettera.
LEZIONE 28: Commentare il codice sorgente

Testi inseriti nel sorgente per descrivere come funziona, non sono eseguibili;
3 modi: IL 2 E’ IL PIU’ CONSIGLIATO
1) // commento solo su riga;
2) /*commento*/ commento multilinea ( per usarle scrivi /* Invio).
3) /** commento*/ commento JavaDoc: sara visibile nella documentazione
generata tramite Javadoc (applicativo del JDK).
Nei commenti JavaDoc si possono usare pezzi di HTML e tag @.
28
LEZIONE 29: Creare Documentazione con JavaDoc.
Genera documentazione HTML
29
LEZIONE 30: Comandi Condizionali
IF-ELSE
If (condizione 1){
/*istruzioni*/
} else if (condizione 2){
/*istruzioni*/
} else{
/*istruzioni*/
}
–––––––––––––––––––––––––––––––––––––––––––––
SWITCH-CASE
Switch(parametro){
Case_valore_1:
/*istruzioni*/
Case_valore_2:
/*istruzioni*/
default:
/*istruzioni*/
}
Esegue le istruzioni al partire dal case che viene matchato.
Sotto DEFAULT ci sono istruzioni che voglio vengano cmq
eseguite.
Il parametro puo’ essere byte, short, char, int, Enum, String;
Lo SWITCH si interrompe con un BREAK (interrompe anche un
ciclo ma si usa anche in uno switch).
30
Esempio
Switch(numero) {
Case 10:
System.out.println(“Entro in case 10”);
Case 20:
Default:
System.out.println(“Esegue comunque le istruzioni
default”);
}
Esempio con break

Switch(numero) {
Case 20:
Case 60:
break;
/* Se entro in 20 o in 60 cmq all’arrivo al break esco
dallo switch, se invece non entro neanche in 60 allora
passo a default*/
Default:
default”);
31
Esempio
Switch(c) {
Case 10:
Case 20:
Case Default:
default”);
}
32
LEZIONE 31 RETURN
Utilizzato all’interno di un metodo per ritornare un valore al termine

dell’invocazione del metodo.
Puo’ essere usato anche piu’ volte all’interno di un metodo, ad esempio
in uno switch
Public String recuperaTesto(int codice){ Public String recuperaTesto(int codice){

Switch(codice) { Switch(codice) {
Case 1: Case 1:
testo = “Codice 1”; return “Codice 1”;
break; Case 2:
Case 2: return “Codice 2”;
testo = “Codice 2”; default:
break; return “prova”;
default: /*Ho risparmiato righe di codice*/
testo = “prova”;
LEZIONE 32: Cicli WHILE, DO-WHILE, FOR.
• while: esegue un blocco di codice fino a che la condizione è vera

(boolean). Nel while l’esecuzione non viene mai effettuata se la condizione è
falsa all’inizio. Attenzione, se la condizione è sempre vera si va in loop
infinito!
while (condizione) {
/*Esegui Istruzioni fino a che la condizione è vera*/
}
33
• do-while: simile a while ma la condizione viene verificata alla fine del
blocco. Nel do-while l’esecuzione viene effettuata almeno una volta anche
se la condizione è falsa. Attenzione, se la condizione è sempre vera si va in
loop infinito!
do {
/* Esegui Istruzioni fino a che la condizione è vera */
} while (condizione)
• for: esegue un blocco di codice fino a che viene verificata la condizione.
for (Inizializzazione; Condizione; Incremento/Decremento) {

/*Esegui Istruzioni fino a che non si verifica la condizione*/
}
-Inizializzazione: definizione e inizializzazione della variabile

contatore (di solito i, j, k);
-Condizione: condizione che deve essere vera per eseguire il ciclo;
- Incremento/Decremento: operazione che viene fatta sulla
variabile contatore alla fine di ogni ciclo;
Esempio:
Numeri[] arr = {0,1,2,3};

for (int i=0 ; i < arr.length; i++) {
System.out.println(arr[i]);
}
Esiste altra sintassi che è il for each e si usa spesso nel caso di array.
• for each:
In questo caso la condizione del for è sostituita da una variabile che
rappresenta l’indice dell’array. Pertanto la condizione è, fino a che array ha
elementi, allora esegui l’istruzione.
34
Numeri[] arr = {0,1,2,3};
for (int elemento : arr) {
System.out.println(elemento);
}
35
LEZIONE 33: Break, Continue.
36
LEZIONE 34: Programmazione orientata agli oggetti.
OOP (Object Oriented Programming) è un paradigma di programmazione nato nella

seconda meta’ degli anni 50 all’MTI.
Questo paradigma permette di:
•Rappresentare un problema o entita’ reali attraverso oggetti software;
•Stabilire relazioni che intercorrono tra le entita’ (classi);
Qui display , CPU, memoria, Clienti….etc…..etc sono Classi.
Programmazione Funzionale: basato su variabili e funzioni;
vs
Programmazione ad Oggetti: basato su classi che contengono attributi(variabili) e
metodi (funzioni che ne definiscono il comportamento).
Vantaggi OOP:
•Permette di modellare problemi reali: con le classi e gli oggetti creati da queste;
•Migliore gestione della manutenzione: essendo organizzata in package posso

identificare facilmente dove intervenire;
•Sviluppo modulare: riutilizzo di parti di codice in altri software;
Linguaggi OOP: C++, Java, Delphi, C#, Smalltalk.
37
Elementi dell’OOP in JAVA:
 Classe: rappresenta un tipo di dato;
 Attributo: proprieta’ di una classe;
 Metodo: rappresenta le azioni che la classe puo’ eseguire;
 Oggetto (istanza): rappresentazione fisica della classe. Ogni
oggetto create possiede tutti gli attributi e i metodi della classe;
Principio di Incapsulamento
Gli attributi non sono accessibili (private – visibili solo nella Classe), lo sono
invece i metodi (public-visibili a tutte le Classi del package) che fanno azioni su
di essi con ad esempio get e set.
38
Principio di Incapsulamento -> Information Hiding
Attributi private;
Non faccio vedere quali manipolazioni ne faccio e allo stesso modo non
sono accessibili da altre classi.
Metodi public;
Sono accessibili da altre classi perché così posso usare queste funzioni.
39
Principio di Ereditarieta’  Tecnica che consente di estendere le
caratteristiche di una classe ad una altra classe, quindi modellare gerarchie di
classi.
Classe che eredita:
 Mantiene metodi e attributi della classe dalla quale deriva;
 Puo’ avere metodi e attributi propri;
 Puo’ ridefinire il codice di alcuni metodi ereditati mediante un
meccanismo chiamato overriding (vedi Polimorfismo).
In questo esempio la Classe PRODOTTO è la classe chiamata BASE e le Classi chiamate SMARTPHONE
e LIBRO sono chiamate classi derivate. Smartphone e Libro hanno gli stessi attributi di Prodotto ma
ne hanno altri propri, ed utilizzano gli stessi metodi di Prodotto ma ne hanno altri definiti.
40
Principio di Polimorfismo  Strettamente legata all’ereditarieta’ e si
effettua con l’overriding.
Una Classe Base ha dei metodi che vengono ereditati (ereditarieta’) dalle
Classi Derivate, ma le Classi Derivate li possono modificare sovrascrivendoli
(overriding).
In questo esempio la Classe PRODOTTO è la classe chiamata BASE e le Classi chiamate SMARTPHONE e
LIBRO sono chiamate classi derivate. La Classe Prodotto ha un metodo che recupera l’elenco dei negozi.
Smartphone e Libro hanno gli stessi metodi, ma ognuno con una sovrascrizione recupera solo gli stores
di competenza.
41
LEZIONE 35: Cosa succede a livello HW quando instanziamo una classe?
 Istanzia(dichiara) una Classe  viene riservata ad essa una certa area di memoria
che conterra’ ATTRIBUTI e VALORE ATTRIBUTI;
 Inizializza una Classe –> Riempio quella area di memoria.
 In JAVA si puo’ inizializzare automaticamente un oggetto attraverso uno o piu’

metodi speciali detti COSTRUTTORI.
 Quando l’oggetto non serve piu’ si usano metodi detti DISTRUTTORI (Garbage
Collector).
42
LEZIONE 36: Garbage Collector (GC);
Modello Memoria
JVM
Non Heap
HEAP memory
(dati dinamici) memory (Byte
Code)
Young gen. Old gen.
Permanent Gen.
Eden Survivor
Il GARBAGE COLLECTOR (GC) è organizzato con:

Minor GC  Gestisce l’EDEN space inserendovi i nuovi oggetti ed effettuando un
scansione frequente dell’area.
Ad ogni CICLO il MINOR GC fa migrare tutte gli oggetti attivi nell’area SURVIVOR e
distruggendo i riferimenti a quelli non attivi liberando memoria.
Ad ogni CICLO il GC fa migrare tutte gli oggetti attivi da SURVIVOR a  OLD Generation
dove rimangono fino a che utilizzati.
Quando OLD gen. è piena viene eseguito il MAJOR GC o FULL GC che svuota la memoria
da oggetti non attivi.
Se HEAP SPACE va in overflow si ottiene l’errore run time:
java.lang.OutOfMemoryError: Java heap space
IL GARBAGE E’ IMPORTANTE E PER NON SATURARLO SI USANO PATTERN COME IL

SINGLETON.  Vedere quando si faranno i pattern.
43
LEZIONE 37: CLASSE E OGGETTO.
Classe: tipo di dato complesso, rappresenta il prototipo di un oggetto reale.
Contiene attributi (Valori) e metodi (Azioni).
Oggetto: tipo di dato della Classe, rappresenta una istanza della Classe e
possiede attributi e metodi definiti nella Classe.
ATTENZIONE: se su cliente2 provo a invocare un metodo avro’ errore in quanto è stato dichiarato
(allocata memoria, ma non ci sono valori in memoria) come oggetto ma non inizializzato e quindi
on potro’ neanche scriverci.
LEZIONE 38: Attributi e Metodi di una classe.
Attributi: caratteristiche di una Classe;

Metodi: azioni effettuate dalla Classe;
Per rispettare il principio di incapsulamento gli attributi devono essere
PRIVATE, mentre i metodi PUBLIC (Information Hiding);
44
LEZIONE 39: COSTRUTTORE.
 COSA E’: Uno o piu’ Metodi all’interno di una Classe che permettono
di creare oggetti (istanze) delle Classe.
 COME VIENE NOMINATO: Stesso nome della Classe, ve ne

possono essere piu’ di uno perché ognuno si distinguera’ dal numero
e tipo dei parametri! Quando viene istanziato l’oggetto, in base ai
parametri che si passeranno al metodo, si otterra’ un determinato tipo
di oggetto.
 COME VIENE DICHIARATO:

 Il nome del costruttore deve coincidere con quello della classe;
 Il tipo del costruttore non deve essere specificato. ...
 Il modificatore static non può essere usato per un costruttore.
 Ogni Classe ha un costruttore DEFAULT: E’ quello che non prende

nessun parametro in ingresso - “NEW”
Prodotto p = new Prodotto();
Tipo Classe Keyword riservata ”new”

Nome Oggetto Costruttore della classe Prodotto.
Che equivale a fare:

public Prodotto() {
super();
}
45
Quando invece il Costruttore non è default: devo usare la l’identificatore this.
che associa ogni parametro passato al metodo costruttore agli attributi
dell’oggetto.
public class Prodotto { /*istanzia la Classe*/
private int id;

private String nome;
private String descrizione;
private double prezzo;
/*Dichiara attributi degli oggetti della classe*/
public Prodotto(int id, String nome, double prezzo) {

this.id = id;
this.nome = nome;
this.prezzo = prezzo;
/*Costruttore degli oggetti della classe al quale vengono
passati 3 parametri*/
}
CLASSE: PRODOTTO OGGETTO: p1
Attributi: id, nome , descrizione,

Attributi: id, nome , prezzo.
prezzo.
Metodi  Metodi 
Costruttore(id,nome,prezzo) Costruttore(id,nome,prezzo)
46
Approfondimento: identificatore this.
L’identificatore this è un puntatore speciale alla classe che costituisce
l’attuale contesto di programmazione. Grazie a this è possibile accedere a
qualsiasi metodo o attributo della classe stessa mediante un’espressione del
tipo:
this.metodo();
L’uso di this è indispensabile quando ci si trova a dover distinguere tra un

attributo e una variabile con lo stesso nome, come avviene spesso nei
metodi setter e nei costruttori:
public setAtt1(int att1) {
this.att1 = att1; // assegna il valore della var locale att1

all’attributo omonimo
}
L’identificatore this può essere usato anche per richiamare un costruttore. In
questo caso, la parola this deve essere seguita dai parametri richiesti dal
costruttore in questione racchiusi tra parentesi, e deve per forza comparire
come prima istruzione di un altro costruttore:
public class MyClass {
private int att1;
private int att2;
public MyClass() {
this(0,0); // chiama il secondo costruttore con i parametri di default
public MyClass(int a1 , int a2) {
att1 = a1;
att2 = a2;
}
47
LEZIONE 40: ACCESSO AGLI ATTRIBUTI DI UNA CLASSE.
PER IL PRINCIPIO DI INCAPSULAMENTO - Ricordiamo:

Attributi  Private (non accessibili da altre Classi)
Metodi  Public (accessibilli da altre Classi)
In questo modo l’accesso agli attributi avviene con i metodi:
public getNomeAttributo() { public void setNomeAttributo(Tipo Parametro){
return Attributo; this.Attributo = Attributo;
} }
LEZIONE 41: “instanceof”

Permette di verificare di quale tipo è l’oggetto.
Sintassi: object instanceof TypeClass

Restituisce “True” se l’oggetto è del tipo classe dichiarata, altrimenti “False”
se non vi appartiene o se è null.
if(p1 instanceof Prodotto) {
System.out.println("p1 è oggetto di tipo Prodotto");
} else {
System.out.println("p1 non è di tipo Prodotto oppure è null");
Questa keyword è utilizzata spesso per prevenire eccezioni di tipo

ClassCastException, perché ci consente di verificare se un oggetto è di un
certo tipo prima di effettuare il cast. E' molto utilizzato, come vedremo,
nell'override del metodo equals.
}
48
LEZIONE 42: Classe Object
La classe Object è la superclasse ereditata da tutte le classi Java, direttamente o
indirettamente.
Infatti:
 Quando creiamo una classe A che non eredita altre classi, implicitamente la classe A
erediterà la classe Object.
 quando creiamo una classe B che eredita la classe A (che non eredita nessuna classe),
A erediterà Object ed indirettamente anche B erediterà Object.
Grazie all'ereditarietà, i metodi public e protected della classe Object possono

essere invocati e sovrascritti in tutte le classi!
La classe Object definisce una serie di metodi che consentono ad un oggetto, tra le
altre cose, di:
 essere convertito in stringa

 effettuare il confronto con un altro oggetto
 ritornare la classe dell'oggetto
I metodi della classe Object che possiamo invocare e sovrascrivere sono:

 clone
 equals
 hashCode
 finalize
 toString
I metodi della classe Object che possiamo invocare ma non possiamo

sovrascrivere sono:
 getClass
 notify
 notifyAll
 wait
Nell'immagine seguente vi mostro l'interfaccia di Eclipse che consente di scegliere i

metodi della classe Object che possiamo riscrivere. In qualsiasi classe possiamo
sovrascrivere questi metodi.
49
50
LEZIONE 43: Il metodo getClass()
Il metodo getClass() ritorna un oggetto di tipo java.lang.Class, che consente di acquisire
informazioni di runtime sulle classi e sulle interfacce disponibili nella JVM.
Un oggetto di tipo Class consente di accedere ad una serie di informazioni sulla classe, ad
esempio:
 il nome della classe

 i metodi della classe
 il nome del package
 i nomi delle interfacce che implementa la classe
Esempio
1. public class Main {
2. public static void main(String[] args) {
3. Main m = new Main();
4. m.stampaInfo();
5. }
6.
7. public void stampaInfo() {
8. System.out.println(getClass().getName()); <--- ritorna il nome della classe comp
leto di package
9. System.out.println(getClass().getSimpleName()); <--- ritorna solo il nome della classe
, senza package
10.
11. System.out.println("");
12. System.out.println("metodi...");
13. for(Method m : getClass().getMethods()) {
14. System.out.println(m.getName()); <--- stampa tutti i metodi della class
e e delle sue superclassi (main, converti, stampaInfo, equals, ...)
15. }
16. }
17. }
51
LEZIONE 44: La classe Object.
I metodi toString() e equals(Object o)
Il metodo toString()
L'implementazione del metodo toString() nella classe Object restituisce una rappresentazione
testuale di un oggetto.
La stringa ritornata dal metodo ha la seguente forma: "ClassName@HashCode" ed è così

ottenuta: getClass().getName() + "@" + Integer.toHexString(hashCode())
Ogni volta che un oggetto deve essere convertito in stringa, viene invocato il metodo
toString()
Esempio
1. public class Order {
2. private Long id;
3. ...
4. public Order() {
5. ...
6. }
7. public void createInvoice(String filename) {
8. ...
9. }
10. }
11.
14. System.out.println(new Order().toString()); <----- L'output sarà it.corso.java.oop.es
empiosuper.Order@15db9742
15. }
16. }
Se non vogliamo che il toString() invocato sulle nostre classi abbia un

comportamento differente, dobbiamo sovrascriverlo.
Esempio
1. public class Order {
2. private Long id;
3. private String status;
4. private Calendar orderDate;
5.
6. public Order() {
7.
8. }
9. public Order(Calendar orderDate, String status) {
10. this.orderDate = orderDate;
11. this.status = status;
12. }
13. }
14.
15. public class SalesOrder extends Order {
16. public SalesOrder(Calendar orderDate, String status) {
17. super(orderDate, status);
18. }
19.
20. public void createSalesInvoice() {
21. String filename = "";
22.
23. super.createInvoice(filename);
24. }
25. @Override
26. public String toString() {
52
27. /* EFFETTUIAMO L'OVERRIDE DEL METODO STAMPANDO IL NUMERO DELL'ORDINE E LA DATA */
28. return "Ordine n. " + getId() +
29. " del " + getOrderDate().get(Calendar.DATE) +
30. "/" + getOrderDate().get(Calendar.MONTH) +
31. "/" + getOrderDate().get(Calendar.YEAR);
32. }
33. }
34.
37. SalesOrder order = new SalesOrder(Calendar.getInstance(), "CONFIRMED");
38. order.setId(123L);
39.
40. System.out.println(order); <-------- L'output sarà Ordine n. 123 del 4/3/2018
41. }
42. }
Il metodo equals(Object obj)
Il metodo public boolean equals(Object obj) consente di confrontare due oggetti tra
loro, in particolare e ritorna true se sono uguali.
L'implementazione del metodo nella classe Object utilizza
l'operatore == per verificare se i due oggetti sono uguali.
L'implementazione default del metodo ritorna true se e solo se l'oggetto A e l'oggetto
B sono lo stesso oggetto.
Esempio
3. System.out.println(new Order().toString());
4.
5. SalesOrder order = new SalesOrder(Calendar.getInstance(), "CONFIRMED");
6. order.setId(123L);
7.
8. System.out.println(order);
9.
10. SalesOrder order2 = new SalesOrder(Calendar.getInstance(), "DELIVERED");
11.
12. System.out.println(order.equals(order2)); <--- order ed order2 sono oggetti distinti quin
di equals ritorna FALSE
13.
14. SalesOrder order3 = order;
15. System.out.println(order.equals(order3)); <--- order ed order3 sono lo stesso oggetto qui
ndi equals ritorna TRUE
16. }
17. }
Se vogliamo che il metodo equals abbia un comportamento diverso, dobbiamo

effettuare l'override.
53
E' il caso della classe String.
Esempio
3.
4. String a = "Paolo";
5. String b = "Alessandra";
6. String c = "Paolo";
7.
8. a.equals(b); <--------- Paolo e Alessandra sono due stringhe diverse quindi il risult
ato è FALSE
9. a.equals(c); <--------- Paolo e Paolo sono due stringhe uguali quindi il risultato è
TRUE nonostante b e c siano due istanze diverse della classe String
10. }
11. }
Esempio 2
1. public class SalesOrder extends Order {
2. public SalesOrder(Calendar orderDate, String status) {
3. super(orderDate, status);
4. }
5.
6. @Override
7. public boolean equals(Object obj) {
8. if(obj != null && obj instanceof SalesOrder) {
9. if(((SalesOrder)obj).getId() == getId()) {
10. return true;
11. }
12. }
13.
14. return false;
15. }
16. }
Nella nostra classe SalesOrder, due ordini sono uguali se hanno lo stesso id (vedi
codice sopra...).
54
LEZIONE 45: Ereditarieta’ (pag.41 per definizione)
Come si effettua in JAVA extends
Sintassi:
public class ClasseB extends ClasseA {
/*Definizione*/
}
La classeB eredita attributi e metodi della classeA di tipo public o
protected.
Comando rapido Extends:
Attenzione quando si hanno errori del tipo
è perché non esiste un costruttore default nella Classe BASE, mentre esiste un
costruttore ma al quale magari vengono passati piu’ parametri
55
LEZIONE 46: Incapsulamento (pag.49 per definizione)
Attributi e metodi public sono disponibili a tutte le Classi del package;
Attributi e metodi private sono disponibili solo alla Classe che li contiene.
Attenzione quando applico incapsulmento è meglio che instanzio i parametri dei

metodi con un metodo SET della Classe invece di usara l’identificatore “this”, questo
perché se nel metodo SET decido di fare manipolazioni del parametro prima di passarlo
alla variabile di instanza
56
LEZIONE 47: Polimorfismo (pag.41 per definizione)
Override di uno o piu’ metodi della classe Base operato dalla Classe Derivata,
chiaramente impone che venga applicato il principio di Ereditarieta’ perché la Classe
Derivata erediti i metodi della Classe Base.
Come si effettua in JAVA @Override
57
Esempio provato: La Classe televisore è una derivata della Classe Prodotto.
In Prodotto definiti dei metodi per il set e get del prezzo.
In Televisore faccio override dei metodi set e get prezzo per fare in modo che quando
richiamo tv1.getPrezzo il prezzo di tv1 che era 149.99 viene modificato dall’override su
set prezzo a 149,99+15 (margine) e poi sul get prezzo metto un fisso tramite la variabile
tmp = 200.
58
LEZIONE 48: Applicazione pratica Ereditarieta’,
Incapsulamento e Polimorfismo.
Progetto di un gestionale
1) Definisco una Classe Cliente con attributi : id, nome, cognome e codice
fiscale con modificatore di accesso private e generandone in metodi di
accesso set & get secondo il principio di incapsulamento.
LEZIONE 49: Utility Eclipse per implementare la

programmazione ad oggetti.
•Ereditarieta’  Estendere una Classe
Quando si crea una Classe, assegnare una SuperClasse diversa da java.lang.object.
Eclipse crea in automatico la nuova Classe Automobile che eredita attributi e

metodi della Superclasse Prodotto.
59
•Ereditarieta’  Operatore super()
Se una classe B estende una classe A, attraverso la keyword super, nella classe
B possiamo accedere agli elementi della classe A.
La keyword super, può essere utilizzata sia per le variabili sia per invocare metodi,
sia per invocare costruttori.
Come si utilizza la keyword super:

super.nomeMetodo() per invocare un metodo della superclasse
super.nomeVariabile per accedere ad una variabile della superclasse
super() per invocare il costruttore default della superclasse.
super(argomenti) per invocare il costruttore specifico della superclasse.
L'invocazione del costruttore della superclasse deve essere la prima
istruzione da eseguire.
•Incapsulamento  Modellare accesso ad una classe con soli

metodi, senza poter accedere direttamente agli attributi.
60
•Polimorfismo Permettere alla Classe Derivata di
sovrascrivere (override) i metodi della Classe Base
61
62
LEZIONE 51-54: Relazioni tra Classi
•Associazione
Un A-ContoCorrente appartiene ad un B-Utente, e ad un B-Utente appartiene un A-

ContoCorrente.
Da una istanza di A è possibile accedere ad una istanza di B e viceversa.
L’associazione puo’ essere anche uni-direzionale, in questo l’accesso è permesso solo in
un verso.
Si ha Associazione quando esiste una relazione , ma questa non crea dipendenza come
l’aggregazione, infatti un Utente per esistere non ha necessita’ del Contocorrente.
63
•Aggregazione
Piu’ Utenti appartengono ad una Azienda

Relazione piu’ forte dell’Associazione, si ha Aggregazione quando esiste
una relazione di proprieta’ della Classe B rispetto alla Classe A.
Esempio: Dipendenti (B)  Azienda (A) , Figlio(B) Padre(A)
Esempio di codice:
64
•Composizione
Relazione nella quale c’è un vincolo maggiore rispetto all’aggregazione,
infatti la Classe B esiste solo se esiste una istanza della Classe A.
Nel caso precedente di aggregazione infatti un Utente puo’ esistere anche se

non fa parte di una Azienda, mentre nel caso sopra non si puo’ avere una
riga di ordine se non esiste l’ordine.
65
Richiamo alle mappe fatte per UML in data 20/11
66
LEZIONE 55: Eccezioni
Situazioni anomale e impreviste Vanno evitate.
Esempi:
Divisione per zero, variabile dichiarata ma non inizializzata, etc….etc….
Tipi di ECCEZIONI:
•Checked (Controllate) Dovute ad eventi esterni al nostro SW.
Esempio: accesso ad un file esterno che non esiste.
•Un-Checked (Non-Controllate) Dovute a bug nel nostro SW.

Esempio: se non metto l’IF mi da eccezione perché la stringa è null.
public class Main {
Main m = new Main();

m.stampaTesto(null);
Main m1 = new Main();

m1.stampaTesto("Testo di prova");
}
private void stampaTesto(String testo) {
if(testo != null) {
String tmp = testo.concat("...");
System.out.println(tmp);
} else {
System.out.println("Testo è null");
}
67
LEZIONE 56: Meccanismi di controllo delle Eccezioni
In Java le eccezioni sono gestite elegantemente con oggetti (istanze) di classi

particolari, quando avviene una eccezione in un metodo questo lancia una
eccezione (throw ) al metodo chiamante.
Esempio: quando passo il testo “null” al metodo stampaTesto(), questo

genera prima una eccezione alla riga 24 dove è dichiarato il metodo, poi
una eccezione del main che lo invoca alla riga 16.
68
GESTIONE DELLE ECCEZIONI:
•Catturo e gestisco;
•Proseguo il programma ignorando l’eccezione (probabilmente il
programma termina);
GERARCHIA DELLE ECCEZIONI
THROWABLE
Superclasse
Java.lang.Error = Errori non Java.lang.Exception = Errori

recuperabili relativi alla JVM, potenzialmente recuperabili
ad esempio crash di relativi ad errori di codice, ad
memoria…etc…etc… esempio indice di array oltre
i limiti, file da leggere non
trovato….etc…etc…
69
ECCEZIONI PERSONALIZZATE
Creo una Classe per la gestione delle eccezioni che ha come Superclasse
Throwable. Quindi che possa ereditare tutti i metodi di gestione delle
eccezioni.--> Poi aggiungo un seriale(1) e genero Override dei metodi(2)…
70
….e modifico i metodi per avere errori personalizzati(3)…
……nel main (4)
71
LEZIONE 57: TRY-CATCH-FINALLY
Flusso
1) Eseguo le istruzioni in TRY, se si generano Eccezioni eseguo le
istruzioni nel Catch e poi quelle nel Finally.
2) Se non si generano Eccezioni nel TRY allora passo direttamente
alle istruzioni del Finally, senza eseguire quelle nel Catch.
3) Comunque sia le istruzioni nel Finally vengono sempre eseguite
alla fine.
Applicazioni
Per leggere su file con FileReader o scrivere su file con FileWriter, oppure in
una connessione ad un DB , le invocazioni dei metodi vanno inserite nel
Finally perché se si generano Eccezioni i file o la connessione rimangono
aperti e generano crash.
72
LEZIONE 58: THROW
Usato per lanciare una eccezione durante l’esecuzione del software.
Vedi esempio alla lezione 56 nella parte eccezioni personalizzate (pag.70)

dove alla linea 49 del codice viene dichiarato il throws con la Classe
CorsoJavaException che è una classe estesa della superclasse Throwable.
THROWABLE
Superclasse
Java.lang.Error Java.lang.Exception
In realta’ per estendere le eccezioni sarabbe piu’ corretto estender Exception

e non Throwable come superclasse.
LEZIONE 59: THROWS

A differenza di THROW, che è usato per lanciare una eccezione, THROWS si
usa per inoltrare una eccezione che un metodo ha ricevuto.
73
SEZIONE 10 – Array, liste, mappe, collezioni, classi wrapper,
Autoboxing & Unboxing
LEZIONE 60: intro Liste & Mappe

Liste: elenco di elementi dello stesso tipo che hanno predecessore e
successore (ad esclusione di testa e coda) nel caso lineari, o dove ogni
elemento puo’ essere a sua volta una lista (non lineari) [Definizione da
Algoritmi e PA].
 Statiche: lunghezza fissa in run-time (esempi vettore-array).
 Dinamiche: lunghezza variabile in run-time.
Java 2 tools gestione liste:

 Array  liste statiche;
 Collection  liste dinamiche;
Mappe: Collezione di oggetti (Dizionario) che vengono identificati da una
chiave per velocizzarne la ricerca . In Algoritmi sono state studiate come
Tabelle ad accesso diretto e Tabelle Hash.
Mappe in JAVA -> per gestirle ci sono delle classi MAP.
 Interfacce: definiscono metodi per la manipolazione della
collezione di oggetti;
 Classi: implementano le interfacce;
Esempi  java.util: HashMap – Hashtable – Properties – TreeMap.
74
LEZIONE 61: Array
Contenitore di elementi, che sono tipi primitivi (int,String…) o implementati
dall’utente.
Caratteristiche:
• Lunghezza “n” fissa e dichiarata in inizializzazione;
•Elementi tutti dello stesso tipo;
•indice primo elemento = 0, ultimo elemento “n-1”;
Esempio: agenda telefonica.
Pagina 1  tutti i nomi con A;
Pagina 2  tutti i nomi con B;
……
Sintassi:
-Dichiarazione  Type[] nomeVariabile = new Type[n]
Type = tipo dato | nomeVariabile = variabile che identifica l’array | new
= keyword er costruire l’oggetto Array | Type(n) = numero di elementi
“n”.
-Restituzione “n”  nomeVariabile.length = attributo del tipo Array
che restituisce la lunghezza dell’array “n” di tipo int.
-Accesso elemento  nomeVariabile[] ad esempio se devo stampare o
fare altre operazioni.
-Inizializza  nomeVariabile[0]=10; inizializza a 10 il primo elemento
dell’array.
Dichiara, crea e inizializza  omettendo n tra le quadre e inizializzando con un
numero di elementi, l’array è definito in base al numero di elementi inizializzati (nel caso sotto
3).
Type[] nomeVariabile = new Type[] {

New Type (..);
New Type (..);
New Type(..); }
75
-Riempimento, lettura, manipolazione in un Array con ciclo For:
package liste;
public class Main {
Main m = new Main(); /*Creo oggetto del main per eseguire il metodo creaArray()*/
m.creaArray(); /*Invoco il metodo creaArray() per eseguirlo da main*/
public void creaArray() {
int[] test; /*Definisco array di int*/

test = new int[10]; /*Inizializzo test a 10 elementi*/
int[] numeri = new int[5]; /*Dichiaro un array di 5 elementi di tipo int*/
// numeri[0]= 10; /*Alternativa meno usata Accesso in scrittura manuale*/

// numeri[1]= 11;
// numeri[2]= 12;
// numeri[3]= 13;
// numeri[4]= 14;
/*Alternativa con ciclo "FOR" per inizializzazione*/
for (int i = 0; i < numeri.length; i++) {

numeri[i]=10+i;
System.out.println(numeri[i]);
}
/*Alternativa con ciclo "FOR EACH" per stampa*/

for (int n : numeri) { /*Utilizzo di un for each*/
System.out.println(n);
}
/*Array di oggetti*/
Smartphone[] prodotti = new Smartphone[3];

/*Dichiaro un array di 3 elementi di tipo Smartphone*/
/*Dentro questo array ogni elemento dell'array contiene un oggetto Smartphone*/
/*Inizializzo primo elemento dell'array all'oggetto Smartphone*/

prodotti[0] = new Smartphone();
prodotti[0].setId(1);
prodotti[0].setMarca("Apple");
prodotti[0].setModello("iPhone13");
/*Inizializzo secondo elemento dell'array all'oggetto Smartphone*/

prodotti[1].setMarca("Samsung");
prodotti[1].setModello("Note");
/*Inizializzo terzo elemento dell'array all'oggetto Smartphone*/

prodotti[2].setMarca("Huawei");
prodotti[2].setModello("P8Lite");
76
/*Stampa array oggetti con for EACH*/
for (Smartphone sm : prodotti) {

System.out.println(sm.getId()+" "+sm.getMarca()+" "+sm.getModello());
public class Smartphone{ /*Definizione della classe Smartphone con attributi e metodi*/
private int id;

private String marca;
private String modello;
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}
/**
* @return the marca
*/
public String getMarca() {
return marca;
}
/**
* @param marca the marca to set
*/
public void setMarca(String marca) {
this.marca = marca;
}
/**
* @return the modello
*/
public String getModello() {
return modello;
}
/**
* @param modello the modello to set
*/
public void setModello(String modello) {
this.modello = modello;
}
77
Array di Array = Matrici
Sintassi:
-Dichiarazione 
Bidimensionale: Type[] [] nomeVariabile = new Type[n][m]
Le coppie di quadre indicano quante dimensioni, gli indici sono
rispettivamente n = n°colonne , m=n°righe.
Tridimensionale: Type[] [] [] nomeVariabile = new Type[n][m][k]

Le coppie di quadre indicano quante dimensioni, gli indici sono
rispettivamente n = n°colonne , m=n°righe, k=n°celle in z.
-Restituzione “n”  nomeVariabile.length = attributo del tipo Array

che restituisce la lunghezza dell’array “n” di tipo int.
-Accesso elemento  nomeVariabile [] [] ad esempio se devo

stampare o fare altre operazioni.
-Inizializza  nomeVariabile[0][0]=10; inizializza a 10 elemento
dell’array.
Esempio di composizione, attenzione al ciclo for annidato!
int[][] matrice = new int[5][5];
for(int i=0;i<matrice.length;i++) {
/*iteriamo le righe*/
for(int j=0;j<matrice[i].length;j++) {
/*iteriamo le colonne*/
matrice[i][j]=i;
System.out.print(matrice[i][j]);
}
78
LEZIONE 62: Interfacce - Collection e Map
Collection e Map  Liste dinamiche
PS: Array si usano per le liste statiche.
-Set e List  Interfacce che estendono Collection.

-SortedSet  Estende Set.
•Collection: è la piu’ generica delle interfacce.

 Non definisce l’ordine degli elementi;
 Non definisce se ci possono essere elementi duplicati;
 Non puo’ contenere tipi primitivi solo oggetti!
Per inserire i primitivi  boxing, da Java 1.5 Autoboxing;
Una Interfaccia non si puo’ istanziare, esempio sotto si fa
new ArrayList
Collection<integer> c = new ArrayList<Integer>();
•List: estende l’interfaccia collection.

 Elementi ordinati rispetto all’inserimento;
 Puo’ contenere duplicati;
 Permette di inserire oggetti specificando l’indice (vedi
sotto);
 Permette di ottenere gli elementi specificando l’indice.
79
LEZIONE 63: ArrayList.
ArrayList Classe che permette implementazione
dell’interfaccia List.
Costruttori  Istanziano la lista.
 ArrayList<Tipo>() : crea instanza Classe ArrayList vuota
senza specificare la capacita’;
 ArrayList<Tipo>(int capacita’) : come sopra ma con un

intero si indica la capacita’;
Esempi:
ArrayList<Prodotto> lista = new ArrayList<Prodotto>();
/*Lista oggetti di tipo prodotto*/
ArrayList<String> lista = new ArrayList<String>();

/*Lista oggetti di tipo stringa*/
Si potrebbe anche istanziare a partire dall’interfaccia List, ma poi va

usato ArrayList come costruttore, perché una Interfaccia non si puo’
istanziare
List<String> lista = new ArrayList<String>();
Esempio:
public void esempioArrayList() {
/*Istanzio Lista di oggetti Smartphone vuota*/
List<String> lista = new ArrayList<String>();
/*Aggiungo alla lista le stringhe che sono gli oggetti*/

lista.add("Paolo");
lista.add("Mario");
lista.add("Chiara");
lista.add("Marta");
80
Metodi  Manipolano la lista.
 Object.get(int index) : restituisce elemento in
posizione index; Attenzione: la lista come un array parte da
elemento 0.
Es: lista.get(0); restituirebbe Paolo.
 Object.set(int index, Object obj) : sostituisce elemento

in posizione index, con nuovo elemento obj;
Es: lista.set(0,”Mario”); sostituirebbe Mario a Paolo
 boolean add(Object obj) : aggiunge elemento obj,

dopo ultimo elemento; E’ boolean perché quando
aggiunte restituisce true.
 void add(Int index,Object obj) : aggiunge elemento obj

in posizione index, sposta tutti gli elementi successivi
di una posizione;
Es: lista.add(0,"tony"); aggiunge Tony alla lista.
 int size(): restituisce il numero di elementi come

intero;
Es: System.out.println(lista.size());
 boolean isEmpty(): restituisce true lista vuota, false

 se contiene almeno 1 elemento;
Es: if(lista.isEmpty()) {
System.out.println("La lista è vuota");
} else {
System.out.println("La lista contiene elementi");
}
 Object remove(int index): rimuove elemento in

posizione index e fa arretrare di una posizione tutti i
successivi;
Es: lista.remove(0);
81
 String toString(): restituisce una stringa elenco di tutti
gli elementi della lista;
Es: System.out.println(lista.toString())
[tony, Jerry, Mario, Chiara, Marta]
 int IndexOf(Object elem): restituisce la posizione

dell’elemento nella lista, oppure -1 se elem non esiste;
Es: System.out.println(lista.indexOf("Mario"));
Ritorna 2 nel caso della lista sopra.
 void clear(): elimina tutti gli elementi della lista;
 Object[] variabile = object.toArray(): restituisce un

array a[] contenente tutti gli elementi della lista.
Es: Object[] a = lista.toArray();
82
LEZIONE 64: Classi HashMap e Properties(usata per file config.)
HashMap Classe che permette implementazione
dell’interfaccia Map. K sono elementi chiavi(Key), e V
elementi Valori.
Costruttori  Istanziano la mappa.
 HashMap<K,V>() : crea instanza Classe HashMap vuota
senza specificare la capacita’;
 HashMap<K,V>(int capacita’) : come sopra ma con un intero

si indica la capacita’;
K= Tipo Chiave | V=tipo Valore
Esempi:
HashMap<String,Prodotto> lista = new HashMap< String,Prodotto >();
/*Mappa di oggetti di tipo prodotto, con chiavi Stringhe*/
Map<String, Smartphone> mappa = new HashMap<String, Smartphone>();
/*una Map non puo’ essere istanziata in quanto Interfaccia (vedi errore), quindi
uso il costruttore HashMap, o in alternativa usa la Classe HashMap per
istanziare*/
HashMap<String,Smartphone> mappa2 = new HashMap<String,Smartphone>();
Errore.
83
Metodi  Manipolano la mappa.
 Object.put(Object Key,Object Value) : aggiunge
l’elemento value alla mappa associandolo alla Key; Se
la mappa contiene gia’ la Key allora l’elemento
associato viene sostituito da quello del put.
Il metodo ritorna null se la Key non esiste, oppure il
vecchio oggetto associato.
Es: mappa.put(0, "Luca"); inserisce Luca

nell’elemento chiave 0.
o Object.get(Object Key) : restituisce elemento associato

alla Key
Es: mappa.get(0)restituirebbe Luca.
 Object.remove(Object Key) : rimuove l’elemento value

alla mappa associato alla Key; Il metodo ritorna
l’elemento rimosso.
 Object.size(): restituisce la dimensione della mappa.
 boolean containsKey(Object key) : restituisce true se la

mappa contiene la chiave, altrimenti false.
 Object.clear(): cancella la mappa.
 Object.Set<Object> keySet(): restituisce un oggetto di

tipo Set che contiene tutte le chiavi della mappa.
Set<String> keys = mappa2.keySet(); }
for (String string : keys) {
System.out.println(string+" ");
}
In questo caso keys è un oggetto contenente tutte le chiavi della mappa
in forma di stringa.
 boolean isEmpty(): restituisce true mappa vuota,

false  se contiene almeno 1 elemento;
84
Properties Classe che permette di gestire i file di
configurazione dei software.
Ad esempio creando un file “config.properties.txt” che mi riporta la
configurazione del mio database web dentro il workspace di Eclipse ed
editandolo con notepad++ come sotto:
Posso usare la classe Properties istanziando un oggetto p che mi

permette di stoccare il mio file esterno con il metodo Inpustream.
public void getConfig() {
Properties p = new Properties();

InputStream is;
try {
is = new FileInputStream(new
File("D:\\ECLIPSE\\WORKSPACE\\config.properties.txt"));
p.load(is);
System.out.println(p.getProperty("db-
name"));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
}
85
LEZIONE 65: Interfaccia Iterator
Iterator<E>  Interfaccia che permette di generare Classi per l’iterazione

degli elementi di Collections (Lista, ArrayList).
Metodi:
 hasNext(): ritorna True fino a quando ci sono elementi della
lista da scorrere. Usato spesso come condizione in un While;
 next(): ritorna l’elemento successivo;
 remove(): rimuove della lista l’ultimo elemento ritornato.

Deve essere usato solo durante un ciclo, altrimenti Java
genera eccezione ConcurrentModificationException quando
effettuiamo il successivo accesso alla lista.
LEZIONE 66: Come iterare gli elementi di una lista con For,
For each e Iterator.
1) Creo la lista:
List<Smartphone> lista2 = new ArrayList<Smartphone>(); /*Istanzio Lista di

oggetti Smartphone vuota*/
Smartphone sm1 = new Smartphone();

sm1.setMarca("Apple");
sm1.setModello("iPhone");

sm2.setMarca("Samsung");
sm2.setModello("Note");

sm3.setMarca("Huawei");
sm3.setModello("P8");

sm4.setMarca("Xiaomi");
sm4.setModello("RedMi");
lista2.add(sm1); /*Aggiungo ogni oggetto alla lista*/

lista2.add(sm2);
lista2.add(sm3);
lista2.add(sm4);
86
2) Posso iterarvi all’interno usando FOR EACH:
for (Smartphone p : lista2) {
/*Ciclo For each che stampa gli oggetti di una lista*/
System.out.println(p.getMarca()+" "+p.getModello());
/*Ad ogni iterazione del ciclo FOR ogni oggetto della lista viene
stoccato dentro l'oggeto p e stampato*/
}
3) Oppure un normale FOR:

for (int i = 0; i < lista2.size(); i++) {
/*Ciclo For che stampa gli oggetti di una lista usando il metodo
object.get(i)*/
Smartphone p1 = lista2.get(i);;
System.out.println(p1.getMarca()+" "+p1.getModello());
}
4) Oppure con il metodo ITERATOR:
Iterator<Smartphone> it = lista2.iterator();
while(it.hasNext()) {
Smartphone p2 = it.next();
System.out.println(p2.getMarca()+" "+p2.getModello());
}
Stampa quanto segue per ognuna delle versioni sopra:

Apple iPhone
Samsung Note
Huawei P8
Xiaomi RedMi
87
Come iterare le chiavi:
1)Metodo “keySet()”:
Set<String> keys = mappa2.keySet();
for (String string : keys) {
System.out.print(string+" ");
}
2)Metodo “Iterator()”:
Iterator<String> it2 = keys.iterator();
while(it2.hasNext()) {
String chiave = it2.next();
System.out.println(chiave);
}
3)Metodo “entrySet()” per Iterare Chiavi e Valori di una Mappa:
Iterator <Map.Entry<String,Smartphone>> it3 = mappa2.entrySet().iterator(); /*Definisce un

oggetto Iterator con il metodo EntrySet()*/
while (it3.hasNext()) { /*Itera la mappa fino a che esistono elementi*/

Map.Entry<String,Smartphone> smtmp = it3.next();
/*Definisce un elemento temporaneo "smtmp" nel quale viene stoccato ogni elemento iterato
della mappa*/
Smartphone smvar = new Smartphone();
/*Definisce un oggetto Smartphone temporaneo "smvar"*/
smvar = smtmp.getValue();
/*Copia dentro smvar l'oggetto di tipo Smartphone che e' associato alla chiave*/
System.out.println(smtmp.getKey()+" "+smvar.getMarca()+" "+smvar.getModello());
/*Stampa la chiave e gli attributi dell'oggetto*/
}
88
LEZIONE 67: Classe Wrapper
Trasforma un tipo di dato primitivo in un oggetto equivalente, incapsulando
al suo interno una variabile di tipo primitivo.
Esempio:
package wrapper;
public class Main {

int a = 5; /*a è un dato di tipo int*/
Integer b = new Integer(10);

/*b è un oggetto della Classe Wrapper*/
int c= b.min(a, b);
/*Il vantaggio della classe Wrapper è che posso trattare variabili come
oggetti ed esistono diversi metodi per manipolarle*/
System.out.println(c);
89
LEZIONE 68: Boxing, Autoboxing e Unboxing
Boxing  caratteristica Java che permette di inscatolare un dato primitivo

nella classe wrapper per utilizzarlo come oggetto wrapper;
Integer b = new Integer(10); /*b è un oggetto della Classe Wrapper*/
AutoBoxing  caratteristica Java che permette convertire un dato primitivo

nella classe wrapper.
Integer d = 12; /*Si incapsula in wrapper direttamente senza istanziare*/
UnBoxing  caratteristica Java che permette ri-convertire una classe

wrapper in un dato primitivo.
int vard = d; /*Si estrae l'oggetto wrapper in variabile dello stesso tipo*/
AutoBoxing & Unboxing disponibili da Java 1.5.
90
SEZIONE 11
LEZIONE 69: Interfacce
Componente che permette di definire metodi comuni a piu’ tipi di oggetti,
senza implementarne la logica.
 Contiene definizione dei metodi che eseguono le azioni;
 Non contiene costruttori;
 Puo’ contenere variabili ma soltanto STATIC, quindi costanti.
 L’interfaccia non puo’ essere istanziata, ricordiamo quando si definiva una lista
con List  non era ammesso poi creare una istanza List ma usavo ArrayList.
Sintassi  keyword interface

Per implementare una interfaccia si usa un Classe:
 Una classe puo’ ereditare una sola Classe;
Es: public class Classe C extends ClasseA,ClasseB {
/*non puo’ ereditare piu’ di una classe*/
 Una classe puo’ implementare una o piu’ interfacce (ereditarieta’

multipla)
Es: public class Classe C implements InterfacciaA,InterfacciaB {
/*puo’ implementare piu’ classi*/
 Una interfaccia puo’ ereditare una o piu’ interfacce.
Generare un interfaccia in Eclipse:

1) Tasto destro sul package;
2) New  Interface;
91
Esempio:
Classe Prodotto che ha bisogno di un Classe FormaGeometrica che ha bisogno di

metodo che stampa un XML un metodo che stampa un XML
Il metodo che stampa l’XML è una

necessita’ comune, quindi è corretto
definirlo in una interface!
IMPORTANTE: Siccome in Java non è permesso che
una Classe erediti piu’ di una Classe allora non posso
creare una Classe che genera l’XML e che estende
(extends) sia Prodotto sia FormaGeometrica.
Devo pertanto definire una interfaccia GeneraDati

che puo’ essere implementata in ogni classe.
Quindi l’interfaccia non fa niente di

particolare, solamente definisce dei
metodi che possono essere riutilizzati
da piu’ Classi che li implementano
ognuno con un proprio @OVERRIDE.
Una volta fatto l’implements di una interfaccia all’interno di una Classe,

mi viene chiesto di implementare il relativo metodo che sara’ fatto in
override, in quanto questo permette una personalizzazione del metodo
Metodo generaXML implementato in Prodotto Metodo generaXML implementato in FormaGeometrica
92
LEZIONE 70: Classi Astratte
Classe che permette di dichiarare caratteristiche comuni a piu’ Classi.
 A differenza dell’interfaccia permette di definire attributi, metodi e
costruttori;
Sintassi  • Classe: abstract class
 Metodi: abstract (prima del metodo), posso anche avere metodi che non
sono astratti in una classe Astratta.
 Non puo’ essere istanziata per creare oggetti come invece si fa con una
classe normale.
93
USO Definire entita’ astratte come Prodotto, FormaGeometrica,
Animale…che poi possono essere estese in classi che costruiscono entita’ piu’
concrete.
Esempio: televisore estende prodotto.
94
LEZIONE 71: Classi Inner, Locali & Anonime.
Premesse:
 Per ogni Classe deve esistere un file .Java (src) che è nominato con lo stesso nome
con la quale è dichiarata la classe.
 Per istanziare un oggetto di una classe devo usare un costruttore che usa la
keyword new. Esempio: Lavatrice l1 = new Lavatrice();
3 tipi di Eccezioni:
o Inner: è un classe definita all’interno di un’altra classe, ma al di
fuori dei metodi;
Accesso:
-Lettura: anche dell’esterno in
funzione del modificatore.
-Istanze della Inner: si possono
creare solo da dentro la classe che
la contiene.
95
Esempio:
Esiste anche un altro modo per poter instanziare la Classe Inner al di fuori
della Classe in cui è stata definita, cioè’ definirla di tipo Static.
96
o Locale: è un classe definita all’interno di un’altra classe, ma
dentro ad un metodo;
o Anonima: è un costrutto che consente di creare e istanziare

una classe. Sono Classi spesso usate nelle Interfacce di tipo
grafico. Sono Classi che vengono definite, inizializzate ed
istanziate nello stesso momento.
Esempio sotto: per Implementare l’interfaccia Azione…
…posso o creare una Classe chiamata “AzioneImplement”

….oppure creare una Classe Anomina Azione che viene
dichiarata, definita e istanziata in un unico punto.
97
Il vantaggio è che per implementare l’interfaccia non ho creato un nuovo file
.java relativo ad una Classe ma la ho implementata nel Main risparmiando la
creazione e gestione di un file.
98
SEZIONE 13 – INPUT/OUTPUT
LEZIONE 76: Classe File
Il costruttore principale della Classe File riceve in ingresso una variabile di
tipo String, cioè il percorso dove salvare il file.
String path  Costruttore File

La creazione dell’instanza di File non genera fisicamente il file o la Directory
sul disco:
-Per creare file fisicamente createNewFile()
-Per creare dyrectory fisicamente mkdir()
 Metodi della Classe File
99
Esempio creazione Directory (mkdir) e File (CreateNewFile)
package files;
import java.io.File;
import java.io.IOException;
/*ATTENZIONE !!!: Un oggetto di tipo File puo' essere: FILE o DIR, dipende solo dal path
passato come parametro*/
public class Main {
Main m = new Main(); /*Istanzia oggetto Main*/

String dir = "D:\\ECLIPSE\\WORKSPACE\\Esercizi\\Esercizi Files";
/*Salvo il path dentro una variabile stringa*/
String file = dir+"\\test-file-.txt"; /*concateno al path il nome del file*/
m.creadir(dir); /*Creo la Directory TEST FILE nel path, invocando il metodo creadir()*/
m.creafile(dir+"\\test-file-.txt"); /*Creo il file test-file-.txt nella Directory del
path, invocando il metodo creafile()*/
m.creafile(dir+"\\test-file2-.txt"); /*Creo il file test-file2-.txt nella Directory del
path, " "*/
m.creafile(dir+"\\test-file3-.txt"); /*Creo il file test-file3-.txt nella Directory del
path, " "*/
m.creafile(file); /*Altro modo di creare il file \\test-file-.txt, invocando il metodo

creafile()*/
m.cancellaFile(file); /*Cancella il file nel path file*/
File d = new File(dir); /*Crea nuovo oggetto di tipo File nel path "dir", quindi una
DIRECTORY nel path DIR */
System.out.println(d.isDirectory()); /*Restituisce TRUE se la Directory esiste*/
File f = new File(file); /*Crea nuovo oggetto di tipo File nel path "dir", quindi una
DIRECTORY nel path DIR */
System.out.println(f.isFile()); /*Restituisce TRUE se il File esiste*/
File[] files = d.listFiles(); /* Il metodo listFiles() restituisce un array di file della

Directory */
for (File file2 : files) { /*Questo ciclo for each permette di stampare tutti i nomi dei
file nella directory*/
System.out.println(file2.getName());
/*Per il tipo File esiste anche il metodo getName(), che restituisce una Stringa con il
nome del file*/
}
100
public void creadir(String path) { /*Come metodo per la creazione del file, ma per la
directory*/
File d = new File(path);
if(!d.exists()) {
try {
d.mkdir();
} catch (Exception e) {
System.out.println("Errore nella generazione della Directory");
}
} else {
System.out.println("La Directory "+d.getName()+" è gia' esistente");
}
public void creafile(String path) { /*Metodo che crea un file*/

File f = new File(path); /*Istanzia oggetto file nel path specificato, il path
è una stringa passata al metodo*/
if(!f.exists()) { /*Check se il file esiste gia', se si non lo crea*/
try { /*Il try si accerta che se avvengono eccezioni vengano gestite
con un errore in output*/
f.createNewFile(); /*Se non esiste lo crea nel path*/
System.out.println("Errore nella generazione del file");
/*Messaggio Errore del try*/
}
} else {
System.out.println("Il file"+f.getName()+" è gia' esistente");
/*Messaggio Errore del check esistenza file*/
}
public void cancellaFile(String path) {

File f = new File(path);
if (f.delete()) {
System.out.println("Il file "+f.getName()+" è stato cancellato con successo");
}else {
System.out.println("Cancellazione del file fallita");
}
PRIMA CANCELLAZIONE DOPO CANCELLAZIONE
101
LEZIONE 77: Classi per scrivere su File FileWriter, BufferedWriter,
PrintWriter
FileWriter & BufferedWriter
public void scriviFileWriter(String path,String[] testo) throws IOException {
FileWriter fw=null; /*Inizializzo oggetto FileWriter*/
try { /*Gestisce eccezioni su creazione del file con il metodo getFile()*/

fw = new FileWriter(getFile(path)); /*Costruisco l'oggetto fileWriter*/
for (String string : testo) { /*Carico Array*/
fw.write(string); /*Metodo della Classe file writer che scrive*/
}
} finally {
try {
fw.close(); /*Metodo della Classe file writer che chiude il file*/
} catch (Exception e2) {
e2.printStackTrace();
}
}
102
Aggiunto il metodo sotto che scrive un file buffered.
public void scriviBufferedWriter(String path,String[] testo) throws IOException {
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(getFile(path)));
/*Costruisco l'oggetto BufferedfileWriter, questo richiede come parametro l'oggetto
FileWriter*/
for (String string : testo) {
bw.write(string);
bw.newLine(); /*Manda a capo 1 riga*/
}
} finally {
try {
bw.close();
}
}
103
PrintWriter
ERRATA CORRIGE: newLine() non è ammesso da PrintWriter;

Premessa: prima di scrivere PrintWriter rispetto al codice precedente è stato creato un metodo
getFile() che evita ogni volta la ridondanza di dover creare l’oggetto File f. Anche i metodi FileWriter e
BufferWriter sono stati modificati con l’inserimento di questo metodo getFile();
private File getFile(String filePath) {
File file = new File(filePath); /*Costruisco l'oggetto file*/
if(!file.exists()) { /*Se "f" non esiste lo creo*/

try {
file.createNewFile();
System.out.println("Errore nella creazione del file");
}
}
return file;
}
Sotto la creazione del metodo con PrintWriter, anche esso per essere costruito ha necessita’ dell’oggetto filewriter come
parametro.
public void scriviPrintWriter(String path,String[] testo) throws IOException {
PrintWriter pw = null;
try {
pw = new PrintWriter(new FileWriter(getFile(path)));
/*Costruisco l'oggetto BufferedfileWriter, questo richiede come
parametro l'oggetto FileWriter*/
for (String string : testo) {
pw.write(string);
pw.println();
}
} finally {
try {
pw.close();
}
104
}
LEZIONE 78: Leggere File: File Reader e BufferedReader

 FileReader: legge un singolo carattere per volta;
Istanza Classe File  Costruttore File Reader
Metodi
public void esempioFileReader(String filePath) {
File f= new File(filePath); /*Istanzio oggetto file f dal path*/
if(f.exists()) { /*Se il file esiste nel path procedo con le operazioni di lettura*/
FileReader fr = null; /*Istanzio oggetto FileReader e lo inizializzo null*/
try { /*Gestore eccezioni se il file non fosse raggiungibile*/
fr = new FileReader(f); /*Costruisco oggetto FileReader passando il

file*/
char[] testo = new char[1024]; /*Instanzio array char di size 1024 dove salvare i
char letti dal file*/
int size = fr.read(testo); /*Invoco metodo di lettura sull'oggetto fr che legge

da file f e deposita dentro array di char. Dato che il metodo ritorna un int di caratteri
letti lo uso per un For per stampare i caratteri letti a video*/
for(int i=0;i<size;i++) {
System.out.print(testo[i]);
}
} catch (FileNotFoundException e) { /*Try per eccezioni FileReader*/

} catch (IOException e) { /*Try per eccezioni fr.read()*/

} finally {
try { /*Try per eccezioni fr.close()*/
fr.close();
}
}
} else {
System.out.println("Il file non esiste");
}
105
 BufferedReader: come file reader ma bufferizza, piu’
efficiente;
Istanza Classe FileReader  Costruttore File Reader

Metodi : stessi di FileReader;
public void esempioFileBufferedReader(String filePath) {
File f= new File(filePath); /*Istanzio oggetto file f dal path*/
if(f.exists()) { /*Se il file esiste nel path procedo con le operazioni di lettura*/
BufferedReader fr = null; /*Istanzio oggetto BufferedReader e lo inizializzo null*/
try { /*Gestore eccezioni se il file non fosse raggiungibile*/
fr = new BufferedReader(new FileReader(f)); /*Costruisco oggetto BufferedReader

passando instanza di FileReader*/
char[] testo = new char[1024]; /*Instanzio array char di size 1024 dove salvare i
char letti dal file*/
int size = fr.read(testo); /*Invoco metodo di lettura sull'oggetto fr che legge da

file f e deposita dentro array di char. Dato che il metodo ritorna int di caratteri letti
lo uso per un For per stampare i caratteri letti a video*/
for(int i=0;i<size;i++) {
System.out.print(testo[i]);
} catch (FileNotFoundException e) { /*Try per eccezioni FileReader*/

} catch (IOException e) { /*Try per eccezioni fr.read()*/

} finally {
try { /*Try per eccezioni fr.close()*/
fr.close();
}
}
} else {
System.out.println("Il file non esiste");
}
}
106
LEZIONE 79 & 80: Input da tastiera.
 InputStreamReader
107
 Scanner
La classe Scanner rappresenta la soluzione più semplice per realizzare in Java un input da uno
stream di caratteri. La classe Scanner appartiene al package java.util e i suoi oggetti sono in grado di
individuare e interpretare i tipi primitivi e le stringhe presenti all’interno di uno stream di
caratteri. Essa presenta diversi costruttori che permettono di ottenere un oggetto di tipo Scanner a
partire da oggetti di altri tipi, quali ad esempio:
1. InputStream, utile in quei casi in cui, per esempio, si debba leggere da tastiera
(l’oggetto System.in, si ricorda, è di tipo InputStream).
2. String, utile in quei casi in cui sia necessario procurarsi degli input da una stringa.
3. File, utile in quei casi in cui l’input proviene da un file di testo.
Per approfondimenti al solito si rimanda alla documentazione ufficiale del linguaggio Java (link), di
seguito vediamo solo alcuni esempi di utilizzo per i primi due casi: lettura da tastiera e da stringhe,
per il terzo caso della lettura da un file di testo, invece, si rimanda al seguente link. Prima però
accenniamo a quali sono alcuni dei metodi più utilizzati di questa classe.
(Si tenga presente che la classe Scanner suddivide lo stream dei caratteri in token, cioè in spezzoni
di stringhe separate dai caratteri delimitatori. I caratteri delimitatori di default sono: gli spazi, i
caratteri di tabulazione e i caratteri di newline).
Il caso più tipico di utilizzo di un oggetto di classe Scanner è quello che utilizza il
metodo nextLine() per leggere una riga intera.
Esempio: dichiarare un oggetto scan di tipo Scanner.

Scanner scan = new Scanner(System.in);
int tot;
tot = scan.nextInt();
Metodi:
 int nextInt(): legge il token successivo interpretandolo come un numero intero e lo
restituisce al chiamante, o lancia un eccezione di tipo InputMismatchException se il token non è
un intero.
 double nextDouble(): legge il token successivo interpretandolo come un numero reale e lo
restituisce al chiamante, o lancia un eccezione di tipo InputMismatchException se il token non è
un reale.
 String nextLine(): legge la riga di testo (successiva) e la restituisce al chiamante.
 String next(): legge il successivo token senza delimitatori e lo restituisce al chiamante.
 boolean hasNextInt(): restituisce vero se il prossimo token può essere interpretato come un
numero intero, falso altrimenti.
 boolean hasNextDouble(): restituisce vero se il prossimo token può essere interpretato come
un numero reale, falso altrimenti.
 boolean hasNextLine(): restituisce vero se in input è disponibile una ulteriore riga, falso
altrimenti.
 boolean hasNext(): restituisce vero se in input è disponibile un ulteriore token, falso altrimenti.
 Scanner useDelimiter(String): modifica il delimitatore dei token, dove la stringa passata come
parametro può essere una espressione regolare (vedi esempio più avanti).
108
1import java.util.Scanner;
2public class ProvaScanner {
3 public static void main(String[] args) {
4 Scanner in = new Scanner(System.in); //istanzia un oggetto lettore di tipo Scanner
5 String s = in.nextLine(); //legge una riga di testo e la memorizza nella variabile s
6 System.out.println("Ho letto la riga: " + s);
7 }
8}
Vediamo anche alcuni esempi di utilizzo della classe Scanner con gli altri metodi:
1 import java.util.Scanner;
2 import java.util.InputMismatchException;
4 public class Main {
5 public static void main(String[] argv) {
6 int i, j;
7 Scanner scanner = new Scanner(System.in);
8 try {
9 System.out.print("Primo numero: ");
10 i = scanner.nextInt();
11 System.out.print("Secondo numero: ");
12 j = scanner.nextInt();
13 System.out.println(i + j);
14 } catch(InputMismatchException ex) {
15 System.out.println("Errore, input non valido.);
16 } finally {
17 scanner.close();
18 }
19 }
20}
Nell’esempio di sopra vengono prelevati da tastiera due numeri e vengono sommati. Il tutto è stato
inserito in un blocco try-catch-finally poiché gli input forniti potrebbero non essere degli interi e in tal
caso viene lanciata un’eccezione di classe InputMismatchException. In questo esempio viene utilizzato
anche il metodo close() che permette di rilasciare le risorse occupate dall’oggetto di classe Scanner
creato.
109
INPUT DA UNA STRINGA - LETTURA DI TOKEN DI INTERI
3 public class Main {
5 String input = "aaa 1 xyz 56 78 .,- pp 1092 yasl 3.14 100";
6 Scanner scanner = new Scanner(input);
7 while(scanner.hasNext()) {
8 // se il prossimo token è un intero lo estrae e lo visualizza
9 if(scanner.hasNextInt())
10 System.out.println(scanner.nextInt());
11 // altrimenti lo salta
12 else
13 scanner.next();
14 }
15 scanner.close();
16 }
17}
Nell’esempio di sopra si ha una stringa che utilizza un delimitatore di default (lo spazio), dalla quale
vengono estratti solo gli interi saltando i restanti token. L’output ottenuto è il seguente:
1
56
78
1092
100
Il delimitatore di default può essere modificato tramite il metodo useDelimiter(), come nell’esempio
seguente:
INPUT DA STRINGA, LETTURA DI TOKEN E INTERI CON DELIMITATORE ';'
Java
3 public class InputConScanner {
110
5 String input = "100;120;300;80";
6 Scanner scanner = new Scanner(input);
7 scanner.useDelimiter(";");
8 while(scanner.hasNext()) {
9 // se il prossimo token è un intero lo estrae e lo visualizza
10 if(scanner.hasNextInt())
11 System.out.println(scanner.nextInt());
12 // altrimenti lo salta
13 else
14 scanner.next();
15 }
16 scanner.close();
17 }
18}
L’esempio precedente produce l’output seguente:
100
120
300
80
NOTA BENE. Attenzione, l’esempio precedente funziona solo se i numeri interi sono separati
esattamente da un solo carattere di punto e virgola. Se si vuole che funzioni anche nel caso in cui a
separarli ci siano più caratteri diversi, compreso gli spazi, bisogna passare al metodo un’espressione
regolare, argomento questo complesso per il quale si rimanda alla documentazione del linguaggio. Qui
si fornisce solo la soluzione nel caso tra i numeri interi, oltre al punto e virgola, ci siano anche degli
spazi. In questo caso la stringa da passare al metodo è : “\s*;\s*”. Il primo backslash nell’espressione
indica che quello che segue è un carattere speciale, ossia l’espressione s* che vuol dire “da 0 a un
numero a piacere di spazi“.
P.S. Per risolvere un problema di estrazione di token da una stringa come il precedente, può essere più
conveniente o sfruttare direttamente i metodi della classe String, come ad esempio i
metodi split() e trim(), o riccorre alla classe StringTokenizer sftuttando i
metodi hasMoreToken() e nextToken(), per i quali si rimanda alla documentazione ufficiale del linguaggio
Java (link). Si riporta qui sotto per comodità il codice di un semplice esempio di utilizzo per entrambe le
soluzioni citate prima:
Java
1 public class Test {
2 public static void main(String[] args) {
3 String s = "3; A; 4; A; 5; A";
111
5 //Prima soluzione: metodi split() e trim() della classe String
6 String[] vs = s.split(";");
7 for(int i=0; i<vs.length; i+=2){
8 System.out.print(vs[i].trim());
9 System.out.println(vs[i+1].trim());
10 }
11
12 System.out.println("");
13
14 //Seconda soluzione: oggetto di classe StringTokenizer
15 StringTokenizer st = new StringTokenizer(s, ";");
16 while(st.hasMoreTokens()) {
17 System.out.print(st.nextToken().trim());
18 System.out.println(st.nextToken().trim());
19 }
20 }
21}
22*/
Il codice di sopra produce l’output seguente:

3A
4A
5A
3A
4A
5A
112
LEZIONE 129: Unit Test
Fase di Test  Fase importante del processo di sviluppo. Spesso viene
trascurata in piccole realta’ mentre in ambienti Enterprise (PA, banche, e-
commerce….) ricopre un ruolo fondamentale.
-Debug  Verifica solo errori di sintassi/struttura e non di semantica.
-Test  Se ben progettati posso rilevare errori di semantica e
sviluppandoli parametrici possono essere simulati vari Use Case ai quali
il prodotto potrebbe essere sottoposto in uso reale, prevendo bug o
crash.
Esecuzione dei test:
Manuale  Creo un Main che esegue i test che voglio condurre.
Strumenti Specifici  Software o librerie che supportano lo sviluppatore, uno di
questi è il Framework Java JUnit.
Xche’ gli strumenti specifici? Se il software cambia non possiamo

usare il metodo Manuale, mentre JUnit permette di testare metodi o
insiemi di essi anche se il codice viene modificato.
Unit Test  Unita’ di codice:
Rappresenta un singolo metodo o un insieme di metodi che
implementano un singola funzionalità.
Unit test puo’ essere organizzato in:
 Test Case: testa una singola unita’ di codice;
 Test Suite: permette di eseguire test su un gruppo di funzionalità

correlate tra loro.
113
Vantaggi degli Unit Test:
 Rendono piu’ semplici le modifiche: usando Unit Test è piu’ facile
modificare il codice con la tranquillà che il componente modificato
continui a funzionare. Se vengono scritti Unit Case per ogni metodo o
per ogni unita’ funzionale, se una modifica porta errori sara’ piu’ facile
individuare in quale metodo si genera l’errore.
 Rendono piu’ semplici integrazione tra componenti: gli unit test
limitano i bug legati all’interazione tra unità funzionali, grazie alla alla
garanzia che ogni unità risponda come richiesto.
 Costituiscono un supporto alla documentazione di progetto: in
ambiente Enterprise è molto spesso richiesto un Test Reporting sia si
unita’ sia di sistema come documentazione da consegnare per il
progetto stesso.
Limiti:
 Possono non essere in grado di identificare tutti i malfuzionamenti:
infatti testando singole unita’ funzionali o gruppi di esse, non possono
garantire una funzionalita’ totale del sistema. Tuttavia un buon
progetto del test consente di limitare al minimo le possibilità di
malfunzionamento.
 Sono piu’ efficaci quando sono usati insieme ad altre tecniche di
testing del software.
 Non testano le prestazioni del sistema ma solo la funzionalita’.
114
LEZIONE 130: Framework JUnit
Cosa è?- Framework open-source che consente di scrivere unit test,
supportando chi sviluppa codice nell’attivita’ di codice.
Cosa fa?- Permette di scrivere ed eseguire Test Case e Test Suite per oggetti e
Classi.
Integrato in Eclipse come plug-in, 2 versioni:
JUnit 3 prima di Java 5 utilizza reflection per individuare test;
JUnit 4  richiede Java 5 o oltre e utilizza annotations per definire test;
Come funziona?
1) Creo una classe Test Case per ogni classe;
2) Se ho Test Case correlati creo una classe Test Suite che contiene
riferimento alle classi Test Case.
Dove creo le Classi di Test Gerarchicamente deve essere nella directory

test, all’interno della directory src. Per crearla tasto destro sul Package  New
Source Folder e la chiamo test.
115
Next  Seleziono i metodi da testare. Nel mio caso trasla().
Con il PROMPT sopra Eclipse mi informa che JUNIT 4 non è nel build path del progetto,
cio’ significa che il JAR di JUNIT non è tra le librerie richieste e se lo voglio aggiungere.-->
OK.
116
Nel mio esempio si è creata la Classe di test Cerchio:
Le Annotations di JUnit “@Test” specificano che i 2 metodi sono dei test.
ANNOTATIONS: si trovano nel package org.junit e si utilizzano per metodi definiti

nella classe Test Case.
 @Test: indica un metodo di test;
 @Before: indica un metodo di test che deve essere eseguito prima di tutti i test.
Se nel mio esempio sopra avessi un metodo con Annotation @Before allora JUnit
esegue prima quello e poi il resto dei metodi @Test.
 @After: indica un metodo di test che deve essere eseguito dopo di tutti i test. Se
nel mio esempio sopra avessi un metodo con Annotation @After allora JUnit
esegue prima tutti i @Test e poi @After.
 @BeforeClass: indica un metodo di test che deve essere eseguito prima di tutti
i test. Se nel mio esempio sopra avessi un metodo con Annotation @BeforeClass
allora JUnit esegue prima questo e poi tutti i metodi @Test della Classe di test.
 @AfterClass: indica un metodo di test che deve essere eseguito dopo di tutti i
test. Se nel mio esempio sopra avessi un metodo con Annotation @AfterClass
allora JUnit esegue prima i metodi @Test della Classe di test e poi questo.
La Classe TEST CASE non deve definire un costruttore e tutti i metodi devono essere
VOID e senza parametro in ingresso e devono eseguire il Throws della Classe
Exception.
117
Come funziona TEST CASE:
1) Istanzio un oggetto della Classe da testare (se serve) e invoco il metodo di

TEST su questo oggetto. Il metodo TEST esegue il confronto con assertEquals;
2) Se il confronto è positivo il test sara’ PASS, altrimenti FAIL;
Il confronto si effettua con i metodi Statici della Classe ASSERT di JUnit, questi metodi si
usano facendone l’import statico, vedi esempio a pagina precedente org.unit.jupiter
1)Fino a Java 3 il metodo di test andava chiamato testXXXXX dove con XXXX si intende il metodo da
testare nella Classe che è nel TestCase. Da Java 5 non è piu’ necessario in quanto non si usano la
Reflections ma le annotations per definire i test.
2)assertEquals(…) è un metodo statico che verifica che la Classe restituisca la somma.
118
Esiti del test
LEZIONE 132: Unit test parametrici
119
FARE MAPPA CONCETTUALE DI:
-STRUTTURA PROGRAMMA (project, Package,classe, metodo…) . + CLASSE MAIN / CLASSE
-VARIABILI (Tipo , Accesso, Tipo dato) .
-STRINGHE
-MODIFICATORI DI ACCESSO (Public, protected, private, default).
-FARE FORMULARIO DELLE SINTASSI
-FARE MAPPE CONCETTUALI DELLE COLLECTION
-Approfondire TEST su dispense del prof e sul WEB!
TO DO:
1- Vedere esempi di Matteo;

2- Vedere dispense inviate dal prof. e se si sta seguendo il programma
correttamente;
3- Trovare esercizi JAVA base;
120
121
ad oggetti
http://searchsoa.techtarget.com/definition/object-oriented-programming
http://it.wikipedia.org/wiki/Programmazione_orientata_agli_oggetti
122
ESERCIZI E APPROFONDIMENTI
123
ESERCIZIO STUDENTE: allenamento su uso di variabili, costruttori e array; In verde le elaborazioni per
comprenderei riferimenti in Java.
public class Studente { Classe Studente

private String nome; Attributo: nome
public Studente(String nome) { Metodi: Get & Set
this.nome = nome;
public void setNome(String nome) {
this.nome = nome;
public String getNome(){
return this.nome;
public static void main(String[] argc) {
Studente[] studenti = new Studente[4]; //Definisce un array di 4 elementi di tipo Studente.
Array: Studente
indice 0 1 2 3
chiave nome nome nome nome
Studente a1 = new Studente("Gigi"); //Creo oggetto "Gigi" di tipo Studente e puntato da a1 ( a1 ==> obj1, obj1.name = "Gigi")
Quando istanzio l’oggetto a1 di tipo studente, fisicamente in a1 viene scritto l’indirizzo della cella di memoria dove è contenuto l’oggetto
nello stack di tipo heap.
Object:a1 in memoria @FF1A18

a1: @FF1A18
Gigi
studenti[0] = a1; //Salvo il puntatore a1 all'oggetto Gigi nella cella 0 del'array "studenti"
Quando dentro all’array scrivo a1 nell’elemento di indice 0 sto di nuovo scrivendo l’indirizzo di memoria dell’oggetto 1.
Array: Studente
indice 0 1 2 3
chiave a1:@FF1A18 nome nome nome

a1: @FF1A18
Gigi
124
a1.setNome("Giorgio"); //Cambio il nome dell'oggetto puntato da a1 ( a1 ==> obj1, obj1.name = "Giorgio" )
Array: Studente
indice 0 1 2 3
chiave a1:@FF1A18 nome nome nome

a1: @FF1A18
Giorgio
a1 = new Studente("Luca"); //Creo un NUOVO oggetto "Luca" di tipo Studente e puntato da NUOVA variabile a1 ( a1 ==> obj2,
obj2.name = "Luca" )
Array: Studente
indice 0 1 2 3
chiave XX:@FF1A18 nome nome nome

XX: @xxxxxxxx
Giorgio

a1: @FF1A19
Luca
studenti[1] = a1; //Salvo il nuovo puntatore a1 (che punta a Luca) nella cella 1 dell'array "studenti"
Array: Studente
indice 0 1 2 3
chiave XX:@FF1A18 a1:@FF1A19 nome nome

XX: @xxxxxxxx
Giorgio

a1: @FF1A19
Luca
125
//CASO 1
Studente a2;
a2 = a1; //ATTENZIONE! Non sto creando un nuovo oggetto, ma solo un NUOVO PUNTATORE all'oggetto puntato dal secondo
puntatore a1 ( a1,a2 ==> obj2, obj2.name = "Luca" )
Array: Studente
indice 0 1 2 3
chiave XX:@FF1A18 a1:@FF1A19 nome nome

XX: @xxxxxxxx
Giorgio

a1: @FF1A19
Luca
a2: @FF1A19
a2.setNome("Paolo"); //Cambio il nome dell'oggetto "Luca" in "Paolo". a1 e a2 puntano allo stesso oggetto quindi
a1.getNome()=a2.getNome() ( a1,a2 ==> obj2, obj2.name = "Paolo"
studenti[2] = a2;
Array: Studente
indice 0 1 2 3
chiave XX:@FF1A18 a1:@FF1A19 a2:@FF1A19 nome

XX: @xxxxxxxx
Giorgio

a1: @FF1A19
Paolo
a2: @FF1A19
126
a1.setNome("Carlo");//Cambio il nome dell'oggetto "Paolo" in "Carlo". a1 e a2 puntano allo stesso oggetto quindi
a1.getNome()=a2.getNome() ( a1,a2 ==> obj2, obj2.name = "Carlo" )
studenti[3] = a1;
Array: Studente
indice 0 1 2 3
chiave XX:@FF1A18 a1:@FF1A19 a2:@FF1A19 a1:@FF1A19

XX: @xxxxxxxx
Giorgio

a1: @FF1A19
Carlo
a2: @FF1A19
for(int i=0; i<studenti.length; i++) {
System.out.print(studenti[i].getNome()+" "); } //NOTA: Cella 0 di "studenti" punta a obj1 (obj1.name =

"Giorgio"); le celle 1,2 e 3 puntanto tutte a obj2 (obj2.name="Carlo").
GIORGIO CARLO CARLO CARLO
//CASO 2
/*Studente a2 = new Studente("Paolo"); //ATTENZIONE! Sto creando un nuovo oggetto

"Paolo" di tipo Studente e puntato da a2 ( a2 ==> obj3, obj3.name = "Paolo")
studenti[2] = a2;
a2 = a1; //Creo NUOVO puntatore a2 verso l'oggetto "Luca"

creato in line 34 ( a1,a2 ==> obj2, obj2.name = "Luca" )
a2.setNome("Carlo"); //Cambio il nome dell'oggetto "Luca" in "Carlo".

a1 e a2 puntano allo stesso oggetto quindi a1.getNome()=a2.getNome() ( a1,a2 ==> obj2, obj2.name = "Carlo" )
//a1.setNome("Carlo"); // Stessa cosa che fare a2.setNome("Carlo")

come in line 52
studenti[3] = a1;
for(int i=0; i<studenti.length; i++)
127
System.out.print(studenti[i].getNome()+" ");*/ //NOTA: Cella 0 di "studenti" punta a obj1
(obj1.name = "Giorgio"); le celle 1 e 3 puntanto entrambe a obj2 (obj2.name="Carlo"); cella 2 punta a obj3
(obj3.name = "Paolo").
//CASO 3
/*Studente a2 = new Studente("Paolo");
studenti[2] = a2;
a1 = a2; //Creo NUOVO puntatore a1 verso l'oggetto "Paolo"

creato in line 60 ( a1,a2 ==> obj3, obj3.name = "Paolo" )
a1.setNome("Carlo"); //Cambio il nome dell'oggetto "Paolo" in

"Carlo". a1 e a2 puntano allo stesso oggetto quindi a1.getNome()=a2.getNome() ( a1,a2 ==> obj3, obj3.name =
"Carlo" )
studenti[3] = a1;
//a1.setNome("Carlo");
for(int i=0; i<studenti.length; i++)
System.out.print(studenti[i].getNome()+" ");*/ //NOTA: Cella 0 di "studenti" punta a obj1

(obj1.name = "Giorgio"); cella 1 punta a obj2 (obj2.name = "Luca"); le celle 2 e 3 puntanto entrambe a obj3
(obj3.name="Carlo").
128
GESTIONE DELLA MEMORIA NELLA PROGRAMMAZIONE AD OGGETTI
(Universita’ di Pisa) https://pages.di.unipi.it/milazzo/teaching/AA1314-ProgJava/slides/13-OOP2.pdf
129
130
Ricerca Max/Min in un array:
 Con bucle For
 public class ArrayMax {
 public static void main(String[] args) {
 int[] intArray = {24, 2, 0, 34, 12, 110, 2};

 int maxNum = intArray[0];

 for (int j : intArray) {
 if (j > maxNum)
 maxNum = j;
 }

 System.out.println("Maximum number = " + maxNum);
 }
 }
 Con Array Sort

 import java.util.Arrays;

 public class ArrayMax {
 public static void main(String[] args) {
 int[] intArray = {24, 340, 0, 34, 12, 10, 20};

 Arrays.sort(intArray);

 System.out.println("intArray after sorting: " + Arrays.toString(intArray));

 int maxNum = intArray[intArray.length - 1];
 System.out.println("Maximum number = " + maxNum);
 }
 }
131
Classe Math
132
SHORTCUT ECLIPSE
Ctrl + spazio
Autocomplete, ossia mostra i suggerimenti della parola che state
scrivendo.
Ctrl + 7
Commenta/Decommenta la riga corrente o la selezione di codice in
blocco.
Ctrl + Click
Eseguito sul nome di un metodo o di una classe, apre la finestra in cui si
trova il metodo o la classe ed il cursore si sposta esattamente al punto
desiderato.
Ctrl + Shift + R
Refactoring, ossia rinomina la variabile selezionata ovunque nel
workspace aggiornandone i riferimenti.
Ctrl + H
Cerca il testo selezionato all'interno del workspace. Utile ad esempio per
sapere dove un setter o getter viene chiamato.
Tab/Shift + Tab
Indenta il codice (o selezione di codice) verso destra o sinistra.
Ctrl + D
Cancella la riga su cui si trova il cursore.
Ctrl + Shift + O
Organizza gli import. Significa che quando avete usato una classe non
ancora importata, con questo shortcut importate tutte le librerie
mancanti e rimuovete quelle inutili.
Ctrl + 1
Attiva il quick fix, l'equivalente di premere a sinistra sulla lampadina che
appare a sinistra quando nella riga sono presenti sottolineature gialle (o
rosse). Funziona anche su variabili non sottolineate in giallo (o rosso), in
questo caso fra le possibilità c'è il rename.
Ctrl + E
Mostra l'elenco di tutte le classi aperte. Utile quando avete tante finestre
e non vedete dove si trova la classe che vi serve. In progetti grandi è
utilissimo.
Ctrl + I
Indenta correttamente la riga corrente.
133
Ctrl + Shift + F
Indenta correttamente l'intera pagina. Si può personalizzare il
comportamento andando su Window -> Preferences -> Java -> Code
style -> Formatter.
Ctrl + F11
Lancia l'applicazione (pulsante play verde). Di default è la classe corrente
che avete aperta nell'editor.
Alt + freccia su (giù)

Sposta l'intera riga corrente o la selezione di codice in alto (basso). Il
movimento indenta in automatico il codice.
Alt + freccia sinistra (destra)

Sposta il cursore nella classe su cui stavate lavorando prima di accedere a
quella corrente. Se prima stavate lavorando sulla classe Prova ed ora
state su Test, con alt + freccia sinistra tornate dentro Prova e la posizione
del cursore è quella che avevate prima.
Ctrl + M
Massimizza o ripristina le dimensioni del tab in cui state scrivendo.
Ctrl + Shift + L
Mostra tutte le shortcut definite in Eclipse.
Personalizziamo alcune scorciatoie:
4- Cliccate su Window -> Preferences -> General -> Keys.

5-
6- Nella schermata che vi apparirà potrete modificare le combinazioni di
tasti preesistenti e soprattutto aggiungere nuove shortcut alle operazioni
elencate da Eclipse.
7-
8-
9-
10- Di seguito una lista di shortcut consigliate:
11-
12- Generate Getters and Setters - Categoria Source (Ctrl + Shift + G)
13-
14- Generate Costructor Using Fields - Categoria Source (Ctrl + Shift + C)
15-
16- Update - Categoria SVN (Alt + U)
134

Appunti Corso Java R02

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Appunti Corso Java R02

Caricato da

Copyright:

Formati disponibili

APPUNTI CORSO JAVA

Luca Girotti,Dicembre 2021

1 – Commenta piu’ linee: Ctrl + shift +/

4- UML per Eclipse

5- Ctrl (dx) + “+” : ingrandisce e diminuisce testo.

2 – New Package: identifica il percorso in cui è presenta la classe.

5 - Dopo aver compilato un file lo trovo anche nel percorso sotto:

Il file .class contiene il bytecode che a noi è illeggibile.

• Di Classe: sono variabili di istanza ma definite come static.

•Riferimento: Classi, interfacce…..utilizzano quantita’ di memoria variabile

•Boolean: rappresenta true o false. Default=false

•int: rappresenta -2^16 a +2^16 -1(inclusi). Memoria= 32 bit; Default=0;

•long: rappresenta -2^32 a +2^32 -1 (inclusi). Memoria= 64 bit; Default=0;

devo usare la f finale o fare il cast

o fare il cast a (float)

•double: rappresenta -2^32 a +2^32 -1 (inclusi) IEEE754. Memoria= 64 bit;

•char: carattere unicode UTF, varia da ‘\u0000’ a ‘\uffff’ . Memoria= 16 bit;

Il char si inizializza tra APICI. Es. char a = ‘a’;

Cliccare Project e aggiungere il progetto che si vuole.

String s1 = "Lorem Ipsum.\"......."

Java non ha il primitivo String, questo si trova nel pacchetto java.lang.

1) Replace: sostituisce tutte le sottostringhe target con quella

2) ReplaceAll: sostituisce tutte le sottostringhe che

String t2 = t.replaceAll("[a-n]", "4");

3) ReplaceFirst: sostituisce la prima sottostringa che corrisponde

String t3 = t.replaceFirst("[a-n]", "P");

1) Substring (beginIndex): estrae la sottostringa che va dal

Restituisce la lunghezza in INT della stringa t.

Manipolazione: SPLIT, divide una striga in un array di stringhe,

String t8 = "Luca Girotti";

String t8 = "Luca Girotti”;

OPERATORI Aritmetici ( +, -, *, /, % (modulo)).

2) a += b; /*a contiene la somma con b*/

OPERATORI LOGICI: AND, OR, NOT.

IMPLICITO: se l’insieme di dati del quale voglio effettuare il

Devo fare il cast esplicito.

METODI: blocchi di codice che possono essere riutilizzati per rappresentare il

Esempio 2: scrivere un blocco di codice che recupera da un DB una riga da

[modificatore di accesso] [altri modif.] Tipo Ritornato NomeMetodo (parametri) [Trows

Struttura della Sintassi:

Signature del Metodo = Nome + Parametri

public static void main(String[] args) {

CorsoJava c = new CorsoJava();

/*metodo concatena: a questo metodo viene passata una sequenza

public String concatena(String... vars) {

Accesso ai metodi: modificatori di visibilita’ del metodo.

•Protected: leggermente piu’ restrittivo di Public.

•Default (o senza modificatore): piu’ restrittivo di Protected.

•Private: piu’ restrittivo di tutti.

•Static: utilizzabile solo su metodi e variabili, string invece è immutabile.

 Una classe puo’ contenere Variabili o Metodi con sua implementazione.

public Class Nomeclasse {

private String varA;

public String getVarA(){

 Una Interfaccia puo’ contenere Variabili e solo definizione dei Metodi.

public Interface Nomeinterfaccia Extends InterfacciaB {

public String getVarA(); /*Solo definizione*/

public Class Nomeclasse {

LEZIONE 26: I PACKAGES

Java ha dei suoi package, esempi sono:

Esempio: 3 package sotto ampli con ognuno una classe.

Gli import vanno dichiarati subito dopo i packages.

Sono ammesse variabili tutte in maiuscolo solo se sono costanti (STATIC);

LEZIONE 28: Commentare il codice sorgente

2) a += b; /a contiene la somma con b/

public String getVarA(); /Solo definizione/