Tema n. 1

Tema n. 1
import competenze.*;
public class TestCompetenze {
public static void main(String[] args) {
String[] v; Org Org1 = new Org();
try{
Competenza c1 = Org1.newCompetenza("java", "programmazione java");
Org1.newCompetenza("c++", "programmazione c++");
Org1.newCompetenza("uml", "modellazione ad oggetti");
Org1.newCompetenza("cs", "progetto sistemi client/server");
Org1.newCompetenza("er", "modellazione er");
String[] v1 = {"java"};
String[] v2 = {"uml", "cs", "java"};
String[] v3 = {"uml", "er"};
String[] v4 = {"uml", "cs", "java", "c++"};
Attività a1 = Org1.newAttività("Analisi s1", v1);
Attività a2 = Org1.newAttività("Progetto s1", v2);
Utente u1 = Org1.newUtente("U1", v3);
Org1.newUtente("U2", v2);
Org1.newUtente("U3", v4);
System.out.println(a2); System.out.println(u1);
} catch (OrgEccezione e){System.out.println(e.getMessage());}
System.out.println(Org1.elencoCompetenzeRichieste());
System.out.println(Org1.elencoCompetenzePossedute());}}
Risultato
Progetto s1[cs, java, uml] nota: competenze ordinate; da println(a2)
U1[er, uml] nota: competenze ordinate; da println(u1)
[java: nR=2 nP=2, cs: nR=1 nP=2, uml: nR=1 nP=3, c++: nR=0 nP=1, er: nR=0 nP=1]
[uml: nR=1 nP=3, cs: nR=1 nP=2, java: nR=2 nP=2, c++: nR=0 nP=1, er: nR=0 nP=1]
Si implementino le classi usate nel programma di test precedente; tali classi si trovano nel
package competenze.
Note
newCompetenza nomeCompetenza, descrizione:
genera un'eccezione se nomeCompetenza è null oppure è ripetuto
newAttività nomeAttività, elenco competenze richieste
genera un'eccezione se nomeAttività è null o è ripetuto
oppure se una competenza nell'elenco non è stata definita
o è già stata richiesta per l'attività corrente
newUtente nomeUtente, elenco competenze possedute
genera un'eccezione come nel caso precedente
elencoCompetenzeRichieste
stampa l'elenco delle competenze ordinate in modo decrescente
in base al numero delle attività richiedenti; a parità di n. richiedenti
vale l’ordine alfabetico delle competenze; si usi un oggetto comparatore
elencoCompetenzePossedute
stampa l'elenco delle competenze ordinate in base al numero degli utenti
possessori; stesse modalità del caso precedente
Suggerimento
In ogni oggetto Competenza si registrino il n. di attività che la richiedono
e il n. di utenti che la posseggono.
Si raccomanda la massima chiarezza.
1
classe OrgEccezione
classe package competenze;
public class OrgEccezione extends Exception {
OrgEccezione(String s) {super(s);}}
classe Competenza
package competenze;
public class Competenza {
String c; String d;
int nRichieste = 0; int nPossedute = 0;
Competenza(String c, String d) {this.c = c; this.d = d;}
public String toString(){
return c + ":" + " nR=" + nRichieste + " nP=" + nPossedute;}}
classe Attività
package competenze;
import java.util.TreeMap; import java.util.Map;
public class Attività {
private String a;
Map competenze = new TreeMap();
Attività(String a) {this.a = a;}
public String toString(){return a + competenze.keySet();}}
classe Utente
package competenze;
import java.util.TreeMap; import java.util.Map;
public class Utente {
private String u;
Map competenze = new TreeMap();
Utente(String u) {this.u = u;}
public String toString(){return u + competenze.keySet();}}
2
classe Org
package competenze;
import java.util.ArrayList; import java.util.Collections;
import java.util.Comparator; import java.util.HashMap;
import java.util.List; import java.util.Map;
public class Org {
private Map competenze = new HashMap();
private Map attività = new HashMap();
private Map utenti = new HashMap();
public Competenza newCompetenza(String c, String d) throws OrgEccezione {
if (c == null) throw new OrgEccezione("competenza nulla");
Competenza c1 = new Competenza(c,d);
Object prev = competenze.put(c, c1);
if (prev != null) throw new OrgEccezione("competenza esistente:" + c);
return c1; }
public Attività newAttività(String a, String[] v) throws OrgEccezione {
if (a == null) throw new OrgEccezione("attività nulla");
Attività a1 = new Attività(a);
Object prev = attività.put(a, a1);
if (prev != null) throw new OrgEccezione("attività duplicata:" + a);
for (int i = 0; i < v.length; i++) {
String c = v[i];
Competenza c1 = (Competenza) competenze.get(c);
if (c1 == null) throw new OrgEccezione("competenza inesistente:" + c);
else {
Competenza c2 = (Competenza) a1.competenze.get(c);
if (c2 != null) throw new OrgEccezione("competenza già richiesta:"
+ c + " da " + a);
else {a1.competenze.put(c, c1); c1.nRichieste++;}
}
}
return a1;}
public Utente newUtente(String u, String[] v) throws OrgEccezione {
if (u == null) throw new OrgEccezione("utente nullo");
Utente u1 = new Utente(u);
Object prev = utenti.put(u, u1);
if (prev != null) throw new OrgEccezione("utente esistente:" + u);
for (int i = 0; i < v.length; i++) {
String c = v[i];
Competenza c1 = (Competenza) competenze.get(c);
if (c1 == null) throw new OrgEccezione("competenza inesistente:" + u);
else {
Competenza c2 = (Competenza) u1.competenze.get(c);
if (c2 != null) throw new OrgEccezione("competenza già richiesta:"
+ c + " da " + u);
else {u1.competenze.put(c, c1); c1.nPossedute++;}
}
}
return u1;}
3
public String elencoCompetenzeRichieste() {
Comparator ordineR = new Comparator() {
public int compare(Object o1, Object o2) {
Competenza c1 = (Competenza) o1;
Competenza c2 = (Competenza) o2;
if (c2.nRichieste == c1.nRichieste) return c1.c.compareTo(c2.c);
return new Integer(c2.nRichieste).compareTo(new Integer(c1.nRichieste));
}};
List l1 = new ArrayList(competenze.values());
Collections.sort (l1, ordineR); return l1.toString();}
public String elencoCompetenzePossedute() {
Comparator ordineP = new Comparator() {
public int compare(Object o1, Object o2) {
Competenza c1 = (Competenza) o1;
Competenza c2 = (Competenza) o2;
if (c2.nPossedute == c1.nPossedute) return c1.c.compareTo(c2.c);
return new Integer(c2.nPossedute).compareTo(new
Integer(c1.nPossedute));
}};
List l1 = new ArrayList(competenze.values());
Collections.sort (l1, ordineP); return l1.toString();}
}
4
Si progetti un’interfaccia
grafica
che
consenta
l’inserimento
delle
competenze e delle attività
relative al package di cui al
punto 1. Per inserire una
competenza si scrive il
nome nella prima casella, la
descrizione nella seconda e
si preme il pulsante
NewCompetenza;
per
inserire un’attività si scrive il nome nella prima casella, l’elenco delle competenze
separate da virgole nella seconda e si preme il pulsante NewAttività; per avere l’elenco
delle competenze richieste si preme il pulsante ElencoCR. L’interfaccia è realizzata dalla
classe Gui che usa il package competenze del punto 1. L’area di testo centrale è usata per
mostrare le eccezioni dei primi due comandi e il risultato del terzo.
Nel caso del comando NewAttività si usi uno StringTokenizer per estrarre le competenze
dalla stringa (ad es. “uml,cs,java”) letta dalla seconda casella di testo per poi collocarle
nel vettore da passare al metodo NewAttività della classe Org.
Si indichino gli attributi della classe Gui e si scriva il metodo ActionPerformed.
Attributi di Gui
private
private
private
private
JTextArea ta;
JTextField tf1;
JTextField tf2;
Org org1 = new Org();
metodo ActionPerformed
public void actionPerformed(ActionEvent e)
{
String actionCommand = e.getActionCommand();
ta.setText("");
if (actionCommand.equals("NewCompetenza")){
String n = tf1.getText();
String d = tf2.getText();
try{org1.newCompetenza(n, d); ta.setText("added");
} catch (OrgEccezione ex){ta.setText(ex.getMessage());}
}
else if (actionCommand.equals("NewAttività")) {
String n = tf1.getText();
String s = tf2.getText();
StringTokenizer st = new StringTokenizer(s,",");
String[] v = new String[st.countTokens()];
for (int i = 0; st.hasMoreTokens(); i++ ) {
v[i] = st.nextToken();}
try{org1.newAttività(n, v); ta.setText("added");
} catch (OrgEccezione ex){ta.setText(ex.getMessage());}
}
else if (actionCommand.equals("ElencoCR")) {
ta.setText(org1.elencoCompetenzeRichieste());
}
}
5
Tema n.2
import biblioteca.*;
public class TestPrestiti {
public static void main(String[] args) {
Biblioteca bib = new Biblioteca();
try{
Libro l1 = bib.newLibro("titolo1", 1);
bib.newLibro("titolo2", 2);
bib.newLibro("titolo3", 3);
Utente u1 = bib.newUtente("utente1", 1);
bib.newUtente("utente2", 3);
int c1 = bib.newPrestito("utente1", "titolo1");
bib.restituzione("utente1", c1);
int c2 = bib.newPrestito("utente1", "titolo3");
int c3 = bib.newPrestito("utente2", "titolo1");
}catch(BiblioEccezione e){System.out.println(e.getMessage());}
System.out.println(bib.graduatoriaLibri());
System.out.println(bib.prestitiInCorso());}}
Risultati
[titolo1:2, titolo3:1, titolo2:0]
[titolo1:100(utente2), titolo3:103(utente1)]
Si implementino le classi usate nel programma di test precedente; tali classi si trovano nel
package biblioteca. Tutti gli attributi di tali classi devono essere privati.
Note
newLibro titolo, nVolumi: genera nVolumi disponibili per il libro dal titolo
dato; produce un’eccezione se titolo è null oppure è ripetuto o nVolumi <= 0.
Ogni volume ha un numero progressivo univoco a partire da 100.
newUtente nome, maxVolumi: genera un utente con il nome dato e stabilisce il n.
max di volumi che può prendere in prestito simultaneamente; produce
un’eccezione se nome è null oppure è ripetuto o maxVolumi <= 0.
newPrestito utente, titolo: genera un prestito e fornisce il codice del volume;
produce un’eccezione se utente/titolo è null oppure non esiste o l’utente ha
raggiunto il max numero di libri in prestito o non c’è alcun volume
disponibile. Un prestito è una coppia di riferimenti: volume, utente.
restituzione utente, codice; restituisce il volume con il codice dato; produce
un’eccezione se utente/titolo è null oppure non esiste o il codice non si
riferisce ad un volume preso in prestito dall’utente.
graduatoriaLibri fornisce l’elenco dei libri ordinati in base al n. dei
prestiti totali e a parità di tale numero in base al titolo; si usi un
comparator.
prestitiInCorso fornisce l’elenco dei prestiti in corso ordinati in base al
titolo e al codice del volume.
Si raccomanda la massima chiarezza.
6
package biblioteca;
public class BiblioEccezione extends Exception {
BiblioEccezione(String s) {super(s);}}
package biblioteca;
public class Libro {
private String titolo; private Volume[] volumi; private int nPrestiti = 0;
Libro(String titolo, int n){
this.titolo = titolo; volumi = new Volume[n];
for (int i = 0; i < volumi.length; i++) volumi[i] = new Volume(this);}
String getTitolo(){return titolo;}
int getNPrestiti() {return nPrestiti;}
Volume getVolume() {
for (int i = 0; i < volumi.length; i++){
Volume v = volumi[i];
if (v.getDisp()) {v.setDisp(false); nPrestiti ++; return v;}}
return null;}
public String toString(){return titolo + ":" + nPrestiti;}
}
package biblioteca;
class Volume {
private static int nuovoCodice = 100;
private int codice; private boolean disp = true;
private Libro libro;
Volume(Libro l){libro = l; codice = nuovoCodice++;}
boolean getDisp () {return disp;}
void setDisp(boolean val) {disp = val;}
int getCodice(){return codice;}
Libro getLibro() {return libro;}
}
7
package biblioteca;
public class Utente {
private String nome; private int max;
private int nPrestiti = 0;
Utente(String nome, int max) {this.nome = nome; this.max = max;}
String getNome(){return nome;}
void incPrestiti(){nPrestiti++;}
void decPrestiti(){nPrestiti--;}
boolean prestitoAmmissibile () {return nPrestiti < max;}
}
package biblioteca;
class Prestito implements Comparable{
private Utente u; private Volume v;
Prestito(Utente u, Volume v){this.u = u; this.v = v;}
Utente getU() {return u;}
Volume getV() {return v;}
public int compareTo(Object o1) {
Prestito p1 = (Prestito) o1;
if (this.v.getLibro().getTitolo().equals(p1.v.getLibro().getTitolo()))
return new Integer(this.v.getCodice()).compareTo(new
Integer(p1.v.getCodice()));
else return
this.v.getLibro().getTitolo().compareTo(p1.v.getLibro().getTitolo());
}
public String toString(){return v.getLibro().getTitolo() + ":" + v.getCodice()
+ "(" + u.getNome() + ")";}
}
8
package biblioteca;
import java.util.ArrayList; import java.util.Collections;
import java.util.Comparator; import java.util.HashMap;
import java.util.List; import java.util.Map;
public class Biblioteca {
private Map libri = new HashMap();
private Map utenti = new HashMap();
private Map prestiti = new HashMap();
public Libro newLibro(String titolo, int n) throws BiblioEccezione {
if (titolo == null || n <= 0) throw new BiblioEccezione("newLibro: dati
errati - " + titolo + " " + n);
Libro l1 = new Libro(titolo,n);
Object prev = libri.put(titolo, l1);
if (prev != null) throw new BiblioEccezione("libro esistente:" + titolo);
return l1;}
public Utente newUtente(String nome, int n) throws BiblioEccezione {
if (nome == null || n <= 0) throw new BiblioEccezione("newUtente: dati
errati - " + nome + " " + n);
Utente u1 = new Utente(nome,n);
Object prev = utenti.put(nome, u1);
if (prev != null) throw new BiblioEccezione("utente esistente:" + nome);
return u1;}
public int newPrestito(String u, String titolo) throws BiblioEccezione {
if (titolo == null || u == null) throw new BiblioEccezione("newPrestito:
dati errati - " + titolo + " " + u);
Utente u1 = (Utente) utenti.get(u);
if (u1 == null) throw new BiblioEccezione("newPrestito: dati errati - " +
u);
if (!u1.prestitoAmmissibile()) throw new BiblioEccezione("newPrestito:
max prestiti per " + u);
Libro l = (Libro)libri.get(titolo);
if (l == null) throw new BiblioEccezione("newPrestito: dati errati - " +
titolo);
Volume v = l.getVolume();
if (v == null) throw new BiblioEccezione("newPrestito: volume non
disponibile - " + titolo);
Prestito p = new Prestito(u1, v);
int c = v.getCodice();
prestiti.put(new Integer(c), p);
u1.incPrestiti();
return c;
}
9
public void restituzione(String u, int codiceVolume) throws BiblioEccezione {
Utente u1 = (Utente) utenti.get(u);
if (u1 == null) throw new BiblioEccezione("restituzione: dati errati - "
+ u);
Prestito p = (Prestito) prestiti.get(new Integer(codiceVolume));
if (p == null || u1 != p.getU()) throw new BiblioEccezione("restituzione:
dati errati - " + codiceVolume);
u1.decPrestiti(); p.getV().setDisp(true);
prestiti.remove(new Integer(codiceVolume));
}
public String graduatoriaLibri() {
Comparator ordine = new Comparator() {
public int compare(Object o1, Object o2) {
Libro l1 = (Libro) o1;
Libro l2 = (Libro) o2;
if (l2.getNPrestiti() == l1.getNPrestiti()) return
l1.getTitolo().compareTo(l2.getTitolo());
return new Integer(l2.getNPrestiti()).compareTo(new
Integer(l1.getNPrestiti()));
}};
List list1 = new ArrayList(libri.values());
Collections.sort(list1, ordine); return list1.toString();}
public String prestitiInCorso(){
List list1 = new ArrayList(prestiti.values());
Collections.sort(list1); return list1.toString();}
}
10
2. Si progetti un’interfaccia grafica (attributi e metodo actionPerformed della classe GUI) che consenta
l’uso del package di cui al punto 1. I pulsanti corrispondono alle operazioni definite al punto 1.
Ad esempio, detti t1 e t2 i valori inseriti nelle due caselle di testo, newLibro inserisce il libro con titolo t1 e
con n. volumi pari a t2.
Eventuali eccezioni sono mostrate nell’area di testo. L’area di testo mostra la conferma “done” nel caso di
newLibro, newUtente e restituzione se l’operazione è andata a buon fine, il codice del prestito nel caso di
newPrestito, il risultato della query negli altri casi. La figura precedente presenta il risultato di
graduatoriaLibri.
private JTextArea ta; private JTextField tf1; private JTextField tf2;
private Biblioteca bib = new Biblioteca();
public static final String LIBRO = "newLibro";
public static final String UTENTE = "newUtente";
public static final String PRESTITO = "newPrestito";
public static final String RESTITUZIONE = "restituzione";
public static final String INCORSO = "prestitiInCorso";
public static final String GRAD = "graduatoriaLibri";
public void actionPerformed(ActionEvent e)
{
String actionCommand = e.getActionCommand();
ta.setText("");
String s1 = tf1.getText(); String s2 = tf2.getText();
try{
if (actionCommand.equals(LIBRO)){
bib.newLibro(s1, Integer.parseInt(s2));
ta.setText("done"); }
else if (actionCommand.equals(UTENTE)) {
bib.newUtente(s1, Integer.parseInt(s2));
ta.setText("done"); }
else if (actionCommand.equals(PRESTITO)) {
ta.setText(bib.newPrestito(s1, s2) + "");}
else if (actionCommand.equals(RESTITUZIONE)) {
bib.restituzione(s1, Integer.parseInt(s2));
ta.setText("done"); }
else if (actionCommand.equals(GRAD)) {
ta.setText(bib.graduatoriaLibri());
}
else if (actionCommand.equals(INCORSO)) {
ta.setText(bib.prestitiInCorso());
}
}catch(BiblioEccezione ex){ta.setText(ex.getMessage());}
catch(NumberFormatException ex){ta.setText(ex.getMessage());}}
11
Tema n. 3
public class TestPalestra {
public static void main(String[] args) {
try{
Persona p1 = new Persona("p1");
Persona p2 = new Persona("p2");
// Persona p3 = new Persona("p1"); genera l’errore: nome ripetuto - p1
Attrezzo a1 = new Attrezzo("a1"); Attrezzo a2 = new Attrezzo("a2");
String s1 = Attrezzo.showAttrezzi(); System.out.println(s1);
Esercizio e1 = new Esercizio ("es 1", "a1", 1, 8);
Esercizio e2 = new Esercizio ("es 2", "a2", 1, 9);
Esercizio e3 = new Esercizio ("es 3", "a1", 2, 8);
Esercizio e4 = new Esercizio ("es 4", "a2", 2, 10);
Esercizio e5 = new Esercizio ("es 5", "a2", 2, 10);
p1.nuovoEsercizio(e1); p1.nuovoEsercizio(e2);
p1.nuovoEsercizio(e3); p2.nuovoEsercizio(e4);
//p1.nuovoEsercizio(e1); //produce il messaggio d'errore esercizio duplicato per p1
//p1.nuovoEsercizio(e5); //produce il messaggio d'errore esercizio duplicato per a2
System.out.println(p1); System.out.println(a1); } catch(PalestraEx e)
{System.out.println(e.getMessage());}}}
Risultato
[a1, a2] nota: gli attrezzi sono ordinati; da showAttrezzi()
p1[1:8:es 1:p1:a1, 1:9:es 2:p1:a2, 2:8:es 3:p1:a1] nota: da println(p1)
a1[1:8:es 1:p1:a1, 2:8:es 3:p1:a1] nota: da println(a1)
Si implementino le classi usate nel programma di test precedente.
Note
Il programma riguarda la gestione degli esercizi che devono essere svolti dalle persone che
frequentano una palestra. Un esercizio è caratterizzato da: nome, attrezzo da usare, giorno e ora di
inizio (giorno e ora sono indicati da numeri interi, la durata si assume unitaria).
new Persona/ new Attrezzo nome
genera un'eccezione se nome è null oppure è ripetuto
new Esercizio nome, attrezzo, giorno, ora
genera un'eccezione se l’attrezzo non è stato definito oppure se giorno non è compreso tra 1 e 365
o ora non è compresa tra 8 e 21
nuovoEsercizio esercizio
genera un'eccezione se esercizio è null oppure la persona ha già un esercizio in quella data
(giorno + ora) o l’attrezzo indicato da esercizio è già impegnato in un altro esercizio alla stessa
data
Si raccomanda la massima chiarezza.
12
classe PalestraEx
public class PalestraEx extends Exception {
PalestraEx(String s) {super(s);}
classe Esercizio
public class Esercizio implements Comparable {
String nome; Attrezzo a; int g; int h;
Persona p;
Attrezzo getAttrezzo(){return a;}
void setPersona(Persona p){this.p = p;}
public Esercizio(String nome, String attrezzo, int g, int h) throws
PalestraEx{
this.nome = nome; this.g = g; this.h = h;
a = Attrezzo.getAttrezzo(attrezzo);
if (a == null) throw new PalestraEx("attrezzo inesistente");
if ((g < 1 || g > 365) || (h < 8 || h > 21)) throw new
PalestraEx("data errata per " + nome);}
public int compareTo(Object other) {
Esercizio e = (Esercizio) other;
if (this.g != e.g) return (this.g < e.g ? -1 : 1);
if (this.h == e.h) return 0;
return (this.h < e.h ? -1 : 1);
}
public String toString(){
return g + ":" + h + ":" + nome +
a.getNome();
}
}
":" + p.getNome() +
":" +
13
classe Attrezzo
import java.util.TreeSet; import java.util.Set;
import java.util.TreeMap; import java.util.Map;
public class Attrezzo {
private String nome;
private static Map attrezzi = new TreeMap();
private Set esercizi = new TreeSet();
static Attrezzo getAttrezzo(String nome){
return
(Attrezzo) attrezzi.get(nome);
}
public static String showAttrezzi(){
return attrezzi.keySet().toString();
}
String getNome (){return nome;}
public Attrezzo(String nome) throws PalestraEx {
this.nome = nome;
if (nome == null) throw new PalestraEx("nome nullo");
this.nome = nome;
Object prev = attrezzi.put(nome, this);
if (prev != null) throw new PalestraEx("attrezzo già esistente:" +
nome);
}
public String toString(){return nome + esercizi;}
boolean addEsercizio(Esercizio e) {return esercizi.add(e);}
}
14
classe Persona
import java.util.TreeMap; import java.util.Map;
import java.util.TreeSet; import java.util.Set;
public class Persona {
private String nome;
private static Map persone = new TreeMap();
private Set esercizi = new TreeSet();
String getNome (){return nome;}
public Persona(String nome) throws PalestraEx {
if (nome == null) throw new PalestraEx("nome nullo");
this.nome = nome;
Object prev = persone.put(nome, this);
if (prev != null) throw new PalestraEx("persona già esistente:" +
nome);
}
public String toString(){return nome + esercizi;}
public void nuovoEsercizio(Esercizio e) throws PalestraEx{
boolean b = esercizi.add(e);
if (! b) throw new PalestraEx("esercizio duplicato per " + nome);
Attrezzo a = e.getAttrezzo();
if (! a.addEsercizio(e)) throw new PalestraEx("esercizio duplicato
per " + a.getNome());
e.setPersona(this);
}
}
15
2. Si progetti un’interfaccia
grafica
che
consenta
l’inserimento delle persone e
degli attrezzi relativi al punto
1.
Per
inserire
una
persona/attrezzo si scrive il
nome nella casella di testo,
poi si preme il pulsante
newPersona/newAttrezzo. Per
avere l’elenco degli attrezzi si
preme
il
pulsante
showAttrezzi.
L’area di testo centrale è usata per mostrare le eccezioni dei primi due comandi e il risultato del
terzo.
Si indichino i dati della classe Gui e si scriva soltanto il metodo ActionPerformed.
private JTextArea ta;
private JTextField tf1;
public void actionPerformed(ActionEvent e)
{
String actionCommand = e.getActionCommand();
ta.setText("");
String n = tf1.getText();
try{
if (actionCommand.equals("newPersona")){
new Persona(n);
ta.setText("added");
}
else if (actionCommand.equals("newAttrezzo")) {
new Attrezzo(n);
ta.setText("added");
}
else if (actionCommand.equals("showAttrezzi")) {
ta.setText(Attrezzo.showAttrezzi());
}
}catch (PalestraEx ex){ta.setText(ex.getMessage());}
}
}
16
Tema n. 4
import voli.*;
public class TestVoli {
public static void main(String[] args) {
try{
Voli vi = new Voli();
Aereo a1 = vi.addAereo("a1", "aereo a1", 100);
Aereo a2 = vi.addAereo("a2", "aereo a2", 150);
vi.addVolo("v1", "a1", "L1", 8, "L2", 10);
vi.addVolo("v10", "a1", "L23", 6, "L34", 7);
vi.addVolo("v2", "a2", "L3", 12, "L4", 14);
//vi.addVolo("v20", "a1", "L5", 9, "L6", 11); genera e. volo sovrapposto
vi.addPrenotazione("v1", "pass5", 1);
vi.addPrenotazione("v1", "pass2", 1);
//vi.addPrenotazione("v1", "pass2", 1); genera e. prenotazione duplicata
VoloGiornaliero vg = vi.getVoloGiornaliero("v1", 1);
System.out.println(vg);
System.out.println(a1);
}catch(VoliEx e){System.out.println(e);}}}
Risultato
1 v1 da L1:8 a L2:10[pass2, pass5] //info su volo giornaliero
//giorno, volo … passeggeri prenotati in ordine alfabetico
a1 aereo a1 100 [v10 da L23:6 a L34:7, v1 da L1:8 a L2:10] //info su aereo
//elenco voli ordinati per orario
Si implementino le classi usate nel programma di test precedente; tali classi si trovano nel
package voli.
Note
Il programma riguarda la gestione delle prenotazioni di voli giornalieri nell’ambito di una
settimana.
addAereo codiceAereo, descrizione, numeroPosti
genera un aereo e produce un'eccezione se codiceAereo è null o ripetuto o se numeroPosti < 0.
addVolo codiceVolo, codiceAereo, luogoPartenza, oraPartenza, luogoArrivo, oraArrivo
produce un'eccezione se codiceVolo è null o ripetuto o se l’aereo non esiste, se i luoghi sono nulli
e le ore non sono comprese tra 1 e 24 e oraArrivo non è maggiore di oraPartenza;
inoltre produce un’eccezione se tale volo si sovrappone ad un altro volo per lo stesso aereo (detti
v1 e v2 due voli per lo stesso aereo, non si ha sovrapposizione se
v1.oraArrivo < v2.oraPartenza o v1.oraPartenza > v2.oraArrivo.
Genera il volo in base al suggerimento seguente.
Suggerimento
Conviene che un oggetto volo, che stabilisce l’orario di un volo, contenga un array di 7 voli
giornalieri, perché le prenotazioni si riferiscono ai voli giornalieri.
addPrenotazione codiceVolo, passeggero, giorno
produce un'eccezione se il volo non esiste, passeggero è nullo o giorno non è compreso tra 1 e 7
e inoltre se non vi sono posti disponibili sul volo giornaliero nel giorno indicato o la prenotazione
è duplicata; aggiunge il passeggero alle prenotazioni del volo giornaliero nel giorno indicato.
17
package voli;
public class VoliEx extends Exception {
VoliEx(String s) {super(s);}
}
package voli;
import java.util.Set; import java.util.TreeSet;
public class Aereo {
String id; String descr; int nPosti;
Set sVoli = new TreeSet();
Aereo(String id, String descr, int nPosti){
this.id = id; this.descr = descr; this.nPosti = nPosti;
}
void addVolo(Volo v) throws VoliEx{
if (! sVoli.add(v)) throw new VoliEx("sovrapposizione voli:" + v.id);
}
public String toString(){
return id + " " + descr + " " + nPosti + " " + sVoli;
}
}
18
package voli;
public class Volo implements Comparable {
String id; Aereo a; String lP; int oP; String lA; int oA;
VoloGiornaliero[] voliGiornalieri;
Volo(String id, Aereo a, String lP, int oP, String lA, int oA){
this.id = id; this.a = a; this.lP = lP; this.oP = oP; this.lA =
lA; this.oA = oA;
voliGiornalieri = new VoloGiornaliero[7];
for (int i = 0; i < 7; i++) voliGiornalieri[i] = new
VoloGiornaliero(this, i);
}
public int compareTo(Object o){
Volo v2 = (Volo) o;
if (this.oA < v2.oP) return -1;
else if (this.oP > v2.oA) return 1;
else return 0;
}
void addPrenotazione(String passeggero, int giorno) throws VoliEx{
VoloGiornaliero vg = voliGiornalieri[giorno];
if (vg.prenotazioni.size() == this.a.nPosti) throw new
VoliEx("volo completo:" + this.id + ":" + giorno);
if (! vg.prenotazioni.add(passeggero)) throw new
VoliEx("prenotazione duplicata:" + this.id + ":" + giorno + " " + passeggero);
}
public String toString(){
return id + " da " + lP + ":" + oP + " a " + lA + ":" + oA;}
}
package voli;
import java.util.Set; import java.util.TreeSet;
public class VoloGiornaliero {
Set prenotazioni; Volo v; int giorno;
VoloGiornaliero(Volo v, int giorno){
this.v = v; this.giorno = giorno; prenotazioni = new TreeSet();}
public String toString(){
return giorno + " " + v.id + " da " + v.lP + ":" + v.oP + " a " +
v.lA + ":" + v.oA + prenotazioni;}
}
19
package voli;
import java.util.HashMap; import java.util.Map;
public class Voli {
Map mAerei = new HashMap();
Map mVoli = new HashMap();
public Aereo addAereo(String id, String descr, int nPosti) throws VoliEx{
System.out.println(id + " " + descr + " " + nPosti);
if (id == null || nPosti <= 0) throw new VoliEx("dati errati - " + id + "
" + nPosti);
Aereo a1 = new Aereo(id, descr, nPosti);
Object prev = mAerei.put(id, a1);
if (prev != null) throw new VoliEx("duplicazione:" + id);
return a1;
}
public void addVolo(String id, String aereo, String lP, int oP, String lA, int
oA) throws VoliEx {
if (id == null || lP == null || lA == null || oP >= oA || oP < 1 || oP >
23 || oA < 2 || oA > 24) throw new VoliEx("dati errati - " + id);
Aereo a1 = (Aereo) mAerei.get(aereo);
if (a1 == null) throw new VoliEx("aereo non definito:" + aereo);
Volo v1 = new Volo(id, a1, lP, oP, lA, oA);
a1.addVolo(v1);
//verifica sovrapposizione voli su aereo
Object prev = mVoli.put(id, v1);
if (prev != null) throw new VoliEx("duplicazione:" + id);
}
public void addPrenotazione(String idVolo, String passeggero, int giorno)
throws VoliEx {
if (idVolo == null || passeggero == null || giorno < 1 || giorno > 7 )
throw new VoliEx("dati errati - " + idVolo);
Volo v1 = (Volo) mVoli.get(idVolo);
if (v1 == null) throw new VoliEx("volo non definito:" + idVolo);
v1.addPrenotazione(passeggero, giorno);
}
public VoloGiornaliero getVoloGiornaliero(String idVolo, int giorno) throws
VoliEx {
if (idVolo == null || giorno < 1 || giorno > 7 ) throw new VoliEx("dati
errati - " + idVolo);
Volo v1 = (Volo) mVoli.get(idVolo);
if (v1 == null) throw new VoliEx("volo non definito:" + idVolo);
return v1.voliGiornalieri[giorno];
}}
20