Slide introduttive al linguaggio Java 8 in preparazione alla certificazione OCA 1Z0-808. Lezione del 12-10-2017 tenuta da Valerio Radice presso Nextre Engeneering https://www.nextre.it/corso/corso-java-oca/

1. Introduzione a Java
Valerio Radice

2. Valerio Radice
valerio.radice@nextre.it
WEB DEVELOPER & TEACHER
https://github.com/valix85
https://plus.google.com/+ValerioRadice85
https://it.linkedin.com/in/valix85/it

3. Di cosa si parlerà ?
 Benefici del Polimorfismo, ereditarietà
 Esempi di Garbage Collector
 Diversi modi di avviare il main
 Package e struttura delle classi
 Import, import statici
 Compilazione e avvio da CLI, passaggio di parametri e relativo utilizzo
 Sintassi di scrittura delle variabili e dei numeri
 valori di default delle variabili primitive
 default delle istanze dei tipi wrapper
 Output per i differenti tipi di oggetto(Classe, Array, primitivo)

4. Linguaggio di programmazione
« In informatica un linguaggio di programmazione è un linguaggio formale che
specifica un insieme di istruzioni che possono essere usate per produrre dati in
output. Esso è utilizzabile per il controllo del comportamento di una macchina
formale »
Wikipedia

5. Linguaggio di programmazione
« La compilazione è il processo per cui il programma, scritto in un linguaggio di
programmazione ad alto livello, viene tradotto in un codice eseguibile per mezzo
di un altro programma detto appunto compilatore »
Wikipedia
PRO: velocità di esecuzione / prestazioni ad HOC per la macchina
CONTRO: compilazione ad hoc per ogni macchina (poca portabilità)

6. Linguaggio di programmazione
« I linguaggi interpretati si basano sull’utilizzo di librerie compilate (per il
sistema di destinazione) per essere eseguiti senza dover essere ricompilati. La
libreria interpreta ed esegue il codice garantendo così portabilità »
PRO: codice unico e comprensibile, portabilità e flessibilità
CONTRO: esecuzione più lenta e onerosa di memoria, non autonomo

7. Linguaggio di programmazione
L’approccio di Java
Java adotta una strategia mista:
 da un linguaggio di alto livello compila un codice per una macchina virtuale
(non esistente nella realtà, JVM) detto ByteCode
 la macchina virtuale (JVM) interpreta il ByteCode codice eseguendo le
istruzioni all’interno dell’ambiente di esecuzione di Java (JRE)

8. Caratteristiche di Java
 Sintassi di alto livello, simile al C e C++
 Gratuito, non bisogna pagare licenze per creare prodotti commerciali
 Robusto, gestisce eccezioni e Garbage Collector (GC), compilatore severo (meglio
errori in compilazioni che in esecuzione)
 Standardizzato, offre una ricca documentazione libera gestita da Oracle, non
esistono conflitti di versione tra compilatori e versioni
 Indipendente e portabile, non dipende dalla macchina su cui viene eseguito, il
risultato sarà sempre lo stesso
 Orientato agli oggetti, offre caratteristiche come ereditarietà, incapsulamento e
polimorfismo
 Aperto, gestito da Oracle ma sempre in contatto con gli sviluppatori per
implementare nuove caratteristiche

9. IDE
Integrated Development Envirorment (IDE), o ambiente di sviluppo integrato, è
quel programma che ci facilità la scrittura del programma, ci da i suggerimenti,
ci guida in alcune operazioni e ci permette di avviare l’applicazione in modalità
di debug per ispezionarla durante il funzionamento.
Esistono IDE gratuti e a pagamento a seconda delle possibilità offerte.
 Eclipse
 IntelliJ
Un IDE non è fondamentale, basta un semplice editor di testo per creare
programmi Java, ma è fortemente consigliato!

10. JVM, JRE, JDK, JavaDoc
 Java Virtual Machine (JVM) = è la macchina virtuale di Java che contiene il
