java uni pavia.pdf

1Luigi Santangelo – Biennio formativo 2009-2010 – Università degli Studi di Pavia

Università degli Studi di Pavia

Corso di base in

Programmazione JavaProgrammazione Java

Luigi Santangelo


Obiettivo

- Il presente corso ha l'obiettivo di presentare i fondamenti di Java- E' un corso prevalentemente pratico, si consiglia pertanto di svolgere regolarmente gli esercizi- Cosa NON faremo:

- Librerie Swing e Awt (interfaccia grafica)- Applet- J2EE- J3ME- Librerie specifiche (es. accesso alla base dati)


Esame

Alla fine del corso è previsto (per chi vuole) lo svolgimento di un esame, il cui superamento comporta l'acquisizione di 2 CF. L'esame è esclusivamente pratico. Al candidato verrà richiesto lo sviluppo di un algoritmo simile a quelli che vedremo a lezione.


Risorse

In rete sono presenti tantissime risorse su Java:

www.java.sun.comJava Italian PortalMokabyteMattone dopo mattone


Introduzione allo Introduzione allo sviluppo del softwaresviluppo del software

- capitolo 1 -


Sviluppo del software

Prima degli anni 90:- Lavoro individuale- Algoritmi veloci- Piccola dimensione dei programmi- Limitata uso di memoria RAM

Oggi:- Lavoro in team- Riusabilità del codice- Rendere semplice il mantenimento- Portabilità


Fasi di sviluppo

modello a cascata


Linguaggi di programmazione

1 9 4 0 1 9 5 0 1 9 6 0 1 9 7 0 1 9 8 0 1 9 9 0 2 0 0 0

M a c h i n ec o d e

A s s e m b l y l a n g u a g e s

F o r t r a nB a s i c

P a s c a l

S c h e m eC C + +

J a v aL I S P

S m a l l t a l k S m a l l t a l k 8 0

C #

L o g o

P y t h o n


Strumenti di lavoro

EditorIl programmatore scrive il codice sorgente

CompilatoreTraduce il codice sorgente in un codice oggetto (specifico per la CPU)

IntepreteTradue il codice sorgente „on the fly“

LinkerConverte uno o più moduli in un programma eseguibile

DebuggerEsegue il programma in „slow motion“ e aiuta a trovare eventuali bug


Strumenti di lavoro

Sul sito della Sun è disponibile un'ottima documentazione “navigabile”.In essa troverete tutte le informazioni che cercate. Purtroppo è solamente in inglese e contiene troppi dettagli che non vedremo.

Impareremo a leggere la documentazione e a riconoscere solo ciò che ci serve.


Strumenti di lavoro

Per sviluppare gli applicativi in Java è sufficiente avere qualsiasi editor di testi di tipo ASCII. Per rendere più semplice lo sviluppo, è consigliato l'utilizzo di un ambiente di sviluppo integrato. Questo ci consente di scrivere codice, compilarlo, eseguire il debug ed eseguirlo. Ci agevola anche la scrittura del codice attraverso suggerimenti.Esistono vari ambienti di sviluppo, alcuni dei quali OpenSource (o comunque free):- Eclispe- Netbeans- Jbuilder- ...


Java: un approccio ibrido

Un compilatore Java converte codice sorgente Java in istruzioni per JVM.

Queste istruzioni, chiamate bytecodes, sono le stesse per ogni architettura e per ogni sistema operativo.

Un interprete, specifico per la CPU, interpreta il bytecode in una specifica architettura.


E d i t o r

H e l lo . ja v a

C o m p i l e r

H e l lo . c l a s s

I n t e r p r e t e rH e l l o ,W o r l d !

I n t e r p r e t e r



JDK: Java Development Kit

Cosa serve per programmare in Java?

Il Kit di sviluppo (JDK) contiene:- javac: il compilatore;- java: l'interprete;- javadoc: genera documentazione partendo dal codice Java (non la vedremo);- jar: le librerie di sviluppo;- appletviewer: consente di visualizzare le applet senza utilizzare un browser (non lo vedremo)

Tutti questi sono tools a riga di comando.


Tipi di programmi

Web application (J2EE), Mobile Application (j2ME)

Applet GUI applicationConsole application


Paradigmi di programmazione

Programmazione imperativa:Il codice viene inteso come una sequenza di istruzioni, dette anche direttive o comandi. Rientrano in questa categoria il linguaggio C, Basic, Fortan, Pascal, ...

Programmazione funzionale:Il flusso di esecuzione di un programma assume la forma di una serie di funzioni. Rientrano in questa categoria il linguaggio LISP, Logo, Haskell, ...


Paradigmi di programmazione

Programmazione orientata agli oggetti:La programmazione orientata agli oggetti gestisce oggetti. Ogni oggetto ha una propria vita (viene creato, viene utilizzato e quindi viene distrutto). L'uso di un oggetto avviene attraverso i propri metodi. Ogni metodo può cambiare lo stato dell'oggetto, spedire un messaggio all'oggetto, o creare un nuovo oggetto (figlio).Un oggetto, inoltre, è di uno specifico tipo (classe). Più oggetti possono far parte della medesima classe ed ereditare le medesime caratteristiche. Java è un linguaggio OOP


Nozioni fondamentaliNozioni fondamentali

- capitolo 2 -


Il linguaggio

Il linguaggio Java è composto da uno o più file di testo, uno dei quali deve necessariamente contenere una classe public con un metodo main:

public MiaClasse{

public static void main (String args[]){

...}

}

Ogni file deve avere lo stesso nome della classe ed estensione .java


Il linguaggio

Considerazioni:- Java è case sensitive: distingue le maiuscole dalle minuscole;- Un programma Java vive all'interno di una classe il cui nome deve essere uguale al nome del file e deve inizare con una lettera;- non c'è limite alla lunghezza del nome della classe;- Per convenzione il nome della classe inizia con la lettera maiuscola;- Se non sono stati commessi errori sintattici, compilando la classe si ottiene un file .class che è il bytecode


I commenti

Un commento è una porzione di codice che verrà ignorata durante la fase di compilazione del codice sorgente. Utilissimo per indicare al programmatore la semantica dell'algoritmo che sta realizzando.Un commento può essere inserito con:

// commento in singola linea

/*commento supiù linee

*/


I commenti

Prendete l'abitudine di commentare i programmi. Partendo dai commenti presenti in un file, è possibile, attraverso l'utility javadoc, creare automaticamente la documentazione (in formato html) per le classi create.A tale scopo, i commenti vanno inseriti prima della definizione di ogni classe, di ogni metodo e di ogni attributo.


Le variabili

