Java SE 5. Capitolo 01: Base

Java Base 1bobpuley@gmail.com
Introduzione a Java

Sommario
1. Cos'è java
2. Java tools
3. Parole riservate (keywords)
4. OO e java
5. Classi e oggetti
6. Fields, metodi e costruttori
7. Le interfacce
8. Le eccezioni

Cos'è Java?
● Linguaggio di programmazione
● Ambiente di sviluppo
● Ambiente applicativo
● Fasi di sviluppo
● La JVM
● Il Garbage Collector

Cos'è Java?
Linguaggio di programmazione
● Semi-compilato
● Interpretato
● Orientato agli oggetti
● Multi-piattaforma
● Fortemente tipizzato
● Robusto (errori di compilazione)

Cos'è Java?
Ambiente di sviluppo
● Come ambiente di sviluppo, Java offre una serie di tool
invocabili a linea di comando per effettuare le principali
operazioni
– Un compilatore (javac)
– Un interprete (java)
– Un generatore di documentazione (javadoc)
– Un tool per il packaging delle classi java (jar)
– ...

Cos'è Java?
Ambiente applicativo
● Il Java Runtime Environment (Jre) è l'ambiente applicativo
dei programmi java sul sistema operativo
● La jre comprende le librerie fondamentali di java che
consentono di sviluppare le più svariate applicazioni
(streaming, console app, GUI, networking, Xml
manipulation, etc...)
● La jre è anche supportata (come ambiente di esecuzione)
dai principali browser per pc.
● Un subset della jre (la J2me) consente anche di sviluppare
applicazione per dispositivi mobile.

Cos'è Java?
Fasi di sviluppo

Cos'è Java?
La JVM
● La Java Virtual Machine (JVM)
– è l'intermediario tra il software scritto in java da eseguire e la
macchina fisica sul quale deve essere eseguito.
● ByteCode
– Ogni programma java, in fase di compilazione, viene trasformato in
un linguaggio (bytecode) che può essere letto ed eseguito dalla JVM
indipendentemente dalla piattaforma di esecuzione e compilazione

Cos'è Java?
Il Garbage Collector
● Il Garbage Collection thread
– è un processo a bassa priorità che si occupa di liberare la memoria
degli oggetti non più utilizzati o utilizzabili dall'applicazione (variabili
al di fuori dello scope per esempio)

Java Tools
● Java
– è un tool fornito con la jdk e la jre per lanciare le applicazioni java
– Si può usare da linea di comando
– Accetta diversi parametri per configurare l'esecuzione del codice
– Accetta un numero arbitrario di argomenti che vengono inoltrati alla classe
main dell'applicazione
● Javac
– è un tool fornito con la jdk per compilare sorgenti java
– Si può usare da linea di comando
– Accetta diversi parametri per configurare la compilazione del codice
● Javadoc
– è un tool fornito con la jdk per la generazione di documentazione a partire
dai commenti presenti nel codice.

Java Tools
java
● Java: java [ options ] class [ argument ... ]
– Options
● -classpath : include classi o librerie nell classpath d'esecuzione
● -cp : shorcut per -classpath
● -jar : specifica che si vuole eseguire una classe contenuta in un archivio
● -version : stampa a video la versione della jre in esecuzione
● -help : restituisce l'elenco delle opzioni
● -? : shortcut per -help
● -Xms : imposta la dimensione iniziale della memoria dedicata
● -Xmx : imposta la dimensione massima della memoria dedicata
Approfondimenti

Java Tools
javac
● Javac: javac [ options ] sourceFiles
– Options
● -classpath : include classi o librerie nel classpath per la compilazione
● -d : specifica la cartella nella quale verranno inseriti i files compilati
● -source : specifica per quale versione dlla jre si sta compilando
Approfondimenti

Java Tools
javadoc
● Javadoc: javadoc [ options ] [ packagenames ]
[ sourcefilenames ] [ -subpackages pkg1:pkg2:... ]
[ @argfiles ]
– Options
● -d : specifica la cartella nella quale verranno inseriti i files compilati
● -public : documenta solo classi e membri pubblici
● -protected (default): documenta solo classi e membri protected e
public.
● -package : documenta solo classi e membri package, protected, e
public.
● -private : documenta solo classi e membri tutte le classi e i membri
Approfondimenti

Parole riservate

OO e Java
● Ereditarietà
● Overloading
● Overriding
● Polimorfismo
● Incapsulamento

