Correzione Esercitazione 19 giugno 2008

Complementi di Informatica

Esercizio 1
Scrivere un programma Java contenente:

• Una classe Giocatore caratterizzata da un cognome, un numero di maglia, un riferimento

al prossimo giocatore all'interno della rosa di una squadra di calcio (che deve essere
realizzata come una lista ordinata di giocatori) e un metodo per stampare l'informazione che
caratterizza questa classe.

• Una classe Squadra, che realizza una lista di giocatori, che contiene un metodo per
inserire un giocatore con un certo cognome e un certo numero di maglia nella lista in modo
tale che la lista risulti sempre ordinata in base al numero di maglia (dal più piccolo al più
grande), un metodo per cancellare un giocatore con un certo cognome dalla lista e un
metodo per stampare tutti i giocatori che fanno parte della lista.

• Una classe Esercizio contenente il metodo main che istanzia una squadra, inserisce
nella squadra un numero a piacere di giocatori, ne elimina alcuni e successivamente stampa
a video i giocatori che compongono la squadra usando l'apposito metodo della classe
Squadra.

Soluzione

/*-----------------------------------------
*
* Giocatore
*
*/

class Giocatore {

Giocatore successivo;
String cognome;
int numero;

Elemento (Giocatore s, String c, int n) {

successivo = s;
cognome = c;
numero = n
}

void stampa() {
System.out.println(cognome + " " + numero);
}

}
/***************************************
**
** Squadra
**
***************************************/