Una variabile identifica una porzione di memoria RAM in grado di contenere una informazione semplice (tipi primitivi) o composta (oggetti). Il tipo di una varibile specifica la quantità di memoria deve essere riservata per mantenere quella informazione.

Tipi primitivi:

boolean short long floatbyte int char double


Assegnamento

Inizializzare una variabile significa assegnare alla variabile un valore iniziale (che può essere modificato). La modifica di una variabile avviene attraverso l'operatore di assegnamento (=)

int a = 6;

In questa istruzione abbiamo dichiarazione e inizializzazione;

a = 8;

In questa istruzione assegnamo 8 alla variabile a


Tipi primitivi

boolean true o falsechar carattere UNICODE a 16 bitbyte intero di 8 bit [-/+127]short intero di 16 bit [-/+32768]int intero di 32 bit [+/-2.147.483.648]long intero di 64 bit [-/+ 10^19]float decimale di 32 bit [+/-3,4*10^38]

con 7 cifre significativedouble decimale di 64 bit [+/-3,4*10^308]

con 15 cifre significative

float richiede il suffisso F per distinguerlo da double


Tipi primitivi: osservazioni

Notate che una stringa NON è un tipo primitivo, ma un oggetto. Ne parleremo più avanti.

Due variabili possono essere combinate tra loro SOLO se hanno lo stesso tipo. Ad esempio, due variabili possono essere sommate tra loro solo se hanno lo stesso tipo (ad esempio entrambe int). Se due variabili sono di tipo differente ma devono essere tra loro combinate DEVONO essere convertite nel medesimo tipo (cast). Questa operazione può essere automatica (fatta dal compilatore) o manuale (fatta dal programmatore)


Casting

Il cast è un processo di conversione (automatico o manuale) di una variabile da un tipo a un altro tipo. Ad esempio, un intero può essere convertito in un float o in un double, o un intero in una stringa. Alcuni cast avvengono automaticamente, mentre in altre circostanze è necessario indicarlo esplicitamente:int a = 5;double b = a; // b vale 5.0String s = a + “”; // s vale “5”char c = 'a';int d = c; // d = 97 ascii di 'a'


Casting

Alcuni cast sono “lossless” (senza perdita di dati). Ad esempio se convertiamo un intero in un double non c'è perdita di dati, ma se convertiamo un double in intero, la parte decimale viene persa:double d = 3.14;int i = (int) d; // i vale 3Di seguito vengono indicati i cast lossless

byte short int long

doublechar


Cast

int a = 17;int b = 5;System.out.print(a / b);// essendo a e b due interi, la divisione ritorna un intero (ovvero 3);

double c = (double) a / (double) b;// c è un numero reale


Nome variabile

Una variabile si può chiamare come si vuole purche:- non abbia come nome una parola riservata;- sia composta solo da lettere, cifre, _ e $- non inizi con una cifra;

Attenzione: Java è case sensitiveint Totale = 100;int totale = 100;


Parole riservate

abstract boolean break bytebyvalue case cast catch

char class const continuedefault do double elseextends false final finally

float for future genericgoto if implementsimport inner instanceof

interface long native newnull operator outer packageprivate protected public restreturn short static superswitch synchronized thisthrow throws transient

try var void volatilewhile int true


Esempio 01

public class ex01{


boolean flag = true;char ch = 'B';int n = 22;float x = 3.14159F;

}}

Le variabili di tipo primitivo di definiscono, gli oggetti si istanziano (operatore new, lo vedremo più avanti).


Esempio 01

public class ex01{


boolean flag = true;char ch = 'B';int n = 22;float x = 3.14159F;

System.out.print(flag);}

}


Caratteri speciali

\b backspace\t tabulazione\n avanzamento riga\r ritorno carrello\” virgolette doppie\' virgoletta singola\\ barra rovesciata


Operatori

Gli operatori in java di distinguono in operatori di:

assegnamento: =relazionali: < <= == >= > !=aritmetici: + - * / %logici: && || !incremento ++decremento --


Operatori logici

(condiz1 && condiz2) è vera se e solo se entrambe le condizioni sono vere. Se la prima è falsa, la seconda non viene verificata (corto-circuitata)

(condiz1 || condiz2) è vera se almeno una delle due condizioni è vera. Se la prima è vera, la seconda non viene verificata. (corto-circuito)

(!condiz1) è vera solo se condiz1 è falsa.


Esempio 02

public class ex02{


int a = 10;int b = 5;int diff = a – b;int mod;mod = a % b;System.out.print(diff);System.out.print(mod);

}}


Controllo del flusso

Come tutti i linguaggi di programmazione, Java supporta i costrutti if, if ... else

if (condizione){

codice se condizione è vera}else{

codice se condizione è falsa}


Esempio 03

public class ex03{


int a = 10;int resto = a % 2;if (resto == 0){

System.out.print(“Numero pari\n”);}else{

System.out.print(“Numero dispari\n”);}

}}


Errori comuni

if (...) if (...)

statement1;else statement2;...

It is safer to always use braces in if-else

if (...)statement1;statement2;

...

if (...) ;{

statements; ...}

Extra semicolon:

Missing braces:


Controllo del flusso

L'utilizzo di molti if potrebbe compromettere la leggibilità del codice. Per questo potrebbe essere utile utilizzare il costrutto switch (equivalente all'if)switch (variabile da controllare){

case valore1: istruzioni; break;

case valore2: istruzioni; break;

...default:

istruzioni; break;

}


Esempio 04

public class ex04{


char carattere = 'a';

switch (carattere){

case 'a': System.out.print(“Carattere A”);break;case 'z': System.out.print(“Carattere Z”);break;default: System.out.print(“Non definito”);

}}

}


Cicli iterativi

In Java esistono 3 modi per poter eseguire i cicli iterativi: for, while e do ... while

I metodo più semplice è il ciclo for con il quale viene indicata la sequenza di istruzioni che devono essere iterate e il numero di volte in cui l'iterazione dovrà avvenire. Questo avviene indicando il limite inferiore, il limite superiore di iterazioni e la lunghezza del “passo”.


Esempio 05

public class ex05{


for (int i = 0; i < 10; i = i+1){

System.out.print(“Iterazione n. “ + i);System.out.print(“\n”);

}}

}


Cicli iterativi

Talvolta, però, non è possibile determinare il numero di iterazioni da fare. Ad esempio, si potrebbe pensare di eseguire un ciclo fintanto che una variabile non assuma il valore 100. In questo caso non sappiamo quando la variabile assuma tale valore. In questo caso è preferibile utilizzare i costrutti while e do ... while.La differenza fondamentale sta nel fatto che il ciclo while può essere eseguito zero volte (se la variabile assume già il valore 100), mentre il do ... while, viene comunque eseguito una volta. Cioè il controllo della condizione avviene DOPO aver eseguito il ciclo.


