NOME: __________________________________________________

COGNOME: __________________________________________________ MATRICOLA: ______________________

Dobbiamo ristrutturare una libreria per la gestione di oggetti grafici. La classe Disegno (vedi codice) modella un disegno. Un
disegno è formato da una sovrapposizione di forme elementari: ad ogni forma è associato un livello (o layer) che rappresenta
l’ordine con cui devono essere sovrapposte le varie forme. Nella implementazione attuale è previsto che un disegno possa
essere composto da due tipologie di forme elementari: cerchi e rettangoli, modellati dalle classi Cerchio e Rettangolo.
Ogni forma ha un colore (istanza della classe Colore) ed un insieme di attributi specifici relativi alla forma (vedi codice).
Nella classe Disegno le forme che compongono un disegno sono memorizzate in due mappe, una per i rettangoli e una per i
cerchi, che associano ad ogni livello una lista di rettangoli e una lista di cerchi, rispettivamente.
Ad esempio supponendo che un disegno sia formato da un rettangolo R1 e un cerchio C2 entrambi al livello 2, sovrapposti da
un cerchio C1 al livello 4, e da due rettangoli R2 ed R3 al livello 5, le mappe livello2rettangoli e livello2cerchi
memorizzerebbero le seguenti informazioni (per chiarezza indichiamo i nomi dei rettangoli e del cerchi al posto dei riferimenti
agli oggetti Rettangolo e Cerchio):
livello2rettangolo livello2cerchio
2  {R1} 2  {C2}
5  {R2, R3} 4  {C1}
Domanda 1 (peso 5%)
Scrivere il codice del metodo aggiungiRettangolo(Rettangolo rettangolo, int livello) della classe Disegno.
Domanda 2 (peso 35%)
Ci si è resi conto che in un disegno potrebbero esserci altre forme oltre a rettangoli e cerchi (ad esempio, ellissi, triangoli,
ecc.): sarebbe molto svantaggioso introdurre una mappa per ciascuna forma. Un programmatore esperto suggerisce di agire
come segue: le classi Rettangolo, Cerchio (e tutte quelle che serviranno a modellare nuove forme) dovranno estendere
una classe astratta Forma. Nella classe Disegno sarà quindi presente una sola mappa, Map<Integer, List<Forma>>
livello2forme.
o scrivere il codice della classe astratta Forma, che astrae il concetto di forma geometrica
o riscrivere completamente il codice delle classi Rettangolo e Cerchio, affinché estendano la classe astratta Forma
o riscrivere completamente il codice della classe Disegno sostituendo le due mappe con la mappa
Map<Integer, List<Forma>> livello2forme. In particolare va riscritto il costruttore, ed i metodi
aggiungiRettangolo(Rettangolo rettangolo, int livello) e aggiungiCerchio(Cerchio
cerchio, int livello) vanno eliminati e rimpiazzati da un unico metodo aggiungiForma(Forma forma,
int livello)
Domanda 3 (peso 15%)
Scrivere il codice del metodo Set<Colore> coloriPresentiNelDisegno() della classe Disegno (riscritta secondo le
indicazioni della Domanda 2) che restituisce in un insieme i colori di tutte le forme che compongono un disegno. Se
necessario è possibile modificare il codice della classe Colore; non è possibile introdurre nuove classi.
Domanda 4 (peso 10%)
Scrivere il codice del metodo Map<Colore, List<Forma>> colore2forme() che restituisce una mappa che associa ad
un colore la lista, ordinata in ordine crescente di superficie, delle forme del disegno con tale colore. Non è possibile introdurre
altre classi; se necessario è possibile modificare il codice della classe astratta Forma.
Domanda 5 (peso 10%)
Scrivere il codice del metodo List <Forma> formeOrdinatePerLuminosita() che restituisce in una lista tutte le forme
presenti nel disegno. La lista deve essere ordinata in ordine crescente di luminosità del colore. Non è possibile modificare le
classi Forma e Colore, mentre è possibile, se necessario, introdurre nuove classi.
Domanda 6 (peso 15%)
Scrivere una classe di test per la classe Disegno. In particolare, scrivere almeno 4 test case per testare la correttezza del
metodo colore2forme() ed almeno 4 per formeOrdinatePerLuminosita(). In particolare la correttezza dei due
metodi va verificata nel caso di: (i) disegno vuoto, (ii) disegno composto da una forma singola, (iii) disegno composto da due
forme di colore diverso, (iv) disegno di due forme dello stesso colore.
Domanda 7 (peso 10%)
Data la seguente porzione di codice, disegnare un diagramma che rappresenti lo stato degli oggetti referenziati dalle variabili
elencoPunti, p0, p1, p2 nel punto marcato con il commento // ****
public static void main(String[] args) {
List<Punto> elencoPunti = new LinkedList<Punto>();
Punto p0 = new Punto(0, 0);
Punto p1 = new Punto(1, 1);
Punto p2 = new Punto(2, 2);
elencoPunti.add(p0);
elencoPunti.add(p1);
elencoPunti.add(p2);
p1 = p2;
p2 = new Punto(4, 4);
elencoPunti.add(p1);
elencoPunti.add(p2);
// ****
}
import java.util.*;
public class Disegno {
private Map<Integer, List<Rettangolo>> livello2rettangoli;
private Map<Integer, List<Cerchio>> livello2cerchi;
public Disegno() {
this.livello2rettangoli = new TreeMap<Integer, List<Rettangolo>>();
this.livello2cerchi = new TreeMap<Integer, List<Cerchio>>();
}
public void aggiungiRettangolo(Rettangolo rettangolo, int livello){
//DOMANDA 1: scrivere il codice di questo metodo
//DOMANDA 2: eliminare questo metodo e sostituirlo con il metodo
// public void aggiungiForma(Forma forma, int livello)
}
public void aggiungiCerchio(Cerchio cerchio, int livello){
// codice omesso
//DOMANDA 2: eliminare questo metodo e sostituirlo con il metodo
// public void aggiungiForma(Forma forma, int livello)
}
public Set<Colore> coloriPresentiNelDisegno() {
Set<Colore> coloriNelDisegno = null;
//DOMANDA 3: scrivere il codice di questo metodo
// (è possibile modificare Colore; non e’ possibile introdurre nuove classi)
return coloriNelDisegno;
}
public Map<Colore, List<Forma>> colore2forme() {
Map<Colore, List<Forma>> colore2forme = null;
//DOMANDA 4: scrivere il codice di questo metodo
// (non è possibile introdurre altre classi; è possibile modificare Forma)
return colore2forme;
}
public List<Forma> formeOrdinatePerLuminosita() {
List<Forma> forme = null;
//DOMANDA 5: scrivere il codice di questo metodo
// (non è possibile modificare Forma e Colore, è possibile introdurre nuove classi)
return forme;
}
}

