1. Dado
Scrivere un programma che usi la classe Random per simulare il lancio di un dado,
visualizzando un numero casuale compreso tra 1 e 6 ogni volta che viene richiesto.
Per questo creare una classe Dado ed una classe TestaDado seguendo il seguente
diagramma delle classi. La classe Dado deve permettere di creare un dado che possa
avere avere da 6 a 10 facce, in modo da permettere di giocare con più tipi di dado.
Classe Dado:
Dado()
- costruttore senza parametri: imposta il numero di facce a 6 come valore di
default e crea l’oggetto generatore per generare numeri casuali.
Dado(int nu)- costruttore che riceve in input il numero di facce desiderato: imposta il
numero di facce con il numero ricevuto in input e crea l’oggetto generatore per generare
numeri casuali.
lancia()
- il metodo ogni volta che è chiamato genera un numero intero casuale
compreso tra 1 ed il numero delle sue facce utilizzando l’oggetto generatore e lo
restituisce
classe LanciaDado
main()
– chiede di digitare il numero di facce del dado che si vuole utilizzare
e crea l’oggetto dado, poi in un ciclo chiede di digitare 1 per lanciare il dado o 2 per
uscire.
package dado;
import java.util.Random ;
public class Dado {
private int numeroFacce;
private Random gen;
//costruttore che crea un dado standard a 6 facce
public Dado() {
numeroFacce = 6;
// si inizializza l'oggetto gen della classe Random
gen = new Random();
}
//costruttore che crea un dado con il numero di facce richiesto
public Dado(int numFacce) {
numeroFacce = numFacce;
// si inizializza l'oggetto gen della classe Random
ITS A. Volta – programmazione java – Flavia Lollis
1
gen = new Random();
}
//cambia il numero di facce del dado
public void setFacce(int nuovoVal)
{
numeroFacce = nuovoVal;
}
/*simula il lancio del dado return il risultato del lancio*/
public int lancia() {
int result = gen.nextInt(numeroFacce) + 1 ;
return result;
}
}
package dado;
import java.util.Scanner;
public class LanciaDado {
public static void main(String[] args) {
Dado da;
Scanner leggi = new Scanner(System.in);
int facce, risLancio, scelta;
do
{
System.out.println("digita il numero di facce del dado (d 1 a
10)");
//utilizza la classe wrapper Integer per trasformare la stringa letta con
leggi.nextLine()
facce = Integer.parseInt(leggi.nextLine());
if (facce <1 || facce >10)
{
System.out.println("digitare un numero compreso tra 1 e 10");
}
} while(facce <1 || facce >10);
da = new Dado(facce);
do
{
do
{
System.out.println("digita:");
System.out.println("1 per lanciare il dado");
System.out.println("2 per terminare il programma");
scelta = Integer.parseInt(leggi.nextLine());
if (scelta < 1 || scelta > 2)
{
System.out.println("valore non ammmesso");
}
} while (scelta < 1 || scelta > 2);
if (scelta == 1)
{
risLancio = da.lancia();
System.out.println("Lancio del dado a " + facce + " facce: "
+ risLancio);
ITS A. Volta – programmazione java – Flavia Lollis
2
}
} while (scelta == 1);
}
}
2. modifica gioco dado
Modificare il programma precedente chiedendo con quanti dadi si vuole giocare, e
simulare il lancio di tutti i dadi contemporaneamente, dando come risultato la somma dei
lanci di ogni dado.
La classe Dado rimane invariata
Classe LanciaDadi:
main()
- chiede con quanti dadi si vuole giocare e poi esegue il costruttore
passandogli il numero dei dadi.
LanciaDadi(int nuDadi) - in un ciclo di nuDad volte chiede quante facce deve avere il
dado e lo crea salvandolo nel vettore dei dadi, poi chiema il metodo menu()
menu()
- in un ciclo chiede se si vuole lanciare o uscire dal programma. Nel caso di
lancio chiama il metodo lancia()
lancia()
- in un ciclo di nuDadi volte, esegue per ognuno dei dadi il metodo lancia() di
ogni dado, somma tutti i risultati dei lanci e dà in output il risultato.
package dado;
import java.util.Random ;
public class Dado {
private int numeroFacce;
private Random gen;
//costruttore che crea un dado standard a 6 facce
public Dado() {
numeroFacce = 6;
// si inizializza l'oggetto gen della classe Random
gen = new Random();
ITS A. Volta – programmazione java – Flavia Lollis
3
}
//costruttore che crea un dado con il numero di facce richiesto
public Dado(int numFacce) {
numeroFacce = numFacce;
// si inizializza l'oggetto gen della classe Random
gen = new Random();
}
//cambia il numero di facce del dado
public void setFacce(int nuovoVal)
{
numeroFacce = nuovoVal;
}
/*simula il lancio del dado return il risultato del lancio*/
public int lancia() {
int result = gen.nextInt(numeroFacce) + 1 ;
return result;
}
}
package dado;
import java.util.Scanner;
public class LanciaDadi {
Dado eleDadi[];
int numDadi;
Scanner leggi = new Scanner(System.in);
public static void main(String[] args) {
Dado da;
Scanner lettore = new Scanner(System.in);
int numero;
do
{
System.out.println("digita con quanti dadi vuoi giocare (da 1 a
5)");
//utilizza la classe wrapper Integer per trasformare la stringa letta con
leggi.nextLine()
numero = Integer.parseInt(lettore.nextLine());
if (numero <1 || numero > 5)
{
System.out.println("digitare un numero compreso tra 1 e 5");
}
} while(numero <1 || numero > 5);
new LanciaDadi(numero);
}
public LanciaDadi(int nu) {
int facce;
numDadi = nu;
eleDadi = new Dado[nu];
for (int i=0; i<nu; i++)
{
ITS A. Volta – programmazione java – Flavia Lollis
4
System.out.println("digita quante facce ha il dado " + (i+1));
facce = Integer.parseInt(leggi.nextLine());
eleDadi[i] = new Dado(facce);
}
menu();
}
public void menu(){
int scelta, risLancio=0;
do
{
do
{
System.out.println("digita:");
System.out.println("1 per lanciare il dado");
System.out.println("2 per terminare il programma");
scelta = Integer.parseInt(leggi.nextLine());
if (scelta < 1 || scelta > 2)
{
System.out.println("valore non ammmesso");
}
} while (scelta < 1 || scelta > 2);
if (scelta == 1)
{
risLancio=lancia();
System.out.println("il lancio dei dadi ha dato somma = " +
risLancio);
}
} while (scelta == 1);
}
public int lancia(){
int ris=0;
for (int i=0; i<numDadi; i++)
{
ris = ris + eleDadi[i].lancia();
}
return ris;
}
}
ITS A. Volta – programmazione java – Flavia Lollis
5
3. Lampadina
Costruire una lampadina che possa essere nello stato spenta, accesa o rotta, e cambia
stando facendo click su un bottone; ogni lampadina può cambiare stato un numero
prefissato di volte, e con il bottone daiStato si può sapere se è accesa, spenta o rotta.
Inoltre la lampadina per default fa luce bianca, ma su richiesta può fare luce colorata:
deve essere inoltre possibile sapere il colore della sua luce e quante volte ancora la si può
accendere e spegnere.
Classe lampadina:
Lampadina(): costruttore senza parametri che crea una lampadina di luce bianca con
numClick=10.Imposta stato=spenta, maxClick=10, contaClick=0, coloreLuce=bianco.
Lampadina (numMax) : costruttore lampadina con numMax possibilità di click che fa
luce bianca. Imposta stato=spenta,maxClick=numMax, contaClick=0, coloreLuce=bianca
Lampadina(numero, colore): costruttore lampadina con numMax possibilità di click che
fa luce co colore colore. Imposta stato=spenta, maxClick=numero, contaClick=0,
coloreLuce=colore.
click() : se stato=rotta dà una segnalazione di errore, altrimenti cambia lo stato della
lampadina ed aumenta il contatore
getNumClick() = restituisce il numero di click che sono stati fatti sulla lampadina
ancoraClick() = restituisce il numero di click che ancora si possono fare (maxClick –
contaClick)
Classe Testa Lampadina:
main() = deve chiedere i dati all’esecutore dei test (quanti click e colore della
lampadina);
Se non viene digitato nulla viene usato il primo costruttore.
Se non viene digitato il colore o se il colore è bianco crea la lampadina con il secondo
costruttore, altrimenti con il secondo.
Realizza inoltre un ciclo che termina a richiesta dell’esecutore del test, nel quale
l’esecutore del test può richiedere di fare alla lampadina le seguenti richieste:
ITS A. Volta – programmazione java – Flavia Lollis
6
click
dai stato lampadina
dai colore
dai quanti click posso ancora fare
package illumina;
import java.io.*;
import java.util.*;
public class TestaLampadine {
public static void main(String[] args){
Scanner leggi = new Scanner(System.in);
Lampadina la;
String colo, let;
int nClick, risp;
do
{
System.out.println("vuoi scegliere alcune caratteristiche della
lampadina?");
System.out.println("0 = no");
System.out.println("1 = si");
//leggo la riga digitata
let = leggi.nextLine();
//* trasformo la riga letta in un numero intero
risp = Integer.parseInt(let);
if ((risp != 0) && (risp !=1))
{
System.out.println("digitare 0 oppure 1");
}
} while ((risp != 0) && (risp !=1));
if (risp == 0)
{
la = new Lampadina();
} else
{
System.out.println("digita quanti click farà la lampadina");
nClick=Integer.parseInt(leggi.nextLine());
System.out.println("digita il colore della luce");
colo=leggi.nextLine();
la = new Lampadina(nClick, colo);
}
String lett="", ret="";
while (!(lett.equals("u")))
{
System.out.println("
System.out.println("
System.out.println("
fare ancora");
System.out.println("
System.out.println("
ITS A. Volta – programmazione java – Flavia Lollis
per testare la lampadina digitare :");
c per fare click");
q per sapere quanti click si possono
t per sapere lo stato della lamoadina");
u per uscire");
7
lett=leggi.nextLine();
if (lett.equals("c") )
{
ret = la.click();
if (!((ret).equals("")))
{
System.out.println(ret);
}
}
if (lett.equals("q") )
{
System.out.println("si possono fare ancora "+
(la.getMaxClick()-la.getNumClick())+ " click");
}
if (lett.equals("t") )
{
System.out.println("la lampadina è "+la.daiStato());
}
}
}
}
package illumina;
/**
* Class Lampadina
* fornisce una lampadina in grado di accendersi e spegnersi tramite un click.
* La lampadina controlla il suo stato e se viene superato il massimo numero di click
* passa allo stato di rotta e non si accende e spegne più
*
*
*/
public class Lampadina {
private int stato, maxClick, contaClick;
String coloreLuce;
public Lampadina (){
/**
* costruttore che imposta i valori di default
*/
maxClick=10;
stato=0;
contaClick=0;
coloreLuce="bianco";
}
public Lampadina (int m){
/**
* costruttore che imposta il massimo numero click che può fare
*/
maxClick=m;
stato=0;
ITS A. Volta – programmazione java – Flavia Lollis
8
contaClick=0;
coloreLuce="bianco";
}
public Lampadina (int m, String c){
/**
* costruttore che imposta il massimo numero click che può fare ed il colore
della luce
*/
maxClick=m;
stato=0;
contaClick=0;
coloreLuce=c;
}
public String click(){
String msg="";
contaClick++;
switch (stato) {
case 0 :
//* lampadina spenta se è stato l'ultimo click si rompe, se no si accende
if (contaClick == maxClick)
{
stato=2;
msg="lampadina si è rotta facendo click";
}
else
{
stato=1;
msg="ho acceso la lampadina";
}
break;
case 1 :
//* lampadina accesa se è stato l'ultimo click si rompe, se no si spegne
if (contaClick == maxClick)
{
stato=2;
msg="lampadina si è rotta facendo click ";
}
else
{
stato=0;
msg="ho spento la lampadina";
}
break;
case 2 :
msg="la lampadina è rotta non posso fare click";
break;
}
return msg;
}
public String daiStato(){
String st="";
switch (stato)
{
case 0: st="spenta";
ITS A. Volta – programmazione java – Flavia Lollis
9
break;
case 1: st="accesa";
break;
case 2: st="rotta";
break;
}
return st;
}
public int getStato(){
return stato;
}
public int getNumClick(){
return contaClick;
}
public int getMaxClick(){
return maxClick;
}
public int ancoraClick(){
return (maxClick - contaClick);
}
public void setColoreLuce(String co){
coloreLuce=co;
}
}
ITS A. Volta – programmazione java – Flavia Lollis
10
4. Trapano
Un trapano verticale si può muovere lungo le direzioni x,y di un piano per poi
fermarsi ed eseguire un foro. Il trapano nasce con una punta di un diametro
fissato, e un numero massimo di fori che per motivi di sicurezza si può fare con
quella punta.
L'operazione di foratura può avvenire solo a trapano acceso, mentre quella di
traslazione lungo gli assi x y solo se il motore del trapano è spento.
Realizza una classe Trapano che gestisca il funzionamento del trapano e
permetta di sapere in ogni momento se il trapano è acceso o spento e in quale
posizione si trova.
Per testare la classe, scrivere un programma TestTrapano che permette di
creare un’istanza della classe Trapano e di richiamare i metodi della stessa, in
modo coerente.
L’output, eseguito tramite System.out, deve essere presente solo nel
programma di test.
Descrizione metodi di Trapano
1)Trapano(pun, max) – costruttore che imposta le variabili globali punta e
maxFori con i parametri ricevuti, azzera numFori, posiziona il trapano
nell'origine degli assi ed inizializza lo stato del motore a spento
2)accendi() se il motore è spento lo accende, altrimenti dà messaggio
3)spegni() se il motore è acceso lo spegne, altrimenti dà messaggio
4)fora() controlla se il motore è acceso e se numero fori fatti < max fori: se sì
esegue il foro, altrimenti dà messaggio accendi motore o cambia punta e
spegne il motore
5)getStato() restituisce lo stato del motore;
6)sposta(sx, sy) se il motore è spento porta il trapano nella posizione di
coordinate (sx, sy); se il motore è acceso lo spegne e poi esegue il
posizionamento
7)getPosX() restituisce la posizione sull’asse x;
ITS A. Volta – programmazione java – Flavia Lollis
11
8)getPosY() restituisce la posizione sull’asse y;
descrizione main() di TestTrapano
Interagisce con l'esterno per chiedere la dimensione della punta e le coordinate
dei punti nei quali si vuole eseguire un foro, poi gestisce un ciclo chiede cosa si
vuole fare:
1. accendi trapano
2. spegni trapano
3. sposta trapano
4. fora
5. dai posizione trapano (coordinate x e y)
ITS A. Volta – programmazione java – Flavia Lollis
12
1. Modificare l'esercizio precedente in modo che il trapano esegua dei fori
lungo il segmento che unisce i punti di coordinate (-1, -2) e (5, 4)
2. Modificare l'esercizio precedente in modo da usare due trapani con punte
di dimensioni diverse eseguendo i fori lungo lo stesso segmento facendo i
fori di dimensione maggiore nei punti di ascissa pari
ITS A. Volta – programmazione java – Flavia Lollis
13
5. Squadra di baseball
Scrivere una programma java per gestire una squadra di giocatori di basket. Per ciascun
giocatore devono essere rilevati il nome come stringa, un punteggio che rappresenta il
numero di canestri fatti in campionato, la sua data di nascita ed il suo peso.
L’allenatore deve avere a disposizione un menù che gli permetta di:
1. inserire un nuovo giocatore rilevando tutti i suoi dati
2. eliminare un giocatore dopo averne indicato il nome
3. modificare il punteggio di un giocatore
4. avere l’elenco dei giocatori in ordine alfabetico
5. avere l’elenco dei giocatori in base al merito
6. uscire
Un giocatore è migliore di un altro se ha un punteggio più alto. A parità di punteggio è
considerato migliore il giocatore più giovane, a parità anche di età è migliore il giocatore
che pesa di meno: si consiglia di utilizzare per l’ordinamento
un metodo
migliore(Giocatore g) che confronta l’oggetto stesso con l’oggetto giocatore ricevuto come
parametro, cioé confronta il proprio punteggio con quello dell’altro oggetto, e se sono
uguali confronta le date di nascita, e se sono uguali anche le date di nascita confronta il
peso.
NB: per calcolare l’età di un giocatore bisogna confrontare l’anno di nascita del giocatore
con l’anno corrente. Il primo lo si estrae come sottostringa della data di nascita, per l’altro
si può utilizzare la classe Calendar, una classe astratta che fornisce i metodi per
manipolare la data corrente, e precisamente
int annoCorr = Calendar.getInstance().get(Calendar.YEAR);
ITS A. Volta – programmazione java – Flavia Lollis
14
6. Raccolta di cartoline
Si vuole registrare le cartoline scambiate tra un gruppo di amici. Il programma deve
rilevare tre elementi:
il nome del mittente
il nome del destinatario
il nome della località da cui la cartolina è stata inviata
Il programma offre le seguenti opportunità:
1. Aggiungi una cartolina
2. Cerca per mittente - stampa l’elenco degli amici che hanno ricevuto cartoline
dall’amico specificato e le località da cui sono state spedite le cartoline
3. Cerca per destinatario- stampa l’elenco degli amici che hanno spedito cartoline
all’amico specificato e le località corrispondenti
4. Cerca per località - stampa l’elenco degli amici che si sono scambiati cartoline delle
località corrispondenti
Classe Cartolina:
Cartolina(String m, String d, String l) – costruttore che riceve in input mittente,
destinatario e luogo
daiTesto()
- il metodo restituisce una stringa composta da : “cartolina spedita da “ ,
mittente , “ a “ destinatario , “ da “ , luogo
Classe Raccoglitore:
main()
- richiama il costruttore della classe
Raccoglitore() - costruttore senza parametri: chiede quante cartoline si pensa di
conservare, crea con questo numero il vettore di oggetti Cartolina e alla fine chiama il
metodo menu()
ITS A. Volta – programmazione java – Flavia Lollis
15
menu()
- propone in un ciclo il menù richiesto, legge la scelta fatta, ed in base alla
scelta chiama i relativi metodi.
addCart()
- chiede quante cartoline si vuole aggiungere, e poi in un ciclo, una alla volta
chiede i dati delle cartoline, crea l’oggetto Cartolina utilizzando il costruttore con parametri
e la mette nel vettore di cartoline del raccoglitore.
cercaMitt() - chiede di digitare il nome del mittente, e poi scorrendo il vettore di
cartoline confronta il nome del mittente di ogni cartolina con il nome cercato, e se sono
uguali emette a video la stringa restituita dal metodo daiTesto() della cartolina stessa
cercaDest() - chiede di digitare il nome del destinatario, e poi scorrendo il vettore di
cartoline confronta il nome del destinatario di ogni cartolina con il nome cercato, e se sono
uguali emette a video la stringa restituita dal metodo daiTesto() della cartolina stessa.
cercaLuogo() - chiede di digitare il nome del luogo da cui è stata inviata la cartolina, e poi
scorrendo il vettore di cartoline confronta il nome del luogo di ogni cartolina con il nome
cercato, e se sono uguali emette a video la stringa restituita dal metodo daiTesto() della
cartolina stessa.
9 Raccolta di cartoline modificata
Modificare il programma precedente aggiungendo anche la data di spedizione della
cartolina, e aggiungendo un metodo alla Cartolina che stabilisce se è uguale o meno ad
una cartolina ricevuta come parametro: due cartoline sono uguali se provengono dallo
stesso luogo nella stessa data, anche se mittente e/o destinatario sono diversi.
8. Treni speciali
Trenitalia vuole fornire alle agenzie viaggi un servizio di treni straordinari per organizzare
dei viaggi giornalieri in alcune città.
Un’agenzia può chiedere la costituzione di un treno speciale nella giornata desiderata, con
partenza da una determinata città, arrivo nel luogo da visitare e rientro in giornata nel
luogo di partenza.
Un treno ha dunque una città ed un orario di partenza e di arrivo, ed è composto da
vagoni passeggeri.
Ogni vagone passeggeri è di prima o di seconda classe, ha un costo giornaliero e un certo
numero di posti numerati che dipende dalla classe: i vagoni di prima classe hanno 40 posti
che costano 25 euro l’uno per la giornata, quelli di seconda classe ne hanno 56 e costano
18 euro al giorno.
Scrivere un programma che permetta a Trenitalia di creare e gestire i treni speciali delle
varie agenzie, in particolare che permetta di:
9)creare un nuovo treno rilevando il nome dell’agenzia che lo richiede, il giorno della
prenotazione, città e orario di partenza ed arrivo, (anche per il ritorno), il numero di
vagoni di prima e seconda classe richiesti.
ITS A. Volta – programmazione java – Flavia Lollis
16
10)Aggiungere un vagone ad un treno
11)togliere un vagone ad un treno
12)prenotare dei posti su un treno
13)calcolare l’incasso che porta l’effettuazione del treno
ITS A. Volta – programmazione java – Flavia Lollis
17
ITS A. Volta – programmazione java – Flavia Lollis
18