Esempio 06

public class ex06{


int a = 100;

while ((a % 2) == 0)a = a / 2;

System.out.print(“Valore di a: “);System.out.print(a + “\n”);

}}


Esempio 07

public class ex07{


float a = 75F;do

a = a / 2;while ((a % 2) == 0);System.out.print("Valore di a: ");System.out.print(a + "\n");

// a vale 37.5}

}


Metodi

Come abbiamo già detto, un programma java è composto da almeno una classe che contiene un metodo chiamato main. In realtà, questa classe potrebbe contenere diversi metodi (o funzioni) che possono essere richiamati da qualsiasi altro metodo. Un metodo prende in input zero, uno o più parametri (INPUT) e ritorna zero o un parametro (OUTPUT). Bisogna però distinguere la definizione del metodo dalla chiamata al metodo. Un metodo che non ritorna nulla, ritorna void. Il valore di ritorno viene ritornato tramite return. Un metodo può avere diversi return.


Esempio 08

public class ex08{


if (pari(5)) System.out.print(“numero pari”);else System.out.print(“numero dispari”);

}

private static boolean pari(int a){

if ((a % 2) == 0) return true; return false;

}}


Visibilità (scope)

Ogni variabile che viene definita in un programma Java ha una sua visibilità (scope). Se si cerca di utilizzare una variabile fuore dal suo scope, il compilatore segnala un errore. Le parentesi graffe possono essere utilizzate per capire qual è lo scope:

public void funzione(){

int miavar = 10;....

}// qui finisce la visibilità della variabile


Visibilità (scope)

Le variabili possono definite dentro un metodo vengono distrutte quando il metodo è stato eseguito (quindi lo spazio di memoria viene liberato).

// le due variabili sono distinte