OO e Java
Ereditarietà
● Per ereditarietà si intende la capacità di un programma
(classe) di essere definito come specializzazione di un altro
programma (classe)
● In java questo si ottiene in fase di definizione di una classe
attraverso la keyword extends:
– class Cane extends Animale{}
● Dire che Cane estende Animale implica che la classe Cane
(sotto-classe) acquisisce automaticamente tutte le proprietà
(attributi d'istanza) e i comportamenti (metodi della classe)
della classe Animale (super-classe)

OO e Java
Overloading (dei metodi)
● L'overloading è un concetto che si applica esclusivamente ai
metodi
● Consente di definire più metodi, nella stessa classe, con il
medesimo nome e tipo restituito ma diversi parametri (per tipo
o numero):
– void stampa(int eta)
– void stampa(String nome)
– void stampa(Sting nome, int eta)
● Il runtime environment invocherà quello giusto a seconda dei
parametri passati:
– istanza.stampa(12);
– istanza.stampa(“gigi”, 12);

OO e Java
Overriding (dei metodi)
● L'overriding è un concetto che si applica esclusivamente ai
metodi e riguarda i metodi ereditati dalla super classe
● Consente di ridefinire il comportamento dei metodi della super
classe:
class Animale{
public int getNumeroGambe(){
return 0;
}
}
class Cane extends Animale{
return 4;
}
}

OO e Java
polimorfismo
● Il polimorfismo è la capacità del runtime environment di
scegliere il metodo corretto nella gerarchia delle classi,
tenendo conto dell'overriding
Animale a = new Animale();
Animale b = new Cane();
Cane c = new Cane();
a.getNumeroGambe();//0
b.getNumeroGambe();//4
c.getNumeroGambe();//4

OO e Java
incapsulamento
● Il concetto di incaspulation viene implementato in java
attraverso i modificatori (keywords) di visibilità:
– private (visibile solo dalla classe stessa)
– default (visibile solo dalle classi dello stesso package)
– protected (visibile dalla classe e dalle sue sottoclassi)
– public

Classi e oggetti
● Occorre distinguere chiaramente il significato di classe da
quello di oggetto (istanza)
● La classe si può definire come il progetto o struttura di un
oggetto
● L'istanza è un oggetto reale pronto all'uso:
class Animale{
return 0;
}
}
Animale a = new Animale();

Classi e oggetti
Definizione di una classe
● Lo schema generale della definizione di una classe è il
seguente:
– [modificatore di visibilità] [altri modificatori] class nomeClasse [extends
nomeClasse] [implements nomeInterfaccia[,nomeinterfaccia]]{}
class Animale{}
public class Animale{}
public final class Animale{}
public abstract class Animale{}
public class Animale extends EssereVivente implements
EssereMobile, EssereMortale {}

Classi e oggetti
tipi di classe
● Le classi java possono essere raggruppate a seconda di
diversi criteri:
– Sulla base di come e dove vengono dichiarate
● Classi standard (class)
● Classi annidate (innerclass)
● Classi anonime (anonymous class)
– Sulla base delle loro visibiltà
● Classi pubbliche
● Classi package
● Classi protette
● Classi private
– Sulla base della loro comportamento specifico
● Classi astratte
● Classi final...

Classi e oggetti
classi standard
● Una classe standard è una classe definita:
– In un file di testo con estensione java che
● ha lo stesso nome della classe (key-sensitive)
● Si trova (path relativo dei sorgenti) nel path corrispondente al package della classe
● <sorgenti>/mio/package/Animale.java
package mio.package;
class Animale{
return 0;
}
}

Classi e oggetti
classi annidate
● Una inner class è una classe definita all'interno di un'altra
classe:
package mio.package;
class Veicolo{
public Motore getMotore(){
return 0;
}
public class Motore{
public int getVelicitaMassima(){
return 100;
}
}
}

Classi e oggetti
classi anonime
● Una classe anonima è una classe che viene ridefinità a
runtime
public Animale getAnimale(){
return new Animale(){
return 2;
}
};
}

Classi e oggetti
modificatori di visibilità delle classi
● Alcune delle keywords java possono essere utilizzate per
limitare la visibilità delle classi
– private (solo inner classes)
– default (se viene omesso il modificatore)
– protected (solo inner class)
– public
private class Animale{}
protected class Animale{}
class Animale{}
public class Animale{}

Classi e oggetti
altri modificatori delle classi
● Con l'ausilio di alcuni altri modificatori si possono definire altri
comportamenti specifici della classe
– Classi abstract (non si possono creare istanze direttamente da queste
classi)
– Classi final (non è possibile estendere queste classi)
– Classi statiche (per le inner classes consente l'accesso e l'utilizzo da
parte di altre classi conformemente ai modificatori di visibilità applicati)
class Veicolo{
public static class Motore{
}
}
Veicolo.Motore motore = new Veicolo.Motore();

