Programma - Home di...

Laboratorio di Programmazione - Esercitazioni 1

✗ Esercizi (old)✗ Switch✗ Programmazione ad oggetti: costruttori, metodi,

la classe Frazione✗ Classi involucro✗ Overloading✗ Autoboxing / unboxing✗ Metodi statici

Programma...


Esercizio 13 – Numeri primi

Calcolare e stampare i primi 100 numeri primi – si ricordi che un numero primo è divisibile solo per 1 e per se stesso – per verificare che N sia primo, è sufficiente verificare che non sia divisibile per uno dei numeri maggiori di 1 e minori di N. Dal momento che 1 e 2 sono primi, si cominci la ricerca dei numeri primi a partire dal numero 3. Si ricordi inoltre che i numeri primi a parte il 2 sono sempre dispari.


Esercizio 14 – Numeri primi gemelli

Si definiscono numeri primi gemelli una coppia di numeri primi che differiscono tra loro di due unità (es. 5 e 7). Si modifichi il programma precedente per trovare le prime 4 coppie di numeri primi gemelli.




Programma...


Switch

true false

IF-ELSE

true

false

IF SWITCH

Val 1

Val 2

Val 1

Default

Selezione:

If, if-else e switch permettono di biforcare il flusso di controllo scegliendo tra due o più alternative.


Selezione: switchPer mezzo di “switch” possiamo operare una scelta tra più opzioni possibili...

Sintassi (errata!) ed esempio (errato):

int m = 2;switch (m) {Case 1:system.out.println(“m=1”);Case 2:system.out.println(“m=2”);system.out.println(“m è maggiore di 1”)case 3:system.out.println(“m=3”);system.out.println(“m è molto maggiore di 1”)default:system.out.println(“altro caso”)}

[NB: Manca “break”!!!!]

Opzione 1

Default

Opzione 2

Switch (espressione)


Esercizio 4

Si modifichi il codice scritto per l'esercizio 3 utilizzando “switch” [→ Il PC acquisisce due numeri interi e li divide nel caso in cui il divisore sia diverso da zero o da uno; avverte l'utente che non è possibile effettuare divisioni per zero qualora sia necessario e non effettua la divisione; si mostra offeso se gli viene chiesto di effettuare una divisione per uno e non effettua la divisione].


Soluzione 4// Se il divisore è diverso da zero effettua la divisioneswitch (divisore){case 0:

// In questo caso il divisore è pari a zero...out.println("Il divisore non puo' essere uguale a zero. La divisione non e' stata effettuata.");

case 1:// In questo caso il divisore è uguale a 1out.println("Sono un computer intelligente, non effettuo banali divisioni per uno!");

default:// Divisione interaquoziente = dividendo / divisore;resto = dividendo % divisore;

// Outputout.println("Quoziente: " + quoziente);out.println("Resto: " + resto);

} // switch


Soluzione 4 – Analisi degli erroriL'output che otteniamo è il seguente:


Soluzione 4 – Analisi degli errori

Una volta identificato il punto di ingresso nel blocco dello switch, la JVM esegue tutte le istruzioni contenute nel blocco!

E' necessario utilizzare un comando per forzare l'uscita dal blocco una volta che si siano eseguite le istruzioni associate al caso desiderato.

Tale istruzione è l'istruzione break, che forza l'uscita dal blocco corrente racchiuso tra parentesi graffe.

NB: non è necessario inserire il break nell'ultimo blocco (default).

Opzione 1

Default

Opzione 2

Switch (espressione)

break;

break;


Soluzione 4 (revisited)Aggiungendo quindi l'istruzione break:

// Se il divisore è diverso da zero effettua la divisioneswitch (divisore){case 0:

// In questo caso il divisore è pari a zero...out.println("Il divisore non puo' essere uguale a zero. La divisione non e' stata effettuata.");break;

case 1:// In questo caso il divisore è uguale a 1out.println("Sono un computer intelligente, non effettuo banali divisioni per uno!");break;

default:// Divisione interaquoziente = dividendo / divisore;resto = dividendo % divisore;

// Outputout.println("Quoziente: " + quoziente);out.println("Resto: " + resto);

} // switch




Programma...


Programmazione ad oggetti

Decomposizione di un problema:

Dividere il problema in sottoproblemi semplifica la soluzione del problema originale (si applica un approccio “dividi et impera” ripetutamente, finchè i sottoproblemi risultanti sono semplici da risolvere).

Nella programmazione Object-Oriented (OO), gli oggetti sono entità pensate per la risoluzione di particolari sottoproblemi.