private double radius;...public void function (...){ double radius = 5; ...


Esercizi

1. public static int daysInMonth(int month, int year)// precondizione: 0 < n < 13// esempio: daysInMonth(2, 2000) ritorna 29

2. public static int numberOfDigits(int n)// esempio: numberOfDigits(1478) ritorna 4

3. public static int sumOfDigits(int n)// esempio: sumOfDigits(1478) ritorna 20

4*. public static int reverseInteger(int n)// esempio: reverseInteger(1234) ritorna 4321


Ricorsione (solo definizione)

Alcuni problemi si prestano bene ad essere risolti attraverso una tecnica di programmazione definita ricorsione.La ricorsione consiste nel definire una funzione che richiama se stessa ripetutamente (attenzione, se non è ben definita può creare loop infiniti). Alcuni problemi infatti sono di tipo ricorsivo:

Fattoriale di un numeroDimensione in byte del contenuto di una directoryMassimo comune divisore (Algoritmo di Euclide)Tutte le operazioni di ricerca (tempo logaritmico)


Pseudocodice e Flowcharts

Pseudocodice: sequenze di asserzioni in una specifica notazione (non legato ad alcun linguaggio di programmazione)

FlowCharts (diagrammi di flusso): rappresentazione grafica del flusso


Esempio: 12 + 22 + ... + n2

Pseudocodice:

Input: n

sum = 0i = 1

Ripeti fintanto che i <= n sq = i * i

sum = sum + sq i = i + 1

Output: sum


Esempio: 12 + 22 + ... + n2

n

sum ← 0i ← 1

i ≤ n ?

sq ← i * isum ← sum + sqi ← i + 1

sum

No

Yes

Input / output

Processing step

Decision


Esempio: 12 + 22 + ... + n2

public static void main(String args[]){

int n, sum, i;n = 10;sum = 0;for (i = 1; i <= n; ++i){

int sq = i * i;sum = sum + sq;

}System.out.print(sum);

}


Gli oggettiGli oggetti

- capitolo 3 -


Gli oggetti

Java è un linguaggio di programmazione orientato agli oggetti. Offre infatti una suite di librerie di oggetti dei quali è possibile utilizzare i relativi metodi.Un oggetto rappresenta una istanza di una classe, una entità fisicamente presente in memoria RAM.Preso un oggetto, è possibile modificare le proprietà attraverso i metodiLe proprietà di un oggetto possono essere altri oggetti o variabili di un certo tipo.Attraverso i metodi (funzioni) si possono modificare le proprietà degli oggetti.


Gli oggetti

Affinchè un oggetto possa esistere, è necessario istanziare tale oggetto partendo dalla sua classe.Per cui per avere l'oggetto bisogna avere la classe. Per istanziare un oggetto si utilizza l'operatore new che alloca lo spazio di memoria sufficiente a memorizzare l'oggetto.

Object myObj = new Object();

I metodi di un oggetto possono essere invocati nel seguente modo:

res = myObj.myMethod(parameter);


Oggetti

Java mette a disposizione una miriade di oggetti che possono essere istanziati e successivamente utilizzati. Fornisce anche i costrutti affinchè possano essere costruiti oggetti “nuovi” attraverso la definizione della classe a cui gli oggetti appartengono.Tra tutti gli oggetti presenti nelle librerie, ne vedremo solo alcuni. Innanzitutto l'oggetto String.Finora abbiamo lavorato solo con tipi primitivi (int, char, float, ecc) ma non abbiamo parlato di stringhe, in quanto queste in Java sono oggetti.


L'oggetto String

Una stringa è una sequenza di caratteri. La classe String contiene più di 50 metodi. Nel seguito vedremo i più significativi. Per prima cosa è necessario creare l'oggetto di istanza String, quindi successivamene utilizzare i metodi che la classe ci mette a disposizione. Gli esempi che verranno indicati nel seguito ometteranno (per questione di leggibilità) la definizione della classe principale e del metodo main.


Esempio 09

// creazione dell'oggettoString saluto = new String(“Ciao”);

// ritorna 4, la lunghezza della stringaint len = saluto.lenght();

// visualizza la sottostringa “ia”System.out.print(saluto.substring(1,3));

// visualizza la stringa in maiuscoloSystem.out.print(saluto.toUpperCase());

// concatenazioneSystem.out.print(“Mario” + “ “ + “Rossi”);


Esempio 09

// visualizza la stringa in minuscoloSystem.out.print(saluto.toLowerCase());

// ritorna il carattere 'C'char c = saluto.charAt(0);

// verifica se le due stringhe sono ugualiString a = new String(“Ciao”);String b = new String(“Hello”);boolean uguali = a.equals(b);

// concatenazione tra stringheString c = new String(a+b);


L'oggetto String

L'oggetto String è un oggetto un po' “particolare”. Per tutti gli oggetti, infatti, la creazione si effettua attraverso l'operatore new (come visto finora). Un oggetto String può essere creato anche nel seguente modo:String s = “Pippo”;che equivale a String s = new String(“Pippo”);

Consiglio: abituatevi a scriverlo nel secondo modo.


L'oggetto String

Una stringa può contenere anche caratteri speciali:

\\ per visualizzare \\n per visualizzare una new line\t per i tab


L'oggetto String

Un qualsiasi oggetto, e quindi anche un oggetto di classe String, può, come abbiamo visto nella funzione equals, può essere passato come parametro all'interno di una funzione (come avviene con i tipi primitivi) ma può anche essere ritornato da un metodo. Ad esempio il metodo substring ritorna una stringa, sottostringa di quella passata come parametro:

String s = new String(“Pippo”);String ss = s.substring(0,2);// o equiventementeString ss = new String(s.substring(0,2));


L'oggetto String

Altre funzioni sull'oggetto String:

String s = new String(“mia stringa”);

s.length(); // lunghezza di s

s.charAt(2); // terzo carattere

s.substring(2, 5); // ritorna 5 caratteri a partire dal secondo

s.compareTo(altra_stringa); // confronta le due stringhe


L'oggetto String

Altre funzioni sull'oggetto String:

String s = new String(“mia stringa”);

s.trim(); // elimina gli spazi

s.replace(vecchia, nuova); // sostituisce ogni occorenza di vecchia con nuova

s.toUpperCase();s.toLowerCase();


L'oggetto String

Conversione intero – stringa e stinga – intero

int i = 5;String s = Integer.toString(i);System.out.print(s + 5); // visualizza 55;

String s = new String(“5”);int i = Integer.parseInt(s);System.out.print(i + 5); // visualizza 10


Esercizi

1. Scrivere la procedura:public int[] contaLettereAlfabeto(String fraseMoltoLunga);

in cui la variabile fraseMoltoLunga contiene una stringa abbastanza lunga (ad esempio i primi 10 versi della Divina Commedia) e ritorna un array di 26 elementi. L'iesimo elemento dell'array contiene il numero di volte in cui la iesima lettera dell'alfabeto figura nella stringa. Es:“nel mezzo del cammin di nostra vita....”array[0] = 3; // perchè 3 sono le occorrenze del carattere Aarray[1] = 0; // perchè non ci sono occorrenze del carattere barray[2] = 1; //perchè c'è una sola lettera c...array[25] = 2; // perchè 2 sono le occorrenze della letterea z


Esercizi

5. public static String intToBinary(int n)// esempio: intToBinary(123) ritorna “1111011”

6. public static int numeroVocali(String s)// esempio: numeroVocali(“pippo”) ritorna 2

7. public static String inverti(String s)// esempio: inverti(“pippo”) ritorna “oppip”

8*. public static String cifrCesare(String s, int k)// esempio: cifrCesare(“abc”, 3) ritorna “def”;// per semplificare si considerino solo i testi minuscoli


Gli array e l'inputGli array e l'input

- capitolo 4 -


Array

Un array è un blocco di memoria che contiene valori dello stesso tipo (es tutti intero, tutte stringhe, ecc)Ogni locazione contiene un “elemento”

1.39

1.69

1.74

0.0

Un array di doubles


Array

Un array fisicamente è una sola variabile anche se contiene diversi elementi. Ogni elemento dell'array viene acceduto attraverso un indice. In informatica gli indici iniziano sempre da zero.

c[0] c[1] c[2] c[3]

1.39

1.69

1.74

0.0 c è il nome

dell'array


Array

Notate che se un array aventi N elementi, gli indici vanno da 0 a n-1

c[0] c[1] c[2] c[3]

1.39

1.69

1.74

0.0 c è il nome

dell'array


Array

In Java, quando si crea un array è necessario specificare a priori la dimensione di questo array. Questa dimensione NON può essere modificata successivamente.

Se si tenta di accedere a una locazione dell'array inesistente viene generato un'eccezione.


Array

Definizione di un array in Java:

Type[] nomeArray = new Type[dimensione];

es.

int[] nomeArray = new int[25];


Array

Perchè sono necessari gli array?

Supponiamo di avere 1000 variabili di tipo intere e vogliamo calcolare la somma. Scriviamo il codice sia con gli array che senza

int sum = 0; int n = 1000;int p = new int[n];

sum = sum + var0001; int sum = 0;... for (int k=0; k<n; k=k+1) sum = sum + var1000; somma = somma+p[i];

totale 1001 righe totale 5 righe


Gli array

Un array può essere visto come un oggetto e come tale possiede alcune proprietà. Quella più utilizzata è la proprietà lenght (non è un metodo), che restituisce il numero di elementi di cui si compone l'array:

int a[] = new int[100];System.out.print(a.lenght);

Si fa notare come l'elemento passato al metodo main è un array di Stringhe:

public static void main(String args[])


Array

Un array, come un qualsiasi altro tipo primitivo, può essere ritornato da un metodo. Es:

public static int[] mioMetodo(int a[]){

int nuovoarray[] = new int[a.length];....return nuovoarray;

}


Esempio 10

// Dichiarazione di array:int arr1[] = new int[100];String arr2[] = new String[25];

//accesso all'arrayarr1[0] = 101;arr1[1] = 202;arr2[0] = new String(“Pippo”);arr2[1] = new String(“Pluto”);arr3[2] = new String(“Paperino”);


Esempio 11

// Riempire un array di 100 elementi con i primi // 100 numeri interi

final int MAX = 100;int array[] = new int[MAX];for (int i = 0; i < MAX ; ++i)

array[i] = i;


Input di dati

Si è visto come con una semplice procedura è possibile visualizzare a video il valore delle variabili:System.out.print(“Messaggio”);Purtroppo però l'input in Java è una operazione abbastanza complessa in quanto bisogna utilizzare parecchie classi che sarebbe troppo prematuro vedere. Risulta pertanto più semplice utilizzare una finestra di input:

JOptionPane.showInputDialog(“messaggio”);


Esempio 12

Import javax.swing.*;

String nome = JOptionPane.showInputDialog(“Il tuo nome”);

System.out.println(“Il tuo nome: “ + nome);

String anni = jOptionPane.showInputDialog(“età”);

int age = Integer.parseInt(anni);

System.exit(0);


Esercizi per casa

1. Utilizzando il ciclo for creare un programma che calcola il fattoriale di n

2. Creare un array di 10 elementi, inizializzarlo (dando valori a casuali). Scrivere il metodo

public static void print(int array[]);che prende l'array e ne visualizza gli elementi

3. Creare un array di 10 elementi, inizializzarlo (dando valori a casuali). Scrivere il metodo

public static int[] swap(int a[]);che prende l'array a e crea un nuovo array b contente gli stessi elementi di a scritti in ordine inverso


Esercizi

9*. public static boolean isSorted(int n[])// ritorna true se n[] è ordinato

10. public static int minimo(int n[])// ritorna l'elemento minimo dell'array

11. public static int media(int n[])// ritorna la media

12. public static int[] reverse(int a[])inverte l'ordine degli elementi dell'array


Esercizi

13. public static int[] concatena(int a[], int b[])// ritorna un array contenente gli elementi di a e di b

14. public static int[] tally(String s)// ritorna un array contenente il numero di occorrenze// dei 26 caratteri dell'alfabeto presenti in s// per semplicità si trasformi s in minuscolo// NB: ricordarsi di gestire gli spazi e i caratteri

speciali


Le classiLe classi

- capitolo 5 -


Terminologia

Classe: schema dettagliato in base al quale l'oggetto verrà creato, definisce le caratteristiche dell'oggetto che appartiene alla classe

Oggetto: istanza della classe, l'oggetto possiede la stessa struttura della classe. Rapprenta l'entità attiva

Campi: proprietà dell'istanza. L'insieme di tutti i campi rappresenta lo stato dell'oggetto

Metodi: azioni che l'oggetto può compiere. I metodi variano lo stato dell'oggetto.


Terminologia

Classe: macchina Oggetto: ferrari

Attributes: String model Color color int numPassengers double amountOfGas

Attributes: model = "Mustang" color = Color.YELLOW numPassengers = 0 amountOfGas = 16.5


Terminologia

Incapsulamento: i campi di un oggetto sono accessibili SOLO all'oggetto stesso e non da altri oggetti (sia istanza della stessa classe che istanze di classi diverse). Attraverso l'incapsulamento, l'oggetto diventa una “scatola nera” e per interagire con l'oggetto si devono usare solo i metodi che l'oggetto mette a disposizione

Ereditarietà: una classe può ereditare e successivamente estendere le proprietà e i metodi di una classe “padre”


Terminologia

Event-driven: Il programma simula la gestione asincrona degli eventi. Alcuni metodi possono essere invocati automaticamente in risposta ad alcuni eventi.

Costruttori: metodi interni alla classe che consentono la creazione dell'oggetto. Devono essere sempre presenti e quando mancano viene utilizzato il costruttore di default. Il costruttore ha lo stesso nome della classe e viene invocato con new


Esempio 13

GragorianCalendar compleanno;compleanno = new GregorianCalendar();// l'operatore new consente di invocare il // costruttore della classe Date. In questo modo// si possono utilizzare i metodi della classe// Date

GregorianCalendar oggi;// Non è stato creato alcun oggetto (nella RAM// non è stato allocato alcuno spazio, per cui// non si possono utilizzare i metodi di Date)

compleanno

oggi

GregorianCalendar


Costruzione di classi

Fino a questo momento abbiamo utilizzato delle classi già esistenti. Java fornisce un set di costrutti che consentono allo sviluppatore di realizzare nuove classi. La forma più semplice per la definizione di una classe è:class nomeClasse{

attributo1attributoN

costruttore1costruttoreN

metodo1metodoN

}


Esempio 14

import java.util.GregorianCalendar;Class Impiegato{

private String nome;private String cognome;private String matricola;private GregorianCalendar dataAssunzione;

// CostruttoreImpiegato(String n, String c, String m){

nome = n;cognome = c;matricola = m;

}[...]


Esempio 14

[...]public String getNominativo(){

return nome + “ “ + cognome;}

public void setAssunzione(int g, int m, int a){

dataAssunzione = new GregoriaCalendar(a,m,g);}

public GregorianCalendar(){

return dataAssunzione;}

}