nostro programma quando è in esecuzione, permette l’esecuzione dei
programmi compilati in ByteCode.
 Java Runtime Envirorment (JRE) = è l’ambiente di esecuzione di Java e
comprende la JVM e le librerie standard di Java.
 Java Development Kit (JDK) = è l’insieme delle librerie non compilate, del
compilatore Java (Javac) e di tutto il software necessario per lo sviluppo in
Java. Contiene la JRE.
 JavaDoc = è un tool per la generazione automatica della documentazione
delle classi, in formato HTML, a partire da specifici commenti presenti in
esse.

11. Compilazione ed esecuzione
 Scrivere il codice all’interno di un semplice file di testo con estensione .java
(es: NomeFile.java)
 Compilare il file con il compilatore javac
 Javac NomeFile.java
 Il compilatore genera un file contenente il ByteCode della nostra classe nel
file NomeFile.class
 Eseguire il ByteCode con il comando java seguito dal nome del file compilato
senza estensione
 java NomeFile

12. Struttura di un programma Java
public class HelloWorld
{
public static void main(String args[]){
System.out.println("Hello World!");
}
}
Il programma è composto da una classe, due metodi statici.
Salvare il file in HelloWorld.java, compilare il programma ed eseguirlo

13. Commenti nel codice
Javadoc è un tool di java per realizzare la documentazione in formato HTML
servendosi di particolari commenti e marcatori. Il tool si può lanciare da riga di
comando: javadoc nomeClasse.java
Il tool potrà generare la documentazione solo per le classi public e dei relativi
metodi, costanti, costruttori e interfacce pubbliche.
// commento di riga
/* … */ commento di blocco
/** … */ commento per la javadoc
/**
* @author Valerio Radice
* @version v1.0
* <p>Descrizione della classe
disponibile su {@link AltraClasse }
</p>
* */

14. Componenti di un programma in Java
 Classe
 Oggetto
 Membro
 Attributo (variabile)
 Metodo
 Costruttore
 Package

15. Classe
 Una classe è un contenitore di dati e operazioni, si dichiara con la parola
chiave class seguito dal nome della classe. Per convenzione i nomi delle classi
iniziano con la lettera maiuscola e sempre al plurale; se si hanno nomi
composti, si rimuove lo spazio e si mette in maiuscolo l’iniziale della parola
(sintassi camelCase).
 Una classe non può iniziare con caratteri speciali, con numeri. Sono ammessi
lettere e _ £$€ all’inizio di una classe, numeri possono essere inseriti nel
mezzo o alla fine.
« Una classe è un’astrazione indicante un insieme di oggetti che condividono le
stesse caratteristiche e funzionalità »

16. Classe
[modificatori] class <NomeDellaClasse>{
[corpo della classe]
}
public class Veicoli {
//istruzioni
}

17. Oggetto
 È rappresentato dall’istanza (creazione effettiva) di una classe
 Una classe è statica quando non ha bisogno di essere istanziata per essere usata, ma
generalmente una classe descrive la struttura di un insieme di proprietà valide per
rappresentare più volte lo stesso tipo di oggetto. Essendo una classe un’astrazione di un
concetto è necessario creare un oggetto per rappresentare uno specifico concetto di quel
dominio di rappresentanza.
Esempio: la classe punto definisce le coordinate(x,y) di un punto su un piano cartesiano a 2
dimensioni. Ma per rappresentare un punto in particolare devo specificare le coordinate.
Quando creo un oggetto da una classe prendo la struttura della classe e la valorizzo.
L’istanziare una classe rappresenta l’atto di valorizzare una copia della classe.
 Posso avere infiniti oggetti di quella classe

18. Membro
 Rappresenta una proprietà (variabile) o un comportamento (metodo) della
classe.
 Le proprietà possono essere di tipi primitivi o altri tipi di classe personalizzati,
immagazzinano principalmente informazioni, relazioni e risultati.
 I metodi rappresentano delle funzioni in grado di elaborare le informazioni,
possono o meno (void) ritornare dei valori, solitamente servono per estendere le
funzionalità di una classe, a volte possono avere in ingresso dei parametri.
 Alcune proprietà / metodi sono trattati indipendentemente dalla singola