class Squadra {

Giocatore primo;

/*------------------------------
*
* Costruttore
*
*/

Squadra (Giocatore pr) {

primo = pr;
}

/*------------------------------------
*
* Inserzione
*
* La lista deve rimanere ordinata
*
*/

void inserzione (String cognome, int numero) {

Giocatore precedente = null;

Giocatore corrente = primo;
boolean trovato = false;

while (!trovato && corrente != null) {

if (corrente.numero > numero) {

trovato = true;

} else {

precedente = corrente;
corrente = corrente.successivo;
 }
}

Giocatore g = new Giocatore(corrente, cognome, numero);

if (precedente == null) {

primo = g;

} else {

precedente.successivo = g;

}
}
/*------------------------------------------------------------
*
* Cancellare un elemento
*
*/

void del (String cognome) {

if (primo != null) {

if (primo.cognome.equals(cognome)) {

primo = primo.successivo;

} else {

Giocatore g = primo;
boolean trovato = false;

while (g != null) && (!trovato) {

if (g.successivo.cognome.equals(cognome)) {
trovato = true;
}

g = g.successivo;

if (trovato) {
g.successivo = g.successivo.successivo;
}
}
}
}
Esercizio 2
Scrivere le seguenti classi Java:

• Una classe Vagone, caratterizzata da:

o un numero intero che rappresenta il numero di passeggeri massimo che il vagone può
contenere (capienza);
o un riferimento al vagone successivo in un treno (che deve essere rappresentato come una
lista di vagoni);
o Un costruttore che permetta di assegnare un valore agli attributi di questa classe;

• Una classe Treno, che realizza una lista di vagoni, caratterizzata da:
o un riferimento al primo vagone del treno (o locomotiva, supponendo che la locomotiva
sia in tutto e per tutto uguale a un qualsiasi altro vagone, ad eccezione del fatto che essa
è l'unico vagone che non è preceduto da altri vagoni);
o un costruttore che permette di assegnare un valore di tipo Vagone alla locomotiva;
o un metodo inserisci, che riceve in ingresso un numero intero cap e inserisce un
nuovo vagone di capienza cap in fondo al treno (nel caso in cui il treno sia vuoto,
questo nuovo vagone deve diventare la locomotiva, in tutti gli altri casi deve diventare
l'ultimo vagone del treno).

Correzione

/*-----------------------------------------
*
* Vagone
*
*/

class Vagone {

Vagone successivo;
int cap;

Vagone (Vagone s, int c) {

successivo = s;
cap = c;
}
}
/***************************************
**
** Lista
**
***************************************/

class Treno {

Vagone locomotiva;

/*------------------------------
*
* Costruttore
*
*/

Treno (Vagone l) {
locomotiva = l;
}

/*--------------------------------------------
*
* Inserzione un elemento in coda
*
*/

void inserzione_in_coda (int cap) {

if (locomotiva == null) {

locomotiva = new Vagone(null, cap);

} else {

Vagone v = primo;

while (v.successivo != null) {

v = v.successivo;

v.successivo = new Vagone(null, cap);

}
}
Esercizio 3

Scrivere un programma Java composto da:

• una classe Automobile caratterizzata da una marca (rappresentabile tramite una stringa),
un colore (rappresentabile tramite una stringa), un numero di targa (rappresentabile tramite
un numero intero), un riferimento all'automobile successiva in una coda di automobili e un
metodo per stampare marca, colore e numero di targa.

• una classe Coda che realizza una coda di automobili, contenente un metodo per inserire
un'automobile in fondo alla coda, uno per estrarre un'automobile dalla testa della coda (nota:
quest'ultimo metodo deve anche cancellare l'automobile estratta) e uno per stampare marca,
colore e targa di tutte le automobili in coda nell'ordine in cui vi sono state inserite.

• una classe CaselloAutostradale contenente un metodo main dove viene istanziata

una coda, vi vengono inserite alcune automobili e poi le varie automobili vengono fatte
uscire dalla coda una per volta secondo l'ordine di arrivo.

Svolgimento

/*-----------------------------------------
*
* Automobile
*
*/

class Automobile {

Automobile successivo;
String marca;
String colore;
int targa;

Automobile (Automobile s, String m, String c, int t) {

successivo = s;
marca = m; colore = c; targa = t;
}

void stampa() {
System.out.println(marca + " " + colore + " " + targa);
}
}
/***************************************
**
** Coda
**
***************************************/

class Coda {

Automobile primo;

/*------------------------------
*
* Costruttore
*
*/

Coda (Automobile p) {
primo = p;
}

/*--------------------------------------------
*
* Inserzione un elemento in coda
*
*/

void inserzione_in_coda (String marca, String colore, int targa) {

if (primo == null) {

primo = new Automobile(null, marca, colore, targa);

} else {

Automobile a = primo;

while (a.successivo != null) {

a = a.successivo;

}
 a.successivo = new Automobile(null, marca, colore, targa);
}
}

/*--------------------------------------------
*
* Estrazione dalla testa
*
*/

void estrai () {

if (primo != null) {
primo = primo.successivo;
}
}

/*--------------------------------------------
*
* stampa coda
*
*/

void stampa() {
Automobile a = primo;
while (a != null) {
a.stampa();
a = a.successivo;
}
}
}
Esercizio 4

Scrivere un programma Java composto da:

1 una classe Motore caratterizzata da una marca (rappresentabile tramite una stringa), un
numero di telaio (rappresentabile tramite un numero intero), un numero di cilindri
(rappresentabile tramite un numero intero), un riferimento al motore successivo in una coda
e un metodo per stampare marca, telaio e numero di cilindri.

2 una classe CatenaDiMontaggio che realizza una coda di motori, contenente un metodo
per inserire un nuovo motore in fondo alla coda, uno per estrarre un motore dalla testa della
coda e metterlo in produzione (nota: quest'ultimo metodo deve anche rimuovere il motore
estratto dalla catena di montaggio) e uno per stampare marca, telaio e numero di cilindri di
tutti i motori presenti sulla catena di montaggio nell'ordine in cui vi sono stati inseriti.

3 una classe Esercizio contenente un metodo main dove viene istanziata una catena di
montaggio, vi vengono inseriti alcuni motori e poi i vari motori vengono estratti uno per
volta secondo l'ordine di arrivo.

Svolgimento

/*-----------------------------------------
*
* Motore
*
*/

class Motore {

Motore successivo;
String marca;
int telaio
int numCilindri;

Motore (Motore s, String m, int t, int c) {

successivo = s;
marca = m; telaio = t; numCilindri = c;
}

void stampa() {
System.out.println(marca + " " + telaio + " " + numCilindri);
}
}
/***************************************
**
** Coda
**
***************************************/

class CatenaDiMontaggio {

Motore primo;

/*------------------------------
*
* Costruttore
*
*/

CatenaDiMontaggio (Motore p) {
primo = p;
}

/*--------------------------------------------
*
* Inserzione un elemento in coda
*
*/

void inserzione_in_coda (String marca, int telaio, int cilindri) {

if (primo == null) {

primo = new Motore(null, marca, telaio, cilindri);

} else {

Motore m = primo;

while (m.successivo != null) {

m = m.successivo;

m.successivo = new Motore(null, marca, telaio, cilindri);

}
}
 /*--------------------------------------------
*
* Estrazione dalla testa
*
*/

void estrai () {

if (primo != null) {
primo = primo.successivo;
}
}

/*--------------------------------------------
*
* stampa coda
*
*/

void stampa() {
Motore m = primo;
while (m != null) {
m.stampa();
m = m.successivo;
}
}
}