Esempio 14

class esempio14{


Impiegato i = new Impiegato(“Mario”, “Rossi”, “A”);Impiegato i2 = new Impiegato(“Luca”,“Bianchi”,“B”);Impiegato i3 = new Impiegato(“Alice”,“Verdi”,“C”);

i.setAssunzione(25, 8, 2009);

System.out.print(i2.getNominativo());}

}


Osservazioni

- Sono state create DUE classi: la prima (Impiegati) contiene solo la definizione della classe, ovvero gli attributi della classe, i costruttori e i metodi per accedere agli attributi; nella seconda invece si creano gli oggetti di classe Impiegati;- I metodi della classe Impiegati sono pubblici, gli attributi invece privati- Nella classe impiegati è stato definito un costruttore (potrebbe essere omesso)- Nella classe impiegati non possono esserci due metodi aventi la stessa “firma”- Il nome del file della classe Impiegati DEVE essere Impiegati.java- Import della classe GregorianCalendar;


Esercizi

15. Creare una classe Impiegato in grado di memorizzare il nome, il cognome, la data di nascita (giorno, mese e anno) e lo stipendio annuo (double) di un generico dipendente. Creare almeno un metodo costruttore e i relativi metodi di set e di get degli attributi (i quali dovranno essere privati). Creare anche un metodo public void bonus(double aumento) che aggiunge allo stipendio annuo del dipendente, il bonus passato come parametro. Scrivere quindi un metodo main con il quale viene creato un array di 5 impiegati. Iterare quindi un ciclo in modo da aumentare, a ognuno dei dipendenti, il proprio stipendio del 5%. Infine stampare il nome, il cognome e lo stipendio annuo di ciascuno dipendente, ciascuno su una riga.


Metodi privati

Come abbiamo visto, in una classe gli attributi sono definiti privati, mentre i metodi pubblici. In alcuni casi, però potrebbe essere necessario definire dei metodi accessibili solo all'interno della classe stessa (e quindi non dall'esterno). In questo caso il metodo può essere definito privato:

private String mioMetodo(int d){

...}


Attributi e metodi static

Un campo (attributo) si dice statico se tutte le istanze di una specifica classe (in cui si definisce il campo statico) condividono lo stesso campo. Di conseguenza, un valore settato in un campo statico, è visibile a tutte le istanze di una classe.Lo scope degli attributi è su tutta la classe.Un campo statico si definisce con static:

private static int contatore;



Un campo si dice statico se tutte le istanze di una specifica classe (in cui si definisce il campo statico) condividono lo stesso campo. Di conseguenza, un valore settato in un campo statico, è visibile a tutte le istanze di una classe. Un campo statico si definisce con static:

private static int contatore;

Un attributo statico che non varia nel tempo (final) è una costante private final static double PI = 3.1415;



Anche un metodo può essere definito static. Un metodo statico può essere invocato anche senza dover istanziare l'oggetto.

public static int numeroDipendenti(){

...}