rappresentazione della classe, pertanto si dicono statiche.
 La firma di un metodo (signature) è l’insieme del tipo di dato restituito e dei
tipi di parametro in ingresso, l’ordine è vincolante.

19. Variabile
[modificatori] tipo_di_variaible <NomeDellaVariabile> [= inizializzazione];
private String Targa;
private String Targa = "ZA 123 ZZ";
static int qta = 2;
Non è possibile definire una variabile fuori da una classe!

20. Metodo
[modificatori] [tipo di ritorno | void] <NomeDelMetodo>([parametri]*){
[corpo del metodo]
[return [valore | null ] ]
}
public String getModello(String targa) {
//istruzioni per la ricerca della targa e assegnazione modello
return modello;
}
Se si usa un Varargs va messo per forza come ultimo parametro

21. Costruttore
 Un costruttore è un particolare metodo che viene invocato automaticamente
alla creazione dell’oggetto.
 Deve chiamarsi obbligatoriamente come la classe
 Posso averne più di uno, sulla base dei parametri (e del tipo) passati ad esso.
 Se non dichiarato Java Compiler introduce il costruttore di default (o
costruttore vuoto) (vuoto e senza parametri).
 Se dichiaro almeno un costruttore Java NON inserirà il costruttore di default!

22. Costruttore
[modificatori] <NomeDellaClasse>([parametri]*){
[corpo del costruttore]
}
public Veicoli(String targa) {
//istruzioni
}
Un costruttore non torna mai alcun valore! È un errore dichiarare il ritorno void,
il ritorno NON DEVE essere dichiarato! Non può essere chiamato manualmente!

23. Package
 Raggruppamento logico delle classi, in contenitori e sotto contenitori
 È la prima riga da inserire in una classe
 Segue un raggruppamento per cartelle
 Se non specificato fa riferimento alla root dell’applicazione
 In caso di classi omonime si fa riferimento al nome assoluto dei package con il
percorso completo che identifica con certezza il riferimento a una classe di
un particolare package (nomeapp.nomepacchetto.nomefunzione.nomeclasse)
 Quando si importa tutto un package si importano solo le classi al suo livello,
non anche i sottopackage!