Programmazione ad oggettiQuale sottoproblema deve risolvere un oggetto (cioè

l'istanza di una classe)?

Quali azioni deve svolgere per adempiere al proprio compito? → Metodi

Quali informazioni servono all'oggetto per svolgere il suo compito? → Variabili della classe, parametri nei metodi,

…

Quale interfaccia mostra ad altri oggetti?

Quali informazioni dovrà nascondere / mostrare agli altri oggetti → public, private, ...


La classe FrazioneNome della classe: Frazione (prog.utili.Frazione)(Help: E:\_Didattica_AA20082009_Programmazione\prog-1.5\prog\doc\index.html)

Task: Rappresentare delle frazioni e permettere di effettuare operazioni tra frazioni.

Informazioni necessarie (variabili di istanza): Numeratore, denominatore.

Operazioni necessarie (metodi pubblici, solo alcuni citati): - Frazione () → Crea una frazione con numeratore e denominatore dati (costruttore)- GetNumeratore () → per ottenere il numeratore- GetDenominatore () → per ottenere il denominatore- ...


Costruttori, metodi, variabili di istanza

Costruttore → permette di creare l'oggetto, in genere inizializzando alcune caratteristiche proprie dell'oggetto (es. numeratore e denominatore di una frazione).

Variabili di istanza → all'interno dell'oggetto, vengono memorizzate le informazioni che caratterizzano la particolare istanza; ad esempio, il numeratore e il denominatore di una frazione.

Metodi → Permettono di interagire con l'oggetto, ad esempio per ottenere il valore del numeratore e del denominatore di una frazione.


Esempi: ConsoleInputManager, Frazione

*******************************************************************************************

ConsoleInputManager in; // Dichiarazione di un'istanzain = new ConsoleInputManager(); // Costruzione dell'oggetto (istanza in)in.readInt(“Dammi un intero: “); // Invocazione di un metodo

*******************************************************************************************

Frazione fraz = new Frazione(5,2); // Dichiara e crea una nuova istanza della classe frazione che rappresenta la frazione 5/2 – Le variabili di istanza “numeratore” e “denominatore” saranno poste pari a 5 e 2 all'interno dell'istanza “fraz”

int numeratore;numeratore = fraz.getNumeratore(); // Invoca il metodo getNumeratore() per assegnare alla variabile “numeratore” il valore del numeratore dell'istanza fraz della classe Frazione.

*******************************************************************************************


Costruttori e metodi: sintassi*******************************************************************************************Costruttore:

<istanza> = new <costruttore>;

Esempio:

Frazione fraz;fraz = new Frazione(5,7); // Crea la frazione 5/7

*******************************************************************************************Metodi:

<istanza>.<nome metodo>;

Esempio:

int numeratore;numeratore = fraz.getNumeratore();

*******************************************************************************************


Classe Frazione

Per utilizzare la classe Frazione (così come abbiamo fatto per le classi ConsoleInputManager e ConsoleOutputManager) → dobbiamo importare la classe all'inizio del file .java.

La classe Frazione si trova in prog/utili/Frazione.class, quindi...

Import prog.utili.Frazione; // Importazione classe Frazione


Esercizio

Si scriva un programma che, dopo avere importato la classe Frazione, crei un'istanza di tale classe corrispondente alla frazione 17/16, quindi utilizzi i metodi getNumeratore e getDenominatore per mostrare a schermo numeratore e denominatore.


Soluzione/* Esempio di importazione e utilizzo della classe Frazione */

// Importimport prog.io.ConsoleOutputManager;import prog.utili.Frazione;

// Class Frazione1class Frazione1{

// Mainpublic static void main(String [] args){

// Dichiarazione variabiliint numeratore,denominatore;

// Dichiarazione oggettiConsoleOutputManager out;Frazione fraz;

// Creazione istanzeout = new ConsoleOutputManager(); // Creazione oggetto per la gestione dell'outputfraz = new Frazione(17,16); // Creazione oggetto frazione 17/16

// Utilizzo di metodi: esempionumeratore = fraz.getNumeratore();denominatore = fraz.getDenominatore();

// Outputout.println("Numeratore : " + numeratore);out.println("Denominatore: " + denominatore);

}}


Esercizio 3 (bis) – Somma frazioniSi scriva un programma che sia in grado di calcolare la somma di una sequenza di 4 frazioni;l'acquisizione di ogni frazione richiede l'acquisizione di numeratore e denominatore;nel caso in cui il numeratore sia uguale a zero, si proceda direttamente all'acquisizione della frazione successiva;nel caso in cui il denominatore sia uguale a zero, si termini il programma segnalando un errore.

Hint:Si modifichi il codice dell'esercizio 3 (ultima lezione) per l'utilizzo della classe Frazione.Si utilizzi il metodo “piu” per effettuare la somma tra frazione.Si utilizzi la documentazione del package prog per la sintassi del metodo “piu”.




Programma...


CastIn java sono definiti diversi tipi fondamentali (char, int, long, double, …)

Conversioni di tipo implicite:- sono consentite promozioni da un tipo ad un tipo più ampio:

int i = 0;long j;j = i + 10000000; // Cast: i viene promosso a long!

- non sono consentite promozioni da un tipo ad un tipo più ristretto; in questo caso la conversione deve essere “forzata”:

int i;long j = 0;i = j + 10; // Non ammesso!i = (int)j + 10; // Casting esplicito, ok


Esercizio

