CompitoB

Prova d’Esame 07.04.2006 — Compito B
DOMANDA 1 (6 punti)
Si analizzi il codice seguente e si scriva l’output prodotto dai metodi main
public class General {
public static String s1 = "ciao";
protected int n;
public General() { n = 3; }
public General(int startVal) {
n = startVal;
}
public String getSaluto() {
return s1;
}
public int incValue() {
return n++;
}
}
public class Special extends General {
private int v;
public Special() {
if (n != 0) v = n;
else v = 0;
}
public int getValue() {
return v + s1.length();
}
public void raiseValue() { v = v + n; }
public String personal(String name) {
if (name != null)
return s1 + " " + name;
return s1 + " no name";
}}
public class CustomException extends Exception {
public CustomException(String arg0) { super(arg0); }
public String getMessage(String note) {
return getMessage() + note;
}
}
--------------------------------------------------------------------import java.io.IOException;
public class Job {
public static Eprom source = null;
private int cv;
public Job(int initialPower) {
cv = initialPower;
}
public void doJob() throws CustomException,IOException {
if (source == null)
throw new IOException();
try {
if (!source.readData(cv))
throw new CustomException("No Power");
} catch (IOException e) {
source.start();
throw new CustomException ("Eprom Started");
}
}
public void addPower(int delta) { cv = cv + delta; }
}
public class Main {
public static void main(String[] args) {
String s1 = new String("Ciao");
Special xS = new Special();
General xG = new General();
if (s1 == General.s1) General.s1 = "Hello";
while (xS.getValue() < 14) {
System.out.println(xG.getSaluto() + "-"
+ xS.incValue());
xS.raiseValue();
}
System.out.println(xS.personal(""));
s1 = "cheers";
if (s1 != General.s1)
System.out.println(xS.personal("62"));
else
System.out.println(xS.personal("64"));
}}
public class Eprom {
private boolean setup = true; String model;
public Eprom(String m) { model = m; }
public void start() throws CustomException {
if (setup)
throw new CustomException("(Eprom running)");
setup = true;
}
public boolean readData(int v) throws java.io.IOException {
if (!setup)
throw new java.io.IOException("setup required: "+model);
if (v < 208) return false;
else return true;
}}
-------------------------------------------------------------------------public class Main {
public static void main(String[] args) {
Job action = new Job(200);
boolean again = true;
while (again) {
try {
action.doJob();
again = false;
} catch (CustomException e) {
System.out.println(e.getMessage());
action.addPower(5);
} catch (java.io.IOException e) {
Job.source = new Eprom("X25");
System.out.println("Eprom X25 Ready");
}
} }}
Prova d’Esame 07.04.2006 — Compito B
Si realizzi un sistema software per la gestione di un’officina per veicoli.
Esistono due tipi di veicoli, le auto e le moto, ognuno dei quali è caratterizzato dal nome del modello.
Più nel dettaglio, ogni auto è caratterizzata dal tipo di alimentazione (benzina, diesel, gpl, metano), dal
numero di chilometri percorsi e dal numero di tagliandi eseguiti sull’auto stessa.
Sono previsti inoltre due casi particolari di auto: le auto sportive, che possono essere alimentate solo a
benzina e per le quali è specificata la cilindrata del motore (un intero positivo che indica i centimetri
cubi), e i suv (sport utility vehicle), ai quali è invece associato il tipo di trazione (integrale, trazione
anteriore, trazione posteriore).
Ogni moto, invece, ha come caratteristiche il peso (un intero positivo che indica il numero di kg), la
cilindrata del motore (un intero positivo che indica i centimetri cubi) ed una serie di regolazioni,
ciascuna delle quali è rappresentata da un campo che può assumere un valore numerico intero compreso
tra un valore minimo (considerato pari a 5) ed un valore massimo (considerato pari a 9).
Una moto può essere o un motard o una moto stradale. Nel primo caso (motard), la moto ha 5
regolazioni ed un campo che specifica la marca delle gomme; nel secondo (moto stradale), c’è un campo
che specifica se la moto ha in dotazione i ricambi per la pista (il kit racing) o meno e sono previste 9
regolazioni.
L’officina è costituita da un meccanico per le auto ed uno per le moto e gestisce una lista di veicoli in
attesa di essere riparati. Tale coda può contenere al massimo 18 unità. Le riparazioni che l’officina deve
essere in grado di fare sono il tagliando per suv e auto sportive e l’impostazione delle regolazioni per i
motard.
Ogni meccanico che lavora nell’officina è caratterizzato dal nome.
In particolare, il meccanico delle auto deve essere in grado di eseguire il tagliando ad un’auto
specificata, mentre il meccanico delle moto deve poter impostare una serie di regolazioni alla moto
specificata.
DOMANDA 2 (2 punti)
Il candidato modelli il sistema software specificato nel seguito individuando i diversi componenti che lo
costituiscono e le relazioni fra di essi (ereditarietà/uso).
Prova d’Esame 07.04.2006 — Compito B
DOMANDA 3 (3 punti)
Con riferimento al sistema descritto nella domanda 2, si implementino la seguente classe ed i metodi
specificati, definendo se necessario il costruttore opportuno. Si verifichi poi il corretto funzionamento
dell’applicazione eseguendo il main implementato nella classe TestOfficina.
Classe Officina: modella l’officina
9 public void tagliandiAutoSportive()
fa eseguire al meccanico auto dell’officina il tagliando alle sole auto sportive presenti nella coda dei
veicoli associata all’officina. Ogni auto sportiva che, dopo la verifica e l’eventuale fase di esecuzione
del tagliando, non necessita di ulteriori tagliandi, va rimossa dalla coda.
9 public void tagliandiSuv()
Analogo al metodo precedente ma per i Suv.
9 public void regolazioneMotard(String modello, String regolazioni) throws VehicleException
cerca il modello specificato come parametro di ingresso tra i veicoli in lista e, in caso sia presente, fa
eseguire al meccanico delle moto la regolazione della moto. A regolazione ultimata, il motard va
rimosso dalla coda dei veicoli.
Se la moto non viene trovata, il metodo stampa un messaggio costituito dal nome della moto cercata
seguito dalla stringa “: non trovato”.
9 public void inserisci(Veicolo v)
aggiunge un veicolo alla lista dei veicoli in attesa di riparazione. Il numero massimo di veicoli che
possono essere presenti in coda è di 18 unità. Se si cerca di inserire un veicolo quando la coda è
piena, deve essere stampato il messaggio “Coda Piena”.
NOTA: non si definisca alcun package!
Prova d’Esame 07.04.2006 — Compito B
DOMANDA 4 (10 punti)
Si realizzi un’interfaccia grafica per la gestione dell’analisi delle rilevazioni cronometriche di una gara
di SuperBike contenute nel file di testo di nome dataB.txt. Tale file è organizzato per righe secondo la
seguente struttura:
− una linea formata dalla stringa “pilota:” seguita dal nome del pilota;
− 21 linee relative a 21 giri della gara (dal secondo al ventiduesimo), ognuna delle quali è così
strutturata:
lapNum <b> vel <b> s1 <b> s2 <b> s3 <b> s4 <b> tot
dove lapNum è il numero del giro; vel è la massima velocità raggiunta nel giro; s1, s2, s3, s4
sono le rilevazioni cronometriche (in secondi) sui vari settori che compongono il giro
(sommando tali tempi si ottiene il tempo totale); tot è il tempo totale di percorrenza del giro e
<b> è un carattere di spazio;
− una linea vuota.
Tale struttura si ripete per i diversi piloti.
L’interfaccia deve comprendere una finestra di nome Filtro ed un pannello, costituito da due etichette (di
nome “Pilota” e “Miglior Giro”), tre campi di testo (di cui uno, editabile, inizializzato con la stringa
“inserire nome”, e gli altri due non editabili) e tre bottoni (di nome “Cerca”, “Salva” e “Clear”) come
mostrato in figura 1.
Figura 1
Come indicato in figura 1, la prima casella di testo deve permettere all’utente di inserire il nome del
pilota. La ricerca è avviata premendo il bottone “Cerca” e produce (vedi figura 2):
9 nella casella di testo non editabile sotto l’etichetta “Miglior Tempo”: il miglior tempo sul giro (in
minuti e secondi) e il numero del giro in cui è stato ottenuto, oppure la stringa “NOT FOUND” se il
pilota non è tra quelli presenti nel file dataB.txt
9 nella casella di testo non editabile sotto il bottone “Cerca”: il valore della velocità massime raggiunta
nel miglior giro; oppure la stringa “NOT FOUND” se il nome del pilota non è nel file data.txt
Figura 2
Prova d’Esame 07.04.2006 — Compito B
Ogni pressione del bottone “Clear” riporta l’interfaccia alla visualizzazione iniziale (figura 1).
Ogni pressione del bottone “Salva” deve aggiungere ad un file (di nome results.txt) le informazioni
riassuntive sul pilota visualizzato dall’interfaccia al momento della pressione del tasto. In particolare, i
dati nel file results.txt sono strutturati secondo il formato seguente:
<nome del pilota>
Miglior giro: <miglior tempo sul giro e relativo numero del giro>
Massima velocità sul giro: <velocità massima raggiunta nel miglior giro>
………………………….
Ad esempio, se le informazioni visualizzate sono quelle in figura 2, nel file verranno aggiunte le
seguenti:
corser troy
Miglior giro: 1'33.165 (2)
Massima velocità sul giro: 306,3
………………………….
Nel caso le caselle di testo contengano la stringa “NOT FOUND” oppure sia stato premuto il tasto
“Clear” e quindi non è visualizzato niente, non deve essere aggiunto alcunché al file.
Suggerimento per l’interfaccia grafica: per favorire la disposizione dei componenti nel pannello, è
possibile specificare la seguente linea di codice prima di procedere con l’aggiunta di etichette di testo e
bottoni
setLayout(new GridLayout(2, 4, 5, 5));
che imposta per il pannello una griglia di 2 righe e 4 colonne. L’inserimento dei componenti parte dalla
casella in alto a sinistra della griglia e procede per righe.
Prova d’Esame 07.04.2006 — Compito B
DOMANDA 5 (punti 7)
Si implementi una struttura ad albero che rappresenta un albero genealogico. L’albero contiene il nome
di ciascuno dei membri della genealogia.
Ogni elemento dell’albero può avere al massimo 3 discendenti.
Deve essere possibile:
− inserire il discendente di un avo, con le opportune verifiche sull’esistenza dell’avo e sulla
possibilità effettiva di aggiungervi un discendente
− cercare un elemento e stampare il nome del padre.
Si realizzi poi una classe che, sfruttando le funzionalità implementate, costruisce l’albero in figura 3 e
stampa il nome del genitore di X2
P
Q
T
R
U
V
S
W
Z
X
X1
Y
X2
X3
Figura 3
Nota: non è consentito l’uso delle classi del Java Collection Framework o di classi del JDK contenenti
implementazioni di strutture ad albero. L’implementazione dell’albero è parte integrante dell’esercizio