Fields, metodi e costruttori
● Le fields sono le proprietà o attributi di una classe, volendo li
si può intendere come lo stato di un'istanza
● I metodi sono i comportamenti o responsabilità di una
determinata classe
● I costruttori sono dei metodi speciali per inizializzare l'oggetto
abstract class Animale{
private int numeroGambe;
public Animale(int numeroGambe){
this.numeroGambe = numeroGambe;
}
return numeroGambe;
}
}

d'istanza o di classe?
● Le fields e i metodi possono essere d'istanza o di classe
– Membri di classe
● Hanno il modificatore static
● Vi si può accedere senza creare un'istanza della classe
● Nel caso delle fields, il loro valore è condiviso da tutte le istanze della classe
– Membri di istanza
● Non hanno il modificatore static
● Per accedervi occorre un'istanza reale della classe
● Nel caso delle fields, il valore è incapsulato e indipendente in ciascuna istanza

le fields
● Le fields possono essere dichiarate in qualunque punto del
body della classe
● Le dichiarazioni delle fields devono rispettare la seguente
forma generale
– [modificatore di visibilità] [altri modificatori] tipo nomeField [= initialValue];
● Il modificatore di visibilità non ha restrizioni d'uso e il suo
significato rispecchia esattamente quello dell' OO
● I restanti modificatori implicano dei comportamenti particolari
● Il tipo deve essere una classe java accessibile da quella
corrente
● Il valore iniziale può essere la keyword null

le fields – il modificatore static
● Il modificatore static rende la field di classe.
– Questo significa che sarà possibile accedere al suo valore senza
creare un'istanza della classe (es File.PATH_SEPARATOR)
– Implica anche che ciascuna istanza della classe condividerà il valore di
quella field, se una delle istanze la modificasse, allora tutte le altre
istanze vedranno anch'esse il valore modificato

le fields – il modificatore transient
● Il modificatore transient serve solo in casi particolari e solo in
classi che implementino l'interfaccia serializable
● Indica al runtime environment che, in caso di serializzazione
dell'istanza (persistenza dello stato su filesystem), la field
transient non deve essere processata

le fields – la keyword reference this
● this è un reference fornito di default dall'ambiente java per
offrire maggiore libertà nella scelta dei nomi di variabili,
parametri e fields, eliminando le ambiguità ove si
presentassero
● Un esempio può chiarire il problema e la soluzione con this
abstract class Animale{
private int numeroGambe;
public Animale(int numeroGambe){
this.numeroGambe = numeroGambe;
}
return numeroGambe;
}
}

i metodi
● I metodi rappresentano, dal punto di vista della modellazione,
le responsabilità di una classe
● Lo schema generale di un metodo è:
– [modificatore di visibilità] [altri modificatori] tipoRestituito
nomeMetodo( [ paramenterType parameterName[ , paramenterType
parameterName]*]) [throws exceptionName[, exceptionName]*]{}
● I modificatori di visibilità sono tutti validi e rispecchiano il
significato già discusso
● I restanti modificatori implicano comportamenti particolari del
metodo
● Il tipo restituito deve essere unico ed un tipo java valido
● I parametri 0 o molti

i metodi – il modificatore abstract
● Questo modificatore può essere usato solo da classi a loro
volta abstract
● Comunica al compilatore che di questo metodo fornisce una
definizione, ma non l'implementazione
– Per questa ragione la classe che lo contiene deve essere
abstract
● Impedire di creare un'istanza che contiene metodi non
definiti
● Obbligare le classi concrete che la estendono a fornire
un'implementazione di quel metodo

i metodi – il modificatore static
● Questo modificatore rende il metodo di classe
● Sarà quindi possibile invocare il metodo senza creare
un'istanza della classe che lo contiene (es.
Collections.sort(List list); )
● I metodi statici impongono però una limitazione
– Non è possibile fare l'overriding di un metodo statico
● D'alta pare questo è ovvio se si pensa che un metodo statico
non può usufruire del polimorfismo che si applica solo ad
istanze e non a classi

i metodi – i modificatori final, native, synch
● Il modificatore final impedisce alle eventuali sottoclassi di
effettuare l'overriding del metodo
● Il modificatore native si applica ai metodi che accedono a
librerie native (del sistema operativo come le dll di windows)
● Il modificatore synchronized si applica a metodi che sono
progettati per operare in ambiente multi-threading, e per i quali
si vuole garantire l'accesso sequenziale

i costruttori
● I costruttori servono ad inizializzare una classe
● La dichiarazione di un costruttore deve rispettare la sintassi:
– [modificatore di visibilità] nomeClasse( [ paramenterType parameterName[ ,
paramenterType parameterName]*]) [throws exceptionName[,
exceptionName]*]{}
● Qualunque modificatore di visibilità è valido e rispecchia il
significato già visto nell'OO
● Il nome del costruttore deve sempre essere uguale al nopme
della classe
● Può avere parametri
● Può lanciare un'eccezione

