Programmazione ad oggetti

DAIS – Univ. Ca' Foscari Venezia
Programmazione
ad oggetti
Samuel Rota Bulò
Informazioni generali
●
Docente:
Samuel Rota Bulò
●
@email:
[email protected]
●
Homepage:
http://www.dais.unive.it/~srotabul/
ooprogramming2012.html
●
Ricevimento:
da concordare previa email
●
Durata:
30 ore
●
Lezioni:
mercoledì 18:15 - 19:45
sabato
08:45 – 10:15
●
Esame:
scritto + laboratorio + progetto
Libro di testo
Il linguaggio
JAVA
Un po' di storia
●
●
●
●
●
●
●
●
●
●
●
1991: nasce alla Sun Microsystems con il nome “green” per
utilizzarlo in elettrodomestici.
1994: l'ideatore di “green” si rende conto che il nuovo
linguaggio poteva avere grosse potenzialità per applicazioni
client/server.
1995: nasce ufficialmente Java
1996: v1.0
1997: v1.1, classi innestate
1998: v1.2, swing e collections
2000: v1.3, miglioramento delle prestazioni
2002: v1.4, asserzioni, XML
2004: v5.0, classi generiche, estensione ciclo for, autoincapsulamento, enumerazioni
2006: v6.0, miglioramento della libreria
2010: v7.0, piccole modifiche al linguaggio e miglioramento
libreria
Caratteristiche di Java
●
●
●
●
●
●
●
Alto livello: assenza di puntatori e gestione esplicita
della memoria
Imperativo: sequenza di istruzioni che modificano la
memoria
Ad oggetti: ogni cosa in Java è un oggetto (salvo
piccole eccezioni)
Portabile: bytecode eseguibile su Java Virtual Machine
(JVM)
Fortemente tipato: controllo forte dei tipi da parte
del compilatore
Sicuro: progettato per eseguire codice remotamente in
modo sicuro
Vivo: in continua evoluzione
La piattaforma Java
Dal sorgente all'esecuzione
Macchina Hardware X
Sorgente
programma
JAVA
Compilatore
JAVA
Bytecode
programma
JAVA
Macchina
Virtuale
JAVA
Bytecode
librerie
JAVA
Esecuzione
programma
Macchina Hardware Y
Java Virtual Machine (JVM)
●
Macchina astratta:
–
Esegue codice intermedio (bytecode)
–
Specifica indipendente dall'architettura sottostante
●
Indipendente del sistema operativo
●
Esistono diverse implementazioni
●
Componenti:
–
–
–
Class loader: carica in memoria le classi necessarie al
programma
Bytecode verifier: controlla l'integrità degli accessi in
memoria e l'aderenza alla specifica della JVM, ...
Security manager: verifica la sicurezza delle classi caricate
a runtime, controlla gli accessi ai file, ...
Interpreter
Class Loader
JVM
Bytecode verifier
Security manager
Hello world !
HelloWorld.java:
public class HelloWorld {
public static void main(String[] args){
//stampa in console un messaggio
System.out.println(“Hello, World !”);
}
}
●
●
●
Compilazione: javac HelloWorld
–
questo genera il bytecode HelloWorld.class
Esecuzione su JVM: java HelloWorld
Output: Hello, World!
Tipi e variabili
●
●
●
●
●
Ogni valore nel linguaggio ha un tipo
Il tipo identifica un insieme di valori e quali
operazioni sono legali sugli stessi.
Una variabile è una porzione di memoria del calcolatore
caratterizzata da un tipo, un nome e un valore
contenuto.
Una variabile di tipo X può assumere solo valori di
tipo X.
Una variabile viene dichiarata con:
nomeTipo nomeVariabile;
nomeTipo nomeVariabile = valore;
●
Esempi:
String greetings = “Hello, World!”;
PrintStream printer = System.out;
int width = 20;
L'operatore di assegnamento
●
●
Abbiamo visto che possiamo assegnare valori alle
variabili in fase di dichiarazione
Mediante l'operatore = possiamo assegnare un nuovo
valore ad una variabile
nomeVariabile = valore;
●
●
●
Una variabile non può essere utilizzata se non viene
prima assegnato un valore
Il valore può essere il risultato di un espressione.
Es:
int width = 10;
int height; height = 3;
width = height + 10; // width=13
height = height + 1; // height=4
Oggetti e classi
●
●
●
●
Una classe è la descrizione di una struttura dati
complessa caratterizzata principalmente da:
– campi: variabili che conterranno i dati
– metodi: operazioni che agiscono sui dati
Un oggetto è un'istanza di una certa classe, in cui i
campi assumono valori ed è manipolabile attraverso
l'invocazione dei metodi descritti nella classe.
La classe rappresenta il tipo di un oggetto.
In Java ogni cosa è un oggetto (salvo piccole
eccezioni).
Esempio di oggetti
●
●
●
Oggetti appartenenti alla stessa classe condividono gli
stessi nomi e gli stessi tipi per i propri campi e lo
stesso codice dei metodi.
Oggetti distinti, anche se appartenenti alla stessa
classe, occupano celle di memoria distinte per
memorizzare i valori dei propri campi.
Ogni oggetto ha una copia privata dei suoi campi.
String
String
data=”Hello”
data=”Pippo”
length(...)
toUpperCase(...)
length(...)
toUpperCase(...)
Nota sugli identificatori
●
●
I nomi di variabili, metodi, classi devono seguire
determinate regole per non incorrere in errori di
compilazione:
– possono essere composti di lettere, cifre, $, _, ma non
possono iniziare con una cifra
– non si possono usare simboli come ?, % o spazi
– non si possono usare parole riservate del linguaggio come
public, class, int, …
Esistono poi delle convenzioni sugli identificatori:
– le variabili e metodi iniziano con una lettera minuscola
– se vogliamo usare parole multiple per un identificatore le
separiamo usando le lettere iniziali maiuscole.
Es: lunghezzaParola
– le classi iniziano con una lettera maiuscola
Utilizzo di oggetti
●
●
●
Consideriamo la classe Rectangle presente nella
libreria java.awt di Java.
La classe Rectangle descrive i campi necessari per
modellare un rettangolo (x,y,altezza,larghezza) e i
metodi per manipolarlo.
Un oggetto di tipo Rectangle rappresenta una specifica
istanza di rettangolo (es: x=5, y=10, larghezza=20,
altezza=30)
(x,y)
Rectangle
x=5
y=10
width=20
height=30
height
...
width
Costruttori
●
●
●
Il costruttore è un metodo speciale che consente di
allocare ed inizializzare un nuovo oggetto.
– il nome del costruttore coincide con il nome della
classe
– può avere o meno dei parametri associati che servono
a determinare l'inizializzazione dell'oggetto
I costruttori vengono descritti all'interno delle
classi.
Un costruttore viene invocato con new e ritorna un
riferimento all'oggetto costruito.
new NomeClasse(parametri)
●
Esempio:
Rectangle box = new Rectangle(5,10,20,30);
Costruttori
●
●
●
Una classe può fornire più di un costruttore
In questo modo abbiamo diverse modalità con cui
possiamo costruire un oggetto sulla base delle
parametrizzazioni del costruttore
Esempio:
Rectangle box = new Rectangle(5,10,20,30);
Rectangle box2 = new Rectangle();
●
Il costruttore Rectangle() inizializza i campi
dell'oggetto a 0.
Metodi
●
●
●
I metodi descrivono le operazioni che possono essere usate
per manipolare gli oggetti
L'implementazione e la firma dei metodi è descritta nella
classe
Il metodo agisce esclusivamente sui campi dell'oggetto che
lo invoca
oggetto.metodo(parametri)
●
●
●
Un metodo può avere dei parametri o meno
Un metodo può ritornare o meno un valore
Es.: il metodo length di String ritorna lunghezza della
stringa su cui viene invocato
String greetings = “Hello, world!”;
String greetings2 = “Ciao”;
int n1 = greetings.length(); // n1=13
int n2 = greetings2.length(); // n2=4
Metodi
●
●
●
●
I metodi possono accedere ai campi dell'oggetto in
lettura o scrittura a seconda dell'operazione che
vogliamo svolgere.
I metodi che ritornano il valore di un campo per
convenzione hanno un nome del tipo getNomeCampo. Es:
getX(), getY().
I metodi che modificano direttamente il valore di un
campo per convenziona hanno un nome del tipo
setNomeCampo. Es: setX(10), setY(30).
Metodi che modificano il valore di uno o più campi di
un oggetto si dicono con “side effects” o “mutators”.
Rectangle box = new Rectangle();
box.setWidth(10); box.setHeight(20);
box.translate(5,10); // x=x+5, y=y+10
System.out.println(box.getX()); //stampa 5
Variabili di tipo oggetto e primitive
●
●
●
●
●
●
Le variabili di tipo oggetto, se inizializzate,
memorizzano la posizione di un oggetto in memoria
(riferimento all'oggetto) o null (riferimento nullo).
Tutti gli oggetti vengono memorizzati nello heap.
Il costrutto new, usato per creare un oggetto, ritorna
un riferimento al nuovo oggetto creato.
Diverse variabili di tipo oggetto possono condividere
un riferimento ad uno stesso oggetto.
In Java non abbiamo esclusivamente oggetti, ma
lavoriamo anche con valori di tipo primitivo (numeri
interi, virgola mobile, booleani, caratteri).
In questo caso la variabile contiene un valore del loro
tipo.
Variabili di tipo oggetto e primitive
Rectangle box1 = new Rectangle (0,0,10,10);
Rectangle box2 = box1; Rectangle box3 = null;
box1.setX(2);
System.out.println(box2.getX()); //stampa 2 e non 0
int width = 10;
int height = width;
height = 2;
System.out.println(width); //stampa 10
box3.setY(0); //errore a run­time
box1=
box2=
box3=
width=
height=
Rectangle
null
x=0
y=0
width=10
height=10
10
10
...
Main
●
●
●
●
Un programma è composto da più classi
La classe applicazione è quella che ha il metodo
statico main, da cui parte la computazione.
Per eseguire il programma bisogna invocare la virtual
machine passando una classe applicazione (es: java
HelloWorld)
I parametri del main identificano i paramatri passati
all'applicazione in fase di esecuzione
public class HelloWorld {
public static void main(String[] args){
//stampa in console un messaggio
System.out.println(“Hello, World !”);
}
}
Classi di libreria
●
●
●
Il codice Java viene organizzato in librerie (packages)
Un package può essere
– una directory
– un speciale archivio jar
Importiamo una classe specificando i nomi del package e della
classe
import java.awt.Rectangle;
●
●
●
Le classi del package java.lang sono importante in automatico. Ne
fanno parte per esempio String e System.
I package seguono un'organizzazione gerarchica. Possiamo avere
sotto-package di altri package (es: java.awt.event)
Possiamo importare tutte le classi di un package (ma non verranno
inclusi in automatico i sotto-package)
import java.awt.*;
import java.awt.event.*;
Documentazione Java
●
●
●
Le librerie Java sono ben documentate .
La documentazione on-line (javadoc) include una
descrizione dei package e delle relative classi (campi,
metodi e costruttori con accesso non privato)
http://docs.oracle.com/javase/7/docs/api/
Documentazione Java
Documentazione Java
Documentazione Java
Documentazione Java