public class Rettangolo {

private Colore colore;
private Punto vertice;
private int larghezza;
private int altezza;
public Rettangolo(Colore colore, Punto vertice, int altezza, int larghezza){
this.colore = colore;
this.vertice = vertice;
this.larghezza = larghezza;
this.altezza = altezza;
}
public Colore getColore(){
return this.colore;
}
public Punto getVertice(){
return this.vertice;
}
public int getAltezza(){
return this.altezza;
}
public int getLarghezza(){
return this.larghezza;
}
public double superficie(){
return (this.altezza * this.larghezza);
}
}
public class Cerchio {
private Colore colore;
private Punto centro;
private int raggio;

public Cerchio(Colore colore, Punto centro, int raggio){

this.colore = colore;
this.centro = centro;
this.raggio = raggio;
}
public Colore getColore(){
return this.colore;
}
public Punto getCentro(){
return this.centro;
}
public int getRaggio(){
return this.raggio;
}
public double superficie(){
return Math.PI * this.raggio * this.raggio;
}
}

public class Punto {

private int x;
private int y;
public Punto(int x, int y){
this.x = x;
this.y = y;
}
public int getX() {
return this.x;
}
public int getY() {
return this.y;
}
}

public class Colore {

private int red;
private int green;
private int blue;
public Colore(int red, int green, int blue) {
this.red = red;
this.blue = blue;
this.green = green;
}
public int getRed() {
return this.red;
}
public int getGreen() {
return this.green;
}
public int getBlue() {
return this.blue;
}
public int luminosita() {
return (this.red + this.green + this.blue) ;
}
}