i costruttori (continua)
● I costruttori possono essere visti come particolari metodi,
salvo alcune differenze
– Funzione: un costruttore si occupa di inizializzare correttamente
un'istanza prima che questa sia fruibile dal client ( i metodi, a
parte quelli statici, vengono invocati sull'istanza già creata)
– Accesso (invocazione): un costruttore viene invocato attraverso
la keyword new e restituisce sempre un reference all'oggetto
stesso.
– Return type: i costruttori non dichiarano alcun return type
– Accesso alle costanti: il costruttore è l'unico punto, a parte la
dichiarazione, ove sia possibile inizializzare una field final.
– Ereditarietà: i costruttori non vengono ereditati

i costruttori – this e super
● Anche per il costruttore valgono le regole generali di
overloading
● È possibile fare riferimento ai costruttori della super-classe
con la keyword super; deve essere la prima chiamata.
● È possibile fare riferimento ai costruttori overloaded con la
keyword this; deve essere la prima chiamata.
class Cane extends Animale{
public Cane(int numeroGambe){
super(numeroGambe);
...
}
public Cane(String name, int numeroGambe){
this(numeroGambe);
...
}
}

Le interfacce
● Le interfacce assomigliano alle classi ma realizzano
un'astrazione maggiore e differisco anche per alcuni dettagli
● La differenza più evidente è che un'interfaccia può dichiarare
solo metodi astratti e fields final. Questo ha alcune
implicazioni, un metodo di un'interfaccia:
– non può essere private
– non può essere final
– non può essere static
● Un 'interfaccia serve a definire quindi dei comportamenti/
responsabilità senza specificare l'implementazione. SI può
dire che definiscano delle abilità, infatti spesso il nome
suggerisce questa idea (Serializable, Comparable, etc...)

Le interfacce
interfacce, ereditarietà multipla e java
● Se si considera che java vincola la definizione di una classe a
specificare al massimo una parent class, si può intuire perché
le interfacce siano utili per realizzare gerarchie più flessibili.
● Un 'interfaccia ha anche la funzione standard di best practice
nella modellazione di applicazioni, in particolare per realizzare
un buon disaccoppiamento tra i vari moduli applicativi e
riutilizzo.

Le eccezioni
● Le eccezioni e la loro gestione rappresentano un altro dei
concetti chiave di java
● Servono a gestire le situazioni impreviste, che, in qualche
modo, impedirebbero di proseguire l'esecuzione del
programma
● Si possono dividere in due categorie principali
– Checked: le eccezioni dichiarate nella signature di un
metodo (previste e presumibilmente gestibili)
– Unchecked: le eccezioni non dichiarate nella signature di
un metodo (impreviste e probabilmente bloccanti)

Le eccezioni
propagazione
● All'interno di un metodo o di un costruttore, è possibile
propagare un'eccezione ovvero interrompere l'esecuzione del
metodo corrente, comunicando al chiamante una certa
eccezione.
● La propagazione di un'eccezione si realizza attraverso la
keyword throw
public String getString() throws Exception{
if(condizione){
throw new Exception(“condizione violata”);
}
}

Le eccezioni
gestione
● All'interno di un blocco di codice, è possibile invocare metodi
che possono propagare eccezioni.
● Si può continuare la propagazione con la keyword throws
applicata al metodo in cui si richiama il codice checked
public InputStream getString(String url) throws
IOException{
return new URL(url).openStream();
}

Le eccezioni
gestione – clausola try
● Si può gestire l'eccezione con la struttura try {} catch {} finally{}
● Il codice incluso nel blocco try è soggetto al controllo delle
eccezioni
● Se si verifica un errore, viene invocata il corrispondente
blocco catch
public InputStream getString(String url) throws
MiaException{
try{
}catch(IOException e){
}finally{
}
}

Le eccezioni
gestione – clausola catch
● La clausola catch può comparire una o più volte
● Le eccezioni in catch devono essere in ordine di
generalizzazione (dai childs verso i parents)
try{
}catch(Exception e){
}

Le eccezioni
gestione – clausola finally
● La clausola finally indica un blocco di codice che deve sempre
essere eseguito
try{
fis = new FileInputStream(“c:prova.txt”);
}catch(FileNotfoundException e){
}finally{
if(fis != null)fis.close();
}

Le eccezioni
gerarchia

Java SE 5. Capitolo 01: Base

Recommended

Recommended

More Related Content

What's hot

What's hot (14)

Similar to Java SE 5. Capitolo 01: Base

Similar to Java SE 5. Capitolo 01: Base (20)

Java SE 5. Capitolo 01: Base