24. Scope
Lo scope rappresenta la visibilità di una variabile a livello di codice, può essere a
livello di statement { } , oppure a livello di metodo o di classe.
Una variabile a livello di statement e metodo non può avere modificatori (errore
di compilazione).
Una variabile d’istanza è una variabile definita al di fuori del metodo ma
all’interno della classe, essa esiste solo dopo essere istanziata.
Se una variabile d’istanza utilizza il modificatore static essa verrà condivisa tra
TUTTE le istanze della classe (esisterà anche senza un'istanza della classe).

25. Sintassi
Gli identificatori permettono di tenere traccia di un’informazione all’interno del
programma.
Il linguaggio Java è :
 case sensitive
 a schema libero (rientri e a capo non influenzano la struttura del codice)
 supporta i commenti
 definisce parole chiave
 Regolamentato per alcuni tipi di dato

26. Identificatori (Variabili)
Gli identificatori permettono di tenere traccia di un’informazione all’interno del
programma.
Una variabile può iniziare solo con lettere e al massimo il segno di underscore o
dollaro, numeri sono consenti ma non all’inizio e non sono ammessi caratteri
speciali.
È buona norma dare dei nomi di variabili sensati, intuitivi riguardo al loro
contenuto, solitamente si usano sostantivi. Nel caso di più parole usare la sintassi
camelCase. Esempi:
numeroDiLanci oppure pesoSoggetto oppure etaCandidato

27. Identificatori (Metodi)
Gli identificatori permettono di tenere traccia di un comportamento all’interno
del programma.
Un metodo può iniziare solo con lettere e al massimo il segno di underscore o
dollaro, numeri sono consenti ma non all’inizio e non sono ammessi caratteri
speciali.
È buona norma dare dei nomi di metodo sensati, intuitivi riguardo all’azione che
svolgerà, solitamente si usano dei verbi. Nel caso di più parole usare la sintassi
camelCase. Esempi:
stampaNumeroDiLanci oppure getPesoSoggetto oppure
resettaEtaCandidato

28. Identificatori (Costanti)
Gli identificatori permettono di tenere traccia di un’informazione all’interno del
programma.
Una costante può iniziare solo con lettere e al massimo il segno di underscore o
dollaro, numeri sono consenti ma non all’inizio e non sono ammessi caratteri
speciali.
È buona norma dare dei nomi di costante sensati, intuitivi riguardo all’azione che
svolgerà, solitamente si usano dei sostantivi e si scrivono tutte in maiuscolo. Nel
caso di più parole usare underscore per unire le parole. Esempi:
NUMERO_DI_LANCI oppure PESO_SOGGETTO

29. Tipi di dati PRIMITIVI
Java definisce 8 tipi di dati primitivi:
 Interi: byte, short, int, long
 Virgola mobile: float, double
 Testuale: char
 Logico: boolean
In java NON esistono i tipi UNSIGNED ma si usa sempre il complemento a due.

30. Interi
Tipo N di byte Intervallo di rappresentazione
byte 1 Da -128 a +127 Da -2^7 a 2^7-1
short 2 Da -32768 a +32767 Da -2^15 a 2^15-1
int 4 Da -2147483648 a +2147483647 Da -2^31 a 2^31-1
long 8
Da -9223372036854775808 a
+9223372036854775807
Da -2^63 a 2^63-1
In java per ogni tipo numerico esiste la stessa quantità di numeri
positivi e negativi. Il numero 0 è considerato un numero
positivo.

31. Interi
Per memorizzare un numero intero si può scrivere con la notazione:
 Decimale: semplice numero
 Binaria: si antepone 0 b(o B) alla sequenza di 0 e 1 [0(b|B)](0|1)*
 Ottale: Numeri da 0 a 7, anteporre al numero uno 0. 0(0-7)*
 Esadecimale: numeri da 0 a 9, lettere da A ad F anteposti da 0x (o X) 0x25afc0
Nella scrittura dei numeri le lettere sono case in-sensitive. Se cerco di
memorizzare un numero in un tipo di cui eccede la grandezza ci sarà
un errore di COMPILAZIONE.

32. Problema
byte b1 = 127;
byte b2 = 128;
byte b3 = 80;
b3 = b3 * 2;
Quali righe daranno errore?
Ok
Errore
Ok
Errore, si eleva a int perché due di default è di tipo
int, un int non ci sta dentro a un byte

33. Promozione automatica
Nelle operazioni tra numeri il risultato è convertito nel tipo di più alto livello tra
gli operandi, se non specificato si sottintende essere int .
 Se uno degli operandi è di tipo double il risultato sarà un double
 Se il più grande è di tipo float il risultato sarà un float
 Se il più grande è di tipo long il risultato sarà un long
 In ogni altro caso il risultato sarà un int
La promozione automatica ad intero avviene prima che venga eseguita qualsiasi
operazione binaria.

34. Casting
L’operazione di casting permette una conversione di tipo, tra uno più ampio a
uno più stretto e viceversa. Il casting essendo controllato dall’operatore non
viene valutato in fase di compilazione ed è per questo che scrivere:
byte b = (byte) 128;
risulta corretto, ma evidentemente il risultato è errato!
Questo perché sarà convertito in -128 (la prima posizione in eccedenza ritorna ad
essere la prima posizione di partenza ammessa dal range del tipo, in questo caso
si parte da -128 a +127 pertanto 128 – (+127) = 1 in eccesso, la prima posizione
accettata da byte è -128)

35. Casting
Attenzione anche alle somme, lo stesso problema lo avremmo nel caso di:
int a = 2147483647; int b = 1; int ris = a+b;
Si ottiene -2147483648! Ovvero il primo numero del range degli int.
Risulta perfettamente lecita la scrittura:
long num1 = 2000;
Anche se sta’ tentando di inserire un int dentro a un long, avviene una
promozione automatica di tipo. Se cerchiamo di inserire un numero superiore ad
un int dentro a un long saremmo obbligati a posporlo con una l o (L).
Es: long num2 = 3000000000L; altrimenti errore di compilazione!

36. Virgola mobile
Tipo N di byte Intervallo di rappresentazione
float 32 Da +/- 1.40239846^-45 a +/- 3.40282347^38
double 64 Da +/- 4.94065645841246544^-324 a +/- 1.79769313486231570^328
Seguono lo standard IEEE-754, il tipo di default è il double, in caso
di casting a float è possibile farlo inserendo f (oF) alla fine della
dichiarazione.
float f = 3.14; //Errore il compilatore prova a inserire un double
in un float
float f = 3.14f; //ok
double = 1.26E-2; //ok equivale 1.26^-2D ovvero a 0.0126

37. Classi Wrapper
Esistono in java operazioni che possono dare risultati inattesi e non definibili dai
numeri primitivi (+/- infinito, NotANumber ecc…). Per questo ci vengono in aiuto
le classi Wrapper (scritte con lo stesso nome ma iniziale maiuscola). Java
converte automaticamente i tipi nelle corrispettive classi wrapper e viceversa
quando ne ha bisogno, questo meccanismo si chiama: autoboxing-autounboxing.
Classi wrapper:
Byte, Short, Integer, Long, Float, Double, Char, Boolean

38. Classi Wrapper
Le classi wrapper al loro interno contengono delle costanti, ovvero delle variabili
che, dopo essere state valorizzate, non possono cambiare il loro valore.
 Le classi wrapper di Double e Float contengono
 Float.NaN Double.NaN
 Float.NEGATIVE_INFINITY Double.NEGATIVE_INFINITY
 Float.POSITIVE_INFINITY Double.POSITIVE_INFINITY
 Tali costanti sono definite come:
 final (non modificabili dopo essere valorizzate)
 static (condivise tra tutte le istanze, variabile di classe)

39. Dati numerici
Per migliorare la leggibilità di dati numerici si può inserire il simbolo di
underscore tra i caratteri che lo compongono ma solo all’interno, in particolare
non può essere usato:
1. All’inizio o alla fine
2. Vicino ad un punto decimale (prima o dopo)
3. Prima dei suffissi F o L o D;
4. In tutte le posizioni in cui si aspetta una stringa di carattere

40. Dati numerici
Float f = 3.14_15F;
int x = 5_2;
Long n1 = 0x34_AD_CF;
Integer n2 = 123_456;
NON VALIDI
Float pil = 3_.1415F; //viola2
Float pil2 = 3._1415f; //viola2
Long pil3 = 99_99_99_L;//viola3
int x = 0_x52; int x = _0x52; int x = 0x_52; int x = 0x52_;

41. Dato logico - booleano
Un dato logico rappresenta un valore di verità che può assumere solo due valori,
true o false. Per questo occupa solo 1 bit.
Una variabile boolean può assumere solo true o false, non sono ammessi valori
numerici durante l’assegnazione.
Se mai istanziata si avrà un errore di compilazione(nel codice locale) mentre
varrà false se è dichiarata di classe/istanza.
boolean b = [true|false];

42. Literals
I literals rappresentano valori che vengono specificati direttamente nel codice
sorgente, quindi non referenziati da una variabile. Possono contenere tipi
primitivi o stringhe e possono comparire a destra del segno di assegnazione o
uguaglianza.
int x = 5; // 5 è un literals
String posizione = "alto"; //alto è un literals
int i = 0x1c;
NON è possibile assegnare un valore ai literals!
"sono un literals" = 3; //Errore di compilazione

43. Dato letterale
Permette di immagazzinare un carattere per volta in formato UNICODE (versione
6.2) in tre forme:
UTF-8: a 8 bit e coincide con la codifica ASCII.
UTF-16: a 16bit, come il char, contiene tutti i caratteri più diffusi
UTF-32: la più estesa, java lo considera come 2 char concatenati
Possiamo assegnare a un char un qualunque carattere da tastiera o con la
notazione Unicode anteponendo u davanti al codice Unicode. In tutti i casi il
valore va inserito tra singoli apici ( ' ). Es:
char c1 = 'A'; char c2= 'u03A9'; //Ω

44. Dato letterale
È anche possibile accettare caratteri speciali e sommare i char con un int! ( il
cast è obbligatorio altrimenti sarebbe un intero) es:
Char a = 'A'; char b = (char) (a+1); //equivale a 'B'
Caratteri speciali:
n = ritorno a capo
= rappresenta il backslash
t = equivale a un Tab
' = equivale un apice
" = equivale al doppio apice

45. Tipi non primitivi: reference
Reference = nome che diamo a un oggetto, rappresenta un puntatore.
Con la parola chiave new si crea una nuova istanza, ovvero un puntamento a
indirizzo di memoria che conterrà una copia di una classe, richiamabile col nome
di variabile scelto.
C'è una differenza tra un dato
primitivo (direttamente il
valore) e una referenza
(insieme di valori/informazioni
in memoria)

46. Reference
Attenzione a copiare i tipi reference, non si copia il contenuto ma si copia il
puntatore. Con la semplice copia avremmo quindi due puntatori diversi per la stessa
cella di memoria.

47. Reference

48. Reference Copia

49. Shallow Copy

50. Passaggio di parametri
In Java il passaggio di parametri avviene sempre per valore ! Si crea una copia
del valore e la si passa in ingresso al metodo.
Anche la referenza di memoria di un oggetto è un valore, per i tipi primitivi
invece è il dato stesso.
Quindi se un metodo che lavora su un
oggetto ne modifica le sue proprietà
tali modifiche saranno disponibili
anche all'esterno di tale metodo.
Viene passata una copia della referenza ma per via della copia superficiale
puntano entrambi allo stesso spazio di memoria

51. Valori di default
Tipo Valore
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char 'u0000' (NULL)
boolean false
Reference (Object, Class) null
Quando si istanzia un oggetto vengono istanziate anche le sue
variabili di classe che se mai inizializzate assumono i seguenti
valori di default:

52. Riassumendo

53. Libreria standard
Java possiede una corposa libreria di classi standard ben organizzata, in package,
suddivisi a seconda dell'utilizzo:
 java.io = classi per gestire input e output
 java.awt = classi per realizzare interfacce grafiche
 java.net = classi per gestire la comunicazione di rete
 java.applet = unica classe per realizzare applet
 java.util = classi di utilità, come Date
 java.lang = libreria cuore del linguaggio, contiene System e String (importata
automaticamente dal compilatore)

54. Import
Il comando di import ci permette di importare una o più librerie all'interno della nostra
classe. Una volta importata una libreria sono rese utilizzabili le classi al suo interno
senza più specificare il package di derivazione (nome canonico o assoluto). Es:
import java.util.Date; //importa la classe Date
Import java.util.*; //importa tutte le Classi a livello di util
//le classi dei sotto-package saranno escluse!
In caso di import statici verranno importate le sole componenti statiche di una classe
(metodi, proprietà statiche, costanti).
import static java.lang.Math.*; //ok, mai invertire static import
//pena errore di compilazione
Gli import vanno sempre dichiarati in testa a una classe, dopo la dichiarazione
del package (per forza come principale, se omesso sarà dedotto dal compilatore)

55. import static
Usato per importare solo le componenti statiche di una classe, metodi e variabili
(anche costanti).
Se importate con static la classe non potrà essere istanziata, dovrete importarla
anche come non static. Es:
Import static java.lang.Math.*;
Import static java.lang.Math.PI;

56. Inizializzatori (statici e d'istanza)
 Blocchi di codice da eseguire:
 Al caricamento della classe in memoria (e quindi statici con static{} )
 Al momento di istanziare un oggetto (d'istanza, basta inserire all'interno della
classe uno o più blocchi di codice tra le {} )
 Vengono eseguiti dall'alto al basso e a seconda del contesto possono usare le
variabili fino ad allora dichiarate.

57. Classe String
In java le stringhe non sono degli array di caratteri, ma veri e propri oggetti
"speciali" che il compilatore istanzia per noi (sostituisce con il costruttore prima
di compilare), questo perché le tratta come "primitive".
String nome = "Valerio"; => String nome = new String("Valerio");
Il fatto che String sia una classe ci permette di usare dei metodi sempre a
disposizione come i classici toUpperCase(); toLowerCase(); length(); trim();
TUTTE LE STRINGHE SONO IMMUTABILI, non è possibile, sullo stesso oggetto,
cambiare il contenuto o modificarlo, possiamo riassegnare una nuova referenza,
in tal caso l'oggetto precedente se non più referenziato sarà reso eliminabile dal
GarbageCollector.
nome.toUpperCase(); //ritorna una nuova stringa, non modifica MAI se stessa

58. Problema
Cosa succede se cerchiamo di fare i seguenti confronti?
String nome = "Valerio";
if (nome==("Vale"+"rio")){…}else{…}
Il risultato è false! Stiamo confrontando un oggetto (indirizzo di
memoria) con un literals!
String nome2 = "Vale"+"rio";
if (nome==nome2){…}else{…}
Il risultato è false! Stiamo confrontando un oggetto (indirizzo di
memoria) con un altro oggetto (indirizzo di memoria), soluzione
if (nome.equals("Valerio")){…}else{…}

59. Array
 Un array è una collezione indicizzata che ci permette di tenere traccia
di un insieme di dati, sia primitivi che reference, o di altri array.
 Per usare un array bisogna:
 Dichiararlo //char room [];
 Creazione //room = new char[3];
 Inizializzazione //room[0] = 'k'; room[1] = 'y'; room[2] = 'z';
 Nota: gli indici partono sempre da 0!

60. Array
//Dichiarazione
char room [];
char room1[];
char[] rooms;
char [] rooms1;
//Creazione
room = new char [2];
room1 = new char[2];
//Inizializzazione
room[0] = 'k';
room1 [1] = 'Y';
//Contrazione
char room9 [] = {'k','Y','z'};
char room8[] = {'k','Y','z'};
char [] room7 = {'k','Y','z'};
char[] room6 = {'k','Y','z'};
int qta = room.length; //è una proprietà! Non un metodo!

61. Array multidimensionali
 Un array multidimensionale, o matrice,
è un array di array.
 Valgono le stesse regole dichiarative
degli array
int matrix [][] = new int[3][];
matrix [0] = new int[5];
matrix [1] = new int[2];
matrix [2] = new int[6];
matrix[0][0] = 8;
matrix[0][1] = 5;
// ...
matrix[1][0] = 52;
matrix[1][1] = 49;
matrix[2][0] = 128;
matrix[2][1] = 256;
// ...
//forma contratta
int matrix2 [][] = {
{8,5,3,4,5},
{52,49},
{128,256,512,1024,2048,4096}
};

62. Args
 Nella creazione di un programma il metodo main vuole obbligatoriamente in
ingresso un parametro di tipo String[] chiamato solitamente args, che
contiene l'elenco dei parametri con il quale il comando java è stato lanciato.
Es:
 Dato hello.java
 public static void main(String[] args) {…}
 java hello Valerio Radice
 Conterrà in posizione 0 la stringa Valerio (args[0])
 Conterrà in posizione 1 la stringa Radice (args[1])

63. Ereditarietà
Altro pilastro cardine della OOP è l'ereditarietà,
anch'essa ispirata alla realtà, pensate alla relazione tra
Animali, Cane e Gatto.
Già la nostra mente classifica tutto con classi e
sottoclassi senza volerlo, cerchiamo raggruppamenti
logici sulla base di fattori comuni per poi creare delle
specializzazioni.
In Java l'ereditarietà è la caratteristica che mette in
relazione (di estendibilità) più classi che hanno
caratteristiche comuni.

64. extends
Quando la rappresentazione della realtà è tale da trovare correlazioni tra le classi in una
relazione di tipo padre-figlio si dice che il figlio è sottoclasse di padre. Padre è
superclasse di figlio.
La classe figlio è derivata, può appartenere allo stesso package o ad altri package.
Per creare una classe figlia bisogna estendere ( extends ) la classe padre.
class Animale{
//Proprietà di
//tutti gli
// animali
}
class Mammifero extends Animale{}
class Cane extends Mammifero{}
class Gatto extends Mammifero{}
class Cavallo extends Mammifero{}
class CavalloDiRazza extends Cavallo{}
class CavalloDaCorsa extends Cavallo{}
class Pesce extends Animale{}
class PesceRosso extends Pesce{}

65. Generalizzazione e specializzazione
Sono due termini che contribuiscono a definire l'ereditarietà. Grazie ad essi si
definiscono le strutture delle classi e delle sottoclassi.
Si parla di generalizzazione quando a partire da un pool di classi comuni si
contribuisce a raccogliere le caratteristiche comuni in una superclasse.
Viceversa si parla di specializzazione quando a partire da una classe comune se
ne derivano altre atte a specificare il comportamento dell'oggetto.

66. Ereditarietà multipla
Questo meccanismo simulato è permesso grazie all'implementazione di più
interfacce. Nel caso di funzionalità differenti non ci sono problemi, ma cosa
succede se una classe dovesse implementare più interfacce che contengono lo
stesso metodo e con la stessa firma?
Il compilatore non saprebbe quale usare, l'unica soluzione possibile è quella di
ridefinire il comportamento di default, nella classe che implementa le interfacce
(vedi Diamond Problem).
In caso di conflitti generati da avere lo stesso metodo astratto nella classe che
implementa lo stesso metodo come default il risultato è che la classe sovrascrive
l'implementazione dell'interfaccia con la sua astratta: class always win.

67. Polimorfismo
Il polimorfismo è un concetto della realtà, che ben si addice alla OOP, importato nel
mondo della programmazione.
Può essere definito come la proprietà di un oggetto di adattarsi a forme differenti.
Esistono diverse forme di polimorfismo:
per metodi
Override
Overload
per dati
Collezioni polimorfe
Parametri polimorfi
Metodi virtuali

68. Parametri polimorfi
In java il passaggio di parametri avviene sempre per valore, in pratica si passa
l'indirizzo di memoria. È quindi possibile passare a un parametro un tipo che sia
sottoclasse di quello richiesto.
In realtà tutti i parametri di tipo reference sono polimorfi, derivando tutti da Object,
se come parametro accetto un Object posso avere qualsiasi parametro a scelta. Posono
anche essere interfacce o classi astratte.
public void getInfo(Persona p){
//TODO...
}
System.out.println(persona.getInfo(new Giocatore("Scacchi")));

69. Esercizio
Trovare, tra le classi di Java, esempi di overload
Lo stesso metodo println() usato fino ad ora accetta differenti tipi in
ingresso

70. Esercizi / Domande
 Stampare a console con il comando System.out.println(); tutti i dati primitivi
e tutte le classi Wrapper, gli Array.
 Creare una classe semplice con tante variabili quante sono i tipi primitivi e
wrapper, stamparli sia con che senza instanziazione.
 Generare un oggetto personalizzato di tipo "Auto" con proprietà come targa,
telaio, alimentazione, venduta si/no, e un elenco di proprietari (String).
 Creare un array di numeri casuali, invertirli, riordinarli

71. Test
//int a = 128;
//byte b = (byte) a;
boolean flag = ( ( a != 0) && ( b/a > -10 ) );
boolean flag1 = ( a != 0) || ( b/a > 10 );
boolean flag2 = ( a != 0) & ( b/a > 10 );

72. Domande
Elenca i tipi primitivi.
Quali sono gli argomenti obbligatori per un ciclo for?
Cosa non si può fare con il ciclo for migliorato
Come si dichiarano e usano gli array?