Lucidi della lezione

Una introduzione al linguaggio Java
Prof. Giancarlo Fortino
[email protected]
a.a. 2004/2005
Algoritmi
• Definizione 1. Un algoritmo è una
procedura per risolvere un problema in un
numero finito di passi, che coinvolge
frequentemente
la
ripetizione
di
un’operazione; in senso lato: un metodo
passo-passo per realizzare un certo compito.
Algoritmi e Problemi
• Individuare un algoritmo risolutivo e
realizzarne
una
implementazione
utilizzando un qualsiasi linguaggio ha senso
solo per un problema generale poiché il
costo
iniziale
di
realizzazione
dell’algoritmo
è
compensato
dalla
possibilità di impiego ripetuto.
Esempi di problemi
•
•
•
•
Somma di 3 numeri x, y, z
Somma di N numeri
Numero massimo tra N numeri
Data una sequenza di N numeri sommare i
numeri uguali
• Calcolare la media e la varianza di una
sequenza di N voti…
Esempio 1 di Algoritmo:
programmazione di un VCR
Passo 1. Se le informazioni di clock e calendario non sono correttamente
fissate, vai a pag. 9 del manuale e segui le istruzioni prima di procedere
Passo 2: Poni un nastro vuoto nell’alloggiamento del nastro del VR
Passo 3. Ripeti i passi da 4. a 7. per ogni programma TV che desideri
registrare, per un massimo di 10 programmi
Passo 4. Inserisci il numero di canale che vuoi registrare e premi il tasto CHAN
Passo 5. Inserisci il tempo al quale deve iniziare la registrazione e premi il
tasto TIME-START
Passo 6. Inserisci il tempo al quale deve finire la registrazione e premi il tasto
TIME-FINISH
Passo 7. Se non desideri registrare altri programmi, premi il tasto END-PROG
Passo 8. Premi il tasto TIMER. Il VR è ora pronto per registrare.
Esempio 2 di Algoritmo:
calcolo del Massimo Comun Divisore (MCD) tramite
l’algoritmo di Euclide
Variabili di ingresso:
Variabili di uscita:
Variabili interne:
Passo 1.
Passo 2.
Passo 3.
Passo 4.
Passo 4.1.
Passo 4.2.
Passo 4.3.
Passo 4.4.
Passo 5.
Passo 6.
n, m di tipo intero >0
mcd di tipo intero >0
x, y, r di tipo intero >=0
leggi n ed m;
x=m;
y=n;
ripeti
dividi x per y e sia r il resto;
x=y;
y=r;
finche' r==0;
mcd =x;
scrivi mcd;
Perché realizzare Algoritmi ?
• Se è possibile scrivere un algoritmo per un
assegnato
problema
allora
è
possibile
automatizzarne la soluzione.
• L’esecuzione di tale algoritmo può essere affidata ad
un agente di calcolo (una persona o un calcolatore
elettronico).
• Non tutti i problemi sono risolubili algoritmicamente
(K. Godel, 1930).
Nozione formale di Algoritmo
• Definizione 2. Un algoritmo è una collezione ben
ordinata
di
operazioni,
non
ambigue
ed
effettivamente calcolabili, che quando eseguita
produce un risultato e termina in una quantità finita di
tempo.
• Le operazioni possono
condizionali e iterative.
essere
sequenziali,
Strutturazione di un programma
• Un programma è la realizzazione di un algoritmo
mediante un linguaggio di programmazione (es.,
Java, Pascal, C++, ecc.)
• La struttura base di un programma è la seguente:
– Dichiarazione delle variabili che servono per memorizzare
valori di INPUT, INTERMEDI e di OUTPUT
– Operazioni di INPUT
– Operazioni di Elaborazione
– Operazioni di OUTPUT
Algoritmi in Java “by example”
• Di seguito si propone una serie di algoritmi realizzati
in linguaggio Java con lo scopo di:
– evidenziare i tipi di operazione base (sequenziali,
condizionali, e iterative)
– descrivere le istruzioni ed i tipi base del linguaggio Java
– fornire esempi significativi sulla base dei quali costruire altri
esempi
Esempi di Programmi Java:
somma di 3 numeri interi
import fondamenti.inout.*;
public class Esercizio_Somma1 {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int x, y, z, somma;
//SEZIONE DI INPUT
x = Console.readInt(“x=”);
y = Console.readInt(“y=“);
z = Console.readInt(“z=“);
//SEZIONE DI ELABORAZIONE
somma=x+y+z;
//SEZIONE DI OUTPUT
System.out.println(“somma = "+somma);
}
}
Esempi di Programmi Java:
comparazione tra due numeri interi
import fondamenti.inout.*;
public class Esercizio_Compara {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int x, y, risultato;
//SEZIONE DI INPUT
x = Console.readInt(“x=”);
y = Console.readInt(“y=“);
//SEZIONE DI ELABORAZIONE
if (x>y) risultato = 1;
else if (x==y) risultato = 0;
else risultato = -1;
//SEZIONE DI OUTPUT
System.out.println(“risultato = "+risultato);
}
}
Esempi di Programmi Java:
inserimento di un numero intero >=0 e stampa del suo quadrato
import fondamenti.inout.*;
public class Esercizio_Quadrato {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int x, quadrato;
//SEZIONE DI INPUT
do
x = Console.readInt(“x=”);
while (x<0);
//SEZIONE DI ELABORAZIONE
quadrato = x*x;
//SEZIONE DI OUTPUT
System.out.println(“quadrato = "+quadrato);
}
}
Esempi di Programmi Java:
somma di una sequenza di N numeri interi
import fondamenti.inout.*;
public class Esercizio_Somma2 {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, x, conta=0, somma=0;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
//SEZIONE DI ELABORAZIONE + INPUT
while (conta<N){
x = Console.readInt(“x>”);
somma = somma + x;
conta = conta + 1;
}
//SEZIONE DI OUTPUT
System.out.println(“Somma = "+somma);
}
}
Esempi di Programmi Java:
visualizzare il numero massimo di una sequenza di N numeri interi
import fondamenti.inout.*;
public class Esercizio_Max {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, x, conta=1, max;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
//SEZIONE DI ELABORAZIONE + INPUT
max = Console.readInt(“x>”);
while (conta<N){
x = Console.readInt(“x>”);
if (x>max) max=x;
conta = conta + 1;
}
//SEZIONE DI OUTPUT
System.out.println(“Max = "+max);
}
}
Esempi di Programmi Java:
conteggio dei numeri selezionati 1 e 2 in una sequenza di N numeri
import fondamenti.inout.*;
public class Esercizio_ConteggioSelettivo {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, x, conta=0, conta1=0, conta2=0;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
//SEZIONE DI ELABORAZIONE + INPUT
while (conta<N){
x = Console.readInt(“x>”);
if (x==1) conta1=conta1+1;
else if (x==2) conta2=conta2+1;
conta = conta + 1;
}
//SEZIONE DI OUTPUT
System.out.println(“Conta1 = "+conta1+” Conta2=“+conta2);
}
}
Esempi di Programmi Java:
media di una sequenza di N numeri interi
import fondamenti.inout.*;
public class Esercizio_Media {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, x, conta=0, somma=0;
float media;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
//SEZIONE DI ELABORAZIONE + INPUT
while (conta<N){
x = Console.readInt(“x>”);
somma = somma + x;
conta = conta + 1;
}
media = somma/N;
//SEZIONE DI OUTPUT
System.out.println(“Media = "+media);
}
}
Esempi di Programmi Java:
calcolo del MCD tra due numeri interi
import fondamenti.inout.*;
public class Esercizio_MCD {
public static void main (String[] args) {
//SEZIONE DICHIARAZIONE
int x, y, resto, mcd;
//SEZIONE DI INPUT
x = Console.readInt(“x=”);
y = Console.readInt(“y=“);
//SEZIONE ELABORATIVA
do { resto=x%y;
x=y;
y=resto; }
while (resto!=0);
mcd=x;
//SEZIONE DI OUTPUT
System.out.println("mcd = "+mcd);
}
}
Istruzioni e dichiarazioni base di Java
• DICHIARAZIONI
– int x = 0; // dichiara una variabile di tipo intero e la inizializza
a zero
• INPUT
– Console.readInt(“****”); // legge un intero da console
• OUTPUT
– System.out.println(“****”+x); //stampa sul monitor il valore
della variabile x preceduto dal testo (o stringa) racchiuso dai
doppi apici
Istruzioni e dichiarazioni base di Java
• ELABORAZIONI
– Espr = espressione; // assegnamento del risultato di una
espressione alla variabile Espr.
• Es., s = x*y+z;
– if (condizione) istruzione1 else instruzione 2; // dove
condizione è una espressione booleana, istruzione1 e
istruzione2 sono istruzioni semplici o composte.
• Es., if (x>10) conta=conta+2; else conta=conta-1;
– {instruzionesemplice1;
istruzione composta.
instruzionesemplice2;
• Es., { x=x+1; y=y+2; if (x>10) t=t+10; }
…}
//
Istruzioni e dichiarazioni base di Java
• ELABORAZIONI
– do instruzione while (condizione); // esegue istruzione che
può essere semplice o composta finchè la condizione è vera
• Es., do {x=x+1; y=y+x;} while (x<10);
– while (condizione) istruzione; // esegue istruzione che può
essere semplice o composta finchè la condizione è vera
• Es., while (x<10) {x=x+1; y=y+x;}
I tipi “semplici” Java
• Interi
–
–
–
–
byte
word
int
long
{-128..127}
{-32768..32767}
{-2^31..(2^31)-1}
{-2^63..(2^63)-1}
• Reali
– float
– double
singola precisione
doppia precisione
• Booleani
– boolean
{true, false}
• Caratteri
– char
16-bit UNICODE. Es., ‘a’, ‘b’, ‘&’, ‘1’, ecc.
• Testo
– String
caratteri
“Giancarlo”, “java”, “Informatica”, qualsiasi sequenza di
Insiemi Fuzzy
• Consideriamo il concetto di Vecchio:
– in accordo agli insiemi “crisp” una persona può essere
vecchia o non vecchia cioè può appartenere all’insieme delle
persone vecchie oppure no. Quindi bisogna scegliere una
soglia di età (es., 65 anni) e affermare che da tale soglia in poi
si è vecchi altrimenti non si è vecchi.
– In accordo agli insiemi “fuzzy” una persona è vecchia con un
certo grado di vecchiaia. Quindi tale grado può essere
espresso da una funzione. Es., si può scegliere una spezzata
che è zero (o grado zero) fino ad una soglia d’età s1 e che
cresca linearmente fino al grado 1 in corrispondenza di una
soglia di età s2>s1.
• Per il concetto di Giovane possiamo fare le stesse
considerazioni.
Insiemi Fuzzy…
Vecchio e Giovane
1
0,9
0,8
0,7
0,6
0,5
0,4
0,3
0,2
0,1
0
Vecchio - fuzzy
Giovane - fuzzy
0
45
65
120
Esempi di Programmi Java:
calcolo del grado di vecchiaia e gioventù di N persone
import fondamenti.inout.*;
public class Esercizio_Fuzzy {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, eta, conta=0;
float vecchiaia, gioventu, eta;
//SEZIONE DI INPUT
N = Console.readInt(“Numero di Persone=”);
//SEZIONE DI ELABORAZIONE + INPUT + OUTPUT
while (conta<N){
eta = Console.readInt(“Età della “+(conta+1)+” persona>”);
if (eta<=45) vecchiaia = 0;
else if ( (eta>45) && (eta<65) ) vecchiaia=(eta-45)/20;
else vecchiaia=1;
if (eta<=45) gioventu = 1;
else if ( (eta>45) && (eta<65) ) gioventu=(65-eta)/20;
else gioventu=0;
System.out.println(“Grado di vecchiaia = "+vecchiaia);
System.out.println(“Grado di gioventù = "+gioventu);
conta=conta+1;
}
}
}
Memorizzazione di N valori con N non
conosciuto “a priori”
• Se si vogliono memorizzare N valori di tipo intero per poi
utilizzarli successivamente, si dovrebbero dichiarare tante
variabili intere per quanti valori interi si devono memorizzare.
Ma se N è molto grande e/o se non conosciamo a priori N il
metodo di dichiarare N variabili non è utilizzabile!
• Per dichiarare N variabili (con N non precisato) di uno stesso
tipo (es., int) si utilizza un nuovo tipo denominato ARRAY.
• Un array si dichiara nel seguente modo:
– int [] a, dove a è la variabile di tipo array che può contenere N
valori interi;
– a può essere vista come una riga di una tabella con N colonne;
Array monodimesionali
• a è un array di 10 elementi ognuno dei quali è un intero. Per
accedere all’i-esimo elemento si utilizza la notazione con
parentesi quadre [].
• Es., per accedere all’elemento con indice 2 bisogna scrivere
a[2]
a
10 1 11 34 -1 -7
0
1
2
3
4
5
5
5
6 10
6
7
8
• Per creare un array di 10 elementi interi si scrive:
• int [] a = new int[10].
• Gli elementi vengono inizializzati tutti a zero.
• int x = a[4] a cosa è uguale?
-1
• a[10] esiste?
NO
9
Esempi di Programmi Java:
somma di una sequenza memorizzata di N numeri interi
import fondamenti.inout.*;
public class Esercizio_SommaArray1 {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, conta=0, somma=0;
int [] a;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
a = new int[N];
while (conta<N){
a[conta] = Console.readInt(“a[”+conta+”]=“);
conta = conta + 1; // oppure conta++
}
//SEZIONE DI ELABORAZIONE
conta=0;
while (conta<N){
somma = somma + a[conta];
conta = conta + 1;
}
//SEZIONE DI OUTPUT
System.out.println(“Somma = "+somma);
}
}
Esempi di Programmi Java:
somma di una sequenza memorizzata di N numeri interi, versione 2
import fondamenti.inout.*;
public class Esercizio_SommaArray2 {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, somma=0;
int [] a;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
a = new int[N];
for (int x=0; x<N; x++)
a[x] = Console.readInt(“a[”+x+”]=“);
//SEZIONE DI ELABORAZIONE
for (int x=0; x<N; x++)
somma = somma + a[x];
//SEZIONE DI OUTPUT
System.out.println(“Somma = "+somma);
}
}
Esempi di Programmi Java:
visualizzazione di una sequenza memorizzata di N numeri interi
import fondamenti.inout.*;
public class Esercizio_Visualizza {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, conta=0, somma=0;
int [] a;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
a = new int[N];
while (conta<N){
a[conta] = Console.readInt(“a[”+conta+”]=“);
conta = conta + 1; // oppure conta++
}
conta=0;
//SEZIONE DI OUTPUT
while (conta<N){
System.out.println(“a[”+conta+”]=“+a[conta]);
conta = conta + 1; // oppure conta++
}
}
}
Calcolo della media e della varianza di una
sequenza di N voti
•
Dati N voti compresi tra 18 e 30;
•
Calcolare la media degli N voti;
N 1
Media =
•
i =0
Votoi
N
Calcolare la varianza degli N voti;
N 1
Varianza =
i =0
Media) 2
(Votoi
N
Esempi di Programmi Java:
calcolo della media e della varianza di N numeri interi (o voti)
import fondamenti.inout.*;
public class Esercizio_MediaVarianza {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, conta=0, somma=0;
float media, varianza=0;
int [] a;
//SEZIONE DI INPUT
N = Console.readInt(“N=”);
a = new int[N];
while (conta<N){
a[conta] = Console.readInt(“a[”+conta+”]=“);
conta ++;
}
conta=0;
//SEZIONE DI ELABORAZIONE
while (conta<N){
somma=somma+a[conta];
conta ++;
}
media = somma/N;
Esempi di Programmi Java:
calcolo della media e della varianza di N numeri interi (o voti)…
conta=0;
while (conta<N){
varianza = varianza + ((a[conta]-media)*(a[conta]-media));
conta ++;
}
varianza=varianza/N;
//SEZIONE DI OUTPUT
System.out.println(“Media=“+media);
System.out.println(“Varianza=“+varianza);
}
}
Stringhe
• Una Stringa è una sequenza di caratteri
• Il tipo stringa in Java è denominato String
• String s1 = “Fondamenti”;
• String s2 = “ d’Informatica”;
• String s = s1+s2; //concatenazione
• Quanto vale s?
“Fondamenti d’Informatica”
• Comparazione tra stringhe: s1.equals(s2) è true se s1 è uguale
a s2, altrimenti è false.
Esempi di Programmi Java:
comparazione tra stringhe inserite da console
import fondamenti.inout.*;
public class Esercizio_CompStringhe {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
String s1, s2;
//SEZIONE DI INPUT
s1 = Console.readString(“s1=”);
s2 = Console.readString(“s2=”);
//SEZIONE ELABORATIVA + OUTPUT
if (s1.equals(s2)) System.out.println(s1);
else System.out.println(s2);
}
}
Esempi di Programmi Java:
inserimento di N nominativi in un’agenda e ricerca di un nominativo
import fondamenti.inout.*;
public class Esercizio_RicercaNome {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
int N, conta=0;
String x;
String [] nominativi;
boolean trovato;
//SEZIONE DI INPUT
N = Console.readInt(“N>”);
nominativi = new String[N];
while (conta<N) {
nominativi[conta]=Console.readString(“Nome>”);
conta++;
} //SEZIONE ELABORATIVA
//ricerca
x = Console.readString(“Ricerca nome>”);
trovato = false; conta = 0;
while ( (conta<N) && (!trovato) ){
if (x.equals(nominativi[conta])) trovato=true;
else conta++;
} //SEZIONE OUTPUT
if (trovato) System.out.println(“Posizione=“+conta); else System.out.println(“Non trovato“);
}
}
Esecuzione di programmi Java
• Per eseguire un programma Java bisogna utilizzare un tool per
compilare il programma Java in codice intermedio detto
BYTECODE e poi bisogna impiegare un interprete che esegue
tale codice.
• Il Java SDK (Java Software Development Kit) fornito dalla Sun
Microsystems,
disponibile
gratuitamente
all’indirizzo
http://java.sun.com, permette di eseguire un programma Java.
• La versione corrente e stabile del tool è la 1.4.2.
• La compilazione viene fatta tramite il tool JAVAC
• L’esecuzione tramite il tool JAVA
• Es., editato e salvato il file prova.java
– prompt di dos> javac prova.java
– prompt di dos> java prova
Tipi composti (Classi senza metodi)
• Per costruire un nuovo tipo di dato si usa il costrutto CLASS.
• Il nuovo tipo avrà il nome della classe (Es., Studente)
• Es.:
public class Studente{
int Matricola;
String Nome, Cognome, CorsoLaurea;
Date anno_iscrizione;
}
• Studente s; //s è una variabile di tipo Studente
• s = new Studente(); //è stata creata un’istanza di Studente con
una inizializzazione di default mediante l’operatone new
•
s.Matricola=6513;
s.Nome=“Mario”;
s.Cognome=“Rossi”;
s.CorsoLaurea=“DES”; s.anno_iscrizione=new Date(“1/10/2002”); // il
valore di s è stato settato cioè alle singole variabili interne sono stati
assegnati valori
Esempio: Studenti, Esami, EsamiSostenuti
Descrizione
CorsoLaurea Data_Iscrizione
Lode
Cognome
Studente
0..n
Data
0..29
Esame
Voto
EsamiSostenuti
Nome
Matricola
Nome
Codice
• Modello logico relazionale:
– Studente(Matricola,
Nome,
Cognome,
CorsoLaurea,
Data_Iscrizione)
– Esami(Codice, Nome, Descrizione)
– EsamiSostenuti(Matr_Studente, Cod_Esame, Voto, Lode, Data)
Esempio: Studenti, Esami, EsamiSostenuti
• Modello logico ad Oggetti realizzato con Java:
public class Studente{
int Matricola;
String Nome, Cognome, CorsoLaurea;
Date Data_Iscrizione;
EsamiSostenuti [] esami;
}
public class EsamiSostenuti{
public class Esame{
byte Voto;
String Codice;
boolean lode;
String Nome;
Date Data;
String Descrizione;
Esame esame;
}
}
Esempio: Studenti, Esami, EsamiSostenuti…
import fondamenti.inout.*;
public class Esercizio_AddEsame {
public static void main (String[] args) {
//SEZIONE DI DICHIARAZIONE
Studente s1, s2;
Esami e1, e2;
EsamiSostenuti es1, es2, es3, es4;
//SEZIONE DI INPUT
s1 = new Studente(5555, “Mario”, “Rossi”, “DES”, new Date(“01/10/2001”));
s2 = new Studente(7777, “Luigi”, “Verdi”, “DES”, new Date(“20/10/2001”));
e1 = new Esame(101, “Introduzione all’Informatica”, “Il corso si propone…”);
e2 = new Esame(102, “Sistemi Informativi”, “Il corso prosegue…”);
es1 = new EsameSostenuti(27, false, new Date(“10/1/2002”), e1);
s1.addEsame(es1);
}
}