Si scriva un programma che calcoli la media m di tre numeri interi, (int x, y e z;). Si analizzi il

comportamento del programma a seconda del modo in cui viene calcolata la media:

int m; … m = (x+y+z)/3;double m; … m = (x+y+z)/3;

double m; … m = (x+y+z)/3.0;double m; … m = (double)(x+y+z)/3;

double m; … m = (double)(x+y+z)/3.0;


Conversioni implicite al tipo String

Abbiamo già utilizzato questa funzionalità...

ConsoloOutputManager out = new ConsoloOutputManager();out.println(“Ciao sono le “ + 5 + “ e mezza.”);

L'int 5 viene convertito automaticamente nella stringa “5”.




Programma...


Metodi statici● Si possono chiedere dei servizi ad una classe senza che

sia necessario creare un oggetto della classe stessa;● Es. per convertire un int in una stringa la classe String

mette a disposizione il metodo statico valueOf;● Non c'è bisogno di creare un oggetto String, il metod o è

definito static all'interno della classe;● Altri esempi di metodi statici: classe Math del package

java.lang, fornisce il metodo log....● Per invocare un metodo statico:

nome_classe.nome_metodo(lista_argomenti)


Esercizio● Si scriva un'applicazione per la risoluzione di un'equazione

di secondo grado {ax2+bx+c=0 → x1,2

=[-b+/-sqrt(b2-4ac)]/(2a)};

● Si assuma che i coefficienti a, b, c siano interi (devono essere acquisite come interi, si utilizzi il casting per avere dei double)

● La classe Math di java.lang mette a disposizione il metodo statico sqrt per il calcolo della radice quadrata (in ingresso prende un double);

● Mette anche a disposizione il metodo pow() per l'elevamento a potenza (→ si veda la guida della API di Java per maggiori dettagli);

● Si mostri a schermo il risultato creando una stringa per mezzo del metodo valueOf messo a disposizione da String.


Classi involucro, unboxing e autoboxing

● I tipi primitivi (int, char, long, ...) non sono oggetti (per questioni di efficienza)

● Esistono però le CLASSI INVOLUCRO che permettono di rappresentare i tipi primitivi come se fossero oggetti (utili in alcuni casi particolari).

● Es. classe Integerint a = 0; // tipo int, assegnamentoa = new Integer(0); // oggetto di tipo integer


Classe Integer: alcuni metodi

public Integer(int x); // costruttorepublic Integer(String str); // costruttorepublic int compareTo(Integer altro);public int intValue();public long longValue();public static int parseInt(String s); // metodo statico per la conversione da stringa a int


Unboxing e autoboxing (per la classe Integer)

● Unboxing → estrazione di un valore di tipo int da un oggetto di tipo IntegerInteger i =new Integer(234);int j = i.intValue();// Unboxingint k = i; // Unboxing automatico

● Autoboxing → “inscatolamento” di un valore di tipo int in un oggetto di tipo IntegerInteger i = 123; // Autoboxing


Esercizio● Si scriva un programma che acquisisca due

stringhe di cifre. Si utilizzi l'unboxing per calcolare la somma delle cifre inserite.

● Hint: Integer.parseInt() per trasformare da stringa a int; (unboxing)


Esercizio● Si scriva un programma che riceva in ingresso una stringa

dall'utente. Utilizzando la classe StringTokenizer del package java.util, si analizzi la stringa importata e si dica all'utente se essa è o non è composta da una sequenza di numeri (composto da una o più cifre) intervallate da spazi vuoti.

● Hint → per la classe StringTokenizer, si controlli la documentazione java.

● Hint → Character.isDigit(char) è un metodo statico della classe involucro Character per verificare che il carattere analizzato sia un numero.


Esercizio● Si estenda il programma precedentemente

scritto per fare in modo che venga visualizzata la somma delle cifre inserite nella stringa.

● Hint → E' necessario convertire da stringa a int... (metodo statico Integer.parseInt)



scritto per eseguire la somma tra un gruppo di frazioni, utilizzando il metodo appropriato della classe Frazione per la somma.

● Hint → per ogni frazione (token) bisogna controllare che sia presente il simbolo “/”, altrimenti il programma deve terminare con un errore.



scritto per fare in modo che possano essere effettuate le somme tra numeri interi e frazioni.

● Hint → un numero intero viene identificato come un numero in cui non compare il simbolo “/”


Esercizio (advanced!)● Si estenda il programma precedente per fare in

modo che possano essere sommati anche dei numeri di tipo double.

● Hint → un numero di tipo double contiene il carattere “.”;

● Hint → utilizzare due contatori per la somma: uno con la somma delle frazioni, uno con la somma dei double; alla fine della stringa, convertire da frazione a double e riportare il risultato in double.


Overloading● Metodi con lo stesso nome, ma con input

diversi.● Evita di implementare tanti metodi simili ma con

nomi diversi!● Esempio (classe ConsoleInputManager):

● double d = readDouble();● double d = readDouble(String prompt);

Programma - Home di...

Documents

Transcript of Programma - Home di...