Si ricorda che il metodo main è un metodo statico. Un metodo statico può solo accedere ai campi statici di una classe



La classe Math fornisce moltissimi metodi statici, che possono, di conseguenza, essere utilizzati senza dover istanziare l'oggetto Math per invocarne i suoi metodi:

double d = Math.random();double p = Math.sqrt(256);


Esempio 15

class Impiegato{

[...]// campo visibile a tutte le istanze// di Impiegatoprivate static int contatore = 0;

// costruttoreImpiegato([...]){ ++contatore; }

public static int getContatore(){

return contatore;}

}


Esempio 15

class Esempio15{


Impiegato a = new Impiegato([...]);Impiegato b = new Impiegato([...]);Impiegato c = new Impiegato([...]);

System.out.print(Impiegato.getContatore);// Non sto utilizzando l'istanza, ma la// classe. Viene visualizzato 3

}


Esercizi

16. Creare una classe CdMusicali in grado di memorizzare informazioni sui CD: artista e titolo del CD. Ogni CD deve essere identificato univocamente, cioè ogni CD deve avere un proprio id (numerico) e tutti i CD devono condividere il successivo numero libero (se ho già creato 4 CD il numero successivo deve essere 5). Costruire i relativi metodi di get e di set. NON costruire il metodo set dell'attributo ID. NON costruire né il metodo SET né il GET del successivo numero libero ma creare un metodo statico che ritorna il numero successivo libero. Infine creare un metodo main che crea 7 CD. Ogni qualvolta viene creato un CD, come id viene assegnato il successivo numero libero, e quest'ultimo deve essere incrementato di 1. Assegnare nome dell'artista e titolo a piacere. Quindi visualizzare i 7 CD.


Overload di metodi

In Java è possibile definire una classe contenente più volte un metodo con lo stesso nome ma parametri differenti. Questo viene definito overload (sovraccarico) del metodo.

public class foo{

public void metodo(){ ... }

public void metodo(int par){ ... }

}


Costruttori

Talvolta si ha necessità di inizializzare gli attributi di una classe ad alcuni valori di default. Il costruttore di una classe serve proprio a definire i valori che dovranno essere assegnati agli attributi della classe. Un costruttore può anche non essere definito, ma non è una buona tecnica di programmazione. Tuttavia, anche per i costruttori è possibile eseguire l'overload, in questo modo una classe può avere diversi metodi costruttori (ognuno di loro avrà una firma differente).


Costruttori

1. Una classe può avere più di un costruttore2. I costruttori devono avere il nome della classe3. Sono sempre di tipo public4. Non ritornano alcun tipo5. Possono prendere parametri6. Se ci sono più costruttori, i parametri devono essere differenti;7. Se non si definisce alcun costruttore, Java ne fornisce uno di default.8. Un costruttore viene invocato con l'operatore new


Esempio 16

class Esempio16{

int param;String val;

public Esempio16(int a, String s){

param = a; s = val;}

public Esempio(int a){

this(a, “”);}

}


Esempio 16/bis

class Esempio16Bis{


String s;// s vale nulls = new String(“pippo”);// s viene inizializzato e in questo momento// viene allocata la memoria

}}


Esercizi

17. Creare una classe Employe composta da tre attributi: un id (di tipo intero), nome (di tipo Stringa) e salario (di tipo intero). Definire quindi un primo metodo costruttore che inizializza solo il nome e un secondo metodo costruttore che inizializza sia il nome che il salario. Nel primo metodo costruttore (quello che inizializza solo il nome), il salario dell'impiegato dovrà essere inizializzato a “-1”. L'attributo id dovrà essere un attributo statico e dovrà essere incrementato ogni qualvolta viene creato un nuovo oggetto istanza della classe Employe. Per cui i metodi costruttori dovranno prevedere opportunamente l'incremento. Creare un metodo toString() che non prende nessun parametro e ritorna una stringa contenente il nome seguito da “:” seguito dal salario. Successivamente creare una seconda classe, chiamata e17, che contiene il metodo main dentro al quale viene definito un array di 5 elementi contenente 5 oggetti Employe (inserire nome e salario casuali), quindi visualizzare l'array.


Package

Un package rappresenta un pacchetto di classi. Queste possono essere utilizzare all'interno di una qualsiasi altra classe, purchè si specifica il nome del package. Ad esempio, la classe Date, fa parte del package java.util, per cui questo pacchetto dovrà essere importato nella nostra classe attraverso la direttiva import:

import java.util.*;class miaClasse{

...}


Package

Esistono centinaia di package, quelli che seguono sono alcuni, quelli che verosimilmente vi troverete ad utilizzare nel prosieguo della vostra attività di programmatori java:

java.applet (applet per il web)java.awt (Abstract Window Toolkit)javax.swing (GUI)java.net (comunicazione in rete)java.text (formattazione di testi)java.math (funzioni matematiche)java.lang (package importato di default)


Incapsulamento

Gli attributi di una classe possono essere tipi primitivi, oppure oggetti istanza di una classe. Gli attributi dovrebbero essere sempre privati. Da una classe B deve essere possibile accedere agli attributi della classe A solo attraverso i metodi pubblici. Questo viene definito incapsulamento. Ad esempio, la classe Impiegati, tra i suoi attributi, può avere un oggetto di classe GregorianCalendar.In questo caso questo oggetto è incapsulato dentro la classe Impiegati.


Incapsulamento

Affinchè l'incapsulamento possa essere realizzato, è necessario che gli attributi siano privati. L'accesso agli attributi avviene attraverso i metodi pubblici di tipo get e set.


Incapsulamento

public class MyClass {

// Private fields: private <sometype> myField; ...

// Constructors: public MyClass (...) { ... } ... // Public methods: public <sometype> myMethod (...) { ... } ... // Private methods: private <sometype> myMethod (...) { ... } ... }

Public interface: public constructors and methods


Ereditarietà e Ereditarietà e PolimorfismoPolimorfismo

- capitolo 6 -


Ereditarietà

Supponiamo di aver già creato una classe chiamata Impiegato, composta dai campi nominativo e stipendio. Se consideriamo i dirigenti, anch'essi sono sotto alcuni aspetti molto simili agli impiegati (hanno un nome e prendono uno stipendio). Ma possiedono qualcosa di più, ad esempio un bonus in caso di raggiungimento degli obiettivi. Attraverso l'ereditarietà è possibile creare una classe Manager che eredità tutte le funzionalità della classe Impiegati e definisce quelle nuove.Class Manager extends Impiegati{

...}


Ereditarietà

La classe Impiegati viene definita superclasse (o classe base, o classe genitore). La classe Manager viene definita sottoclasse (o classe derivata, o classe figlia).Le sottoclassi possiedono pertanto maggiori funzionalità delle superclassi.Tutti i metodi e gli attributi definiti nella superclasse vengono ereditati nella sottoclasse. NON vale il viceversa. È possibile nella sottoclasse ridefinire (override) un metodo della superclasse. All'interno della sottoclasse è possibile invocare un metodo della superclasse attraverso la parola chiave super.


Esempio 17class Impiegato{

int stipendio;String nominativo;

public Impigato(int s, String n){

stipendio = s;nominativo = n;

}

public int getStipendio(){ return stipendio; }

public String getNominativo(){ return nominativo; }

}


Esempio 17

class Manager extends Impiegato{

int bonus;

public Manager(int s, String n, int b){

super(s, n);bonus = b;

}

public int getStipendio(){

// return stipendio + bonus; // ERROREreturn super.getStipendio() + bonus;

}}


Esempio 17

class Esempio17{

public static void main(String arg[]){

Impiegato i = new Impiegato(25000, “pippo”);Manager m = new Manager(35000, “pluto”, 15000);

System.out.print(i.getNominativo() + “ “);System.out.println(i.getStipendio());// ritorna 25000System.out.print(m.getNominativo() + “ “);System.out.println(m.getStipendio());// ritorna 50000

}


Polimorfismo

Continuiamo con l'esempio di prima: Impiegati e Manager. Abbiamo detto che la classe Manager estende la classe Impiegato. Questo significa che un oggetto istanza della classe Manager è anche istanza della classe Impiegato (anche nella vita pratica un manager è pur sempre un impiegato). Il fatto che un oggetto può essere istanza di due classi differenti viene definito polimorfismo. L'esempio seguente chiarirà i dubbi:


Esempio 18class Esempio18{

public static void main(String arg[]){

Impiegato dip[] = new Impiegato[4];

dip[0] = new Impiegato(“Carl”, 15000);dip[1] = new Manager(“Tom”, 35000, 12000);dip[2] = new Impiegato(“Bob”, 22000);dip[3] = new Manager(“Harry”, 29000, 15000);

for (int i = 0; i < 4; ++i){

System.out.print(dip[i].getNominativo()+ “ “);System.out.println(dip[i].getSalario());

}}


Polimorfismo

Nell'istruzione seguenteSystem.out.println(dip[i].getSalario());

la VM invoca dinamicamente il metodo getSalario a seconda di chi sia dip[i], cioè a seconda che dip[i] sia istanza di Impiegato o sia istanza di Manager. La selezione automatica del metodo appropriato durante l'esecuzione viene chiamata binding dinamico


Classi e metodi final

Talvolta si può aver necessità di impedire che una classe venga ereditata. Cioè se A è una classe di tipo final, non è possibile creare B che estende A. In questo caso, in fase di compilazione verrà generato l'errore. La stessa cosa, accade con i metodi final. Es:class A{

public final int test(){ ... }

}

Class B extend A{ // B non può definire il metodo test. }


Classi Astratte

Una classe si dice astratta quando contiene uno o più metodi astratti. Un metodo è astratto quando tale medoto viene solo definito e non implementato. Spetta alla classe che estende la classe astratta implementare i metodi astratti. Una classe astratta non può mai essere istanziata, cioè NON è possibile creare un oggetto istanza di una classe astratta.

ClasseAstratta a = new ClasseAstratta(); // impossibile


Esempio 19

Nell'esempio che segue creeremo una classe Person astratta, nella quale viene definito ma non implementato il metodo getDescrizione, quindi creeremo altre due classi (Impiegato e Studente) che ereditano la classe Person e quindi implementano il metodo astratto.


Esempio 19

abstract class Person{

private String name;

public Person(String n){ name = n; }

public abstract String getDescription();

public String getName(){ return name; }

}

Metodo astratto non definito


Esempio 19

class Impiegato extends Person{

private double stipendio;

public Impiegato(String n, double s){ super(n); stipendio = s; }

public double getStipendio(){ return stipendio; }

public String getDescrizione(){ return “L'impiegato “ + super.getNome() +

“ guadagna “ + stipendio + “ euro”;}

}


Esempio 19

class Studente extends Person{

private String facolta;

public Studente(String n, String f){ super(n); facolta = f; }

public double getFacolta(){ return facolta; }

public String getDescrizione(){ return “Lo studente “ + super.getNome() +

“ è iscritto alla facoltà di “ + facolta;}

}


Esempio 19

class Esempio19{


Person people[] = new Person[2];people[0] = new People(“Pippo”); //ERRORE// non si può istanziare una classe astrattapeople[0] = new Impiegato(“Pluto”, 15000);people[1] = new Studente(“Paperino”, “lettere”);

for (int i = 0; i < people.length; i++){

Person p = people[i];System.out.println(p.getDescrizione());

}}

Notare: è stato creato un array di due elementi


Attributi protected e public

Nel metodo getDescrizione della classe Impiegato, per visualizzare il nome del dipendente utilizza il metodo “getNome()”. Perchè non può utilizzare l'attributo “nome”? L'attributo nome è un attributo della classe Person (superclasse), essendo privato, diventa inaccessibile alle sottoclassi. Come fare per renderlo accessibile? Si può definire l'attributo come protected. Un attributo protected è un attributo che può essere acceduto SOLO dalla sottoclassi. Un attributo può anche essere public e in questo caso è accessibile a tutti. Se non viene definito nulla è visibile a livello di package.


Attributi protected e public

IMPORTANTE: per privilegiare l'incapsulamento dei dati è necessario che gli attributi siano sembre privati e i metodi pubblici.


Suggerimenti

Quando si scrivono i programmi e si vuole utilizzare l'ereditarietà, tenete presente questi suggerimenti:1. Inserire le operazioni e i metodi comuni nella superclasse;2. Non utilizzare campi protected;3. Utilizzare l'ereditarietà solo se tutti i metodi ereditati hanno senso;


L'operatore instanceof

Alcune volte può essere necessario individuare la natura (intesa come classe) di un oggetto. L'operatore instanzeof può essere utilizzato a tale scopo:

Person p[] = new Person[2];p[0] = new Impiegato(...);p[1] = new Dirigente(...);

for (int i = 0; i < p.length; ++i){

if (p[1] instanceof Impiegato)...

else ....}


Object: la superclasse cosmica

Ogni qualvolta creiamo una classe, anche se questa NON estende alcuna classe, in realtà, estende implicitamente una superclasse: Object.La classe Object definisce alcune metodi “amministrativi”, ovvero di gestione della classe. È per questo che quando, attraverso l'operatore “.” in Eclipse, vedete l'elenco dei metodi di un oggetto, vi appaiono metodi che voi non avete mai definito nella classe.


Object: la superclasse cosmica

Quali sono i metodi che vengono forniti dalla classe Object?equals() : verifica se due oggetti ugualigetClass(): ritorna il nome della classe di cui l'oggetto è istanza

Potrebbe essere necessario eseguire una sovrascrittura di questi metodi


Metodo equals()

Impiegato a = new Impiegato(“pippo”, 15000);Impiegato b = new Impiegato(“pippo”, 15000);

if (a == b) system.out.print(“identici”);else system.out.print(“differenti”);

Cosa verrà stampato a video?

Sebbene i due oggetti contengano le stesse informazioni, l'operatore di uguaglianza verifica solo se l'indirizzo di memoria è uguale. Per cui, essendo due oggetti separati, avranno differente indirizzo di memoria e quindi differenti [...]


Metodo equals()

Quando si devono confrontare due oggetti, è necessario ricorrere al metodo equals(). Poiché ogni classe estende di default la classe Object, possiede già un metodo equals il quale però verifica SOLO se il contenuto nella cella di memoria è identico per cui, riferendoci all'esempio di prima, l'istruzione

if (a.equals(b)) system.out.print(“identici”);else system.out.print(“differenti”);

visualizzerà sempre la parola differenti. Bisogna quindi sovrascrivere il metodo equals() nel modo seguente:


Metodo equals()

public boolean equals(Impiegato i){

if (this.getNome().equals(i.getNome)) && this.getStipendio() == i.getStipendio()) return true;return false;}


Metodo getClass()

Il metodo getClass della classe Object ritorna un oggetto Class che rappresenta la classe di cui l'oggetto è istanza:

Impiegato i = new Impiegato(...);Class c = i.getClass();System.out.print(c.getName());

viene visualizzato il nome della classe dell'oggetto i.


InterfacceInterfacce

- capitolo 7 -


Ereditarietà multipla

Alcuni linguaggi di programmazione (ad esempio il C++) consentono ad una classe di ereditare metodi e attributi da più superclassi (ereditarietà multipla). In Java non esiste un concetto analogo: una classe può ereditare metodi e attributi da una sola superclasse. Una classe in Java però può implementare una o più interfaccia. Una interfaccia è una classe in cui i metodi non sono definiti. Una classe che implementa una interfaccia (o più interfacce) deve necessariamente implementare TUTTI i metodi delle interfacce. Di conseguenza una interfaccia non può essere istanziata.


Interfacce

DanceFloor

DanceGroup

ControlPanel

Band

Dancer

Aerobics

Waltz

Rumba

Cha-Cha-Cha

Salsa

Dance

Interface


Esempio 20

public interface Dance{

public int getTempo();public getBeat(int i);

}

public class Waltzer implements Dance{

public int getTempo(){return 750; }

...}


Interfacce fornite dal jdk

Le librerie di Java forniscono, tra le altre cose, un set di interfacce che possono essere utilizzare per creare delle classi che implementano i metodi definiti nelle interfacce. Tra queste prendiamo in esame l'interfaccia Cloneable. Per prima cosa definiamo il concetto di clonazione:


Metodo clone()

Supponiamo di avere il seguente codice:

Impiegato a = new Impiegato(“pippo”, 15000);Impiegato b = a;

a.setNome(“pluto”);

System.out.print(b.getNome());

Cosa verrà visualizzato a video?


Metodo clone()

IMPIEGATO

Nome = “pippo

salario = 15000

a

b


Metodo clone()

Quando si devono creare cloni di un oggetto è opportuno creare un metodo clone che esegue la clonazione. Supponiamo di aver definito tale metodo per la classe Impiegato, si avrà che:

Impiegato a = new Impiegato(“pippo”, 15000);Impiegato b = (Impiegato) a.clone();

a.setStipendio(25000);

System.out.print(b.getStipendio());


Metodo clone()

IMPIEGATO

Nome = “pippo

salario = 15000

a

b

IMPIEGATO

Nome = “pippo

salario = 15000

IMPIEGATO

Nome = “pippo

salario = 15000

IMPIEGATO

Nome = “pippo

salario = 15000


Metodo clone()

Per creare il metodo clone, è opportuno che la classe Impiegati implementa l'interfaccia Cloneable. Questa interfaccia definisce (ma non implementa) il metodo clone che verrà definito nella classe Impiegati:

class Impiegati implements Cloneable{

...

public Object clone(){

[ vedi pagina seguente ]}

}


Metodo clone()

...


Impiegato i = new Impiegato(this.getNome(), stipendio);return i;

}

...


Metodo clone()

Problema: cosa succede quando si clona un oggetto che possiede, tra i suoi attributi, degli altri oggetti (incapsulamento)?

Supponiamo che la classe Impiegati abbia, tra i suoi attributi, un attributo istanza della classe GregorianCalendar (data assunzione):

Impiegati a = new Impiegati(“pippo”, “21/06/2004”);Impiegati b = (Impiegato) a.clone();a.setDataAssunzione(“22/06/2004”);

quale sarà la data di assunzione di b?


Metodo clone()

IMPIEGATO

Nome = “pippo

salario = 15000

a

b

IMPIEGATONome = “pippo

salario = 15000

assun =

IMPIEGATO

Nome = “pippo

salario = 15000

IMPIEGATONome = “pippo

salario = 15000

assun =

GregorianCalendar


Metodo clone()

In questi casi è necessario dover clonare anche gli oggetti incapsulati:


Impiegato i = new Impiegato(this.getNome(), stipendio);i.setDataAssuzione(dataAssunzione.clone());return i;

}


EccezioniEccezioni

- capitolo 8 -


Classificazione

Una eccezione è un errore che si manifesta durante l'esecuzione di un programma. Esistono due macroaree di eccezioni:

- RuntimeException (cast difettoso, accesso ad array fuori dai limiti, puntatore nullo);- IOException (lettura di un file vuoto, apertura URL errato);

Bisogna cercare di intercettare qeuste eccezioni e agire di conseguenza.


Lancio di eccezioni

I metodi possono lanciare eccezioni, ma è necessario definire il tipo di eccezione lanciata:

public String readLine() throws IOException

In questo esempio, la funzione readLine ritorna una stringa ma può anche generare una eccezione di tipo IOException

All'interno della procedura, l'eccezione viene lanciata con la parola chiave throw

Vedi esempio seguente:


Esempio 21

public interface interfaccia1{

public void metodo1();}

public interface interfaccia2{

public void metodo2();}

public class miaClasse implements interfaccia1, interfaccia2{

// la classe DEVE implementare i metodi delle due interf.}

java uni pavia.pdf

Documents