Ingegneria del Software - Esercizi

Esercizi presi dai compiti in classe.

Warning

Questi esercizi sono stati svolti da me e da altri studenti, quindi potrebbero contenere errori. Se ne trovate, segnalateli.

Domande a risposta multipla

public Libro getLibro() { return b.getLib(); }

Domande a risposta aperta

public class Buffer {
  private int box;
  private boolean full = false;
  public mod1 int get() throws InterruptedException {
    while (!full) metodo1();
    full = false; notifyAll(); return box;
  }
  public mod2 void put(int value) throws InterruptedException {
    while (full) metodo2();
    box = value; full = true; metodo3();
  }
}

Produrre il design ad oggetti corrispondente ai seguenti requisiti:

• Su richiesta dell'utente deve essere calcolato il costo complessivo degli ordini fatti dal cliente in un mese
• Per gli ordini in un mese dovranno essere fornite le categorie a cui appartengono ciascuno dei prodotto acquistati

public class Order {
    String product;
    int cost;
    String category;
    String month;
    String client;
    // getters and setters
}

class OrderManager {
    List<Order> orders = new ArrayList<>();
    public int getCostInMonthForClient(String month, String client) {
        return orders.stream()
                .filter(order -> order.month.equals(month))
                .filter(order -> order.client.equals(client))
                .mapToInt(order -> order.cost)
                .sum();
    }
    public List<String> getCategoriesInMong(String month) {
        return orders.stream()
                .filter(order -> order.month.equals(month))
                .map(order -> order.category)
                .distinct()
                .collect(Collectors.toList());
    }
}

Design pattern

Esercizio 1

public interface IDataSource {
 public String getNomeCompleto();
 public int getEta();
}

public class Info {
  private String nome;
  private String cognome;
  private Date dataDiNascita;
  public Info(String nome, String cognome, Date dataDiNascita) {
    this.nome = nome; this.cognome = cognome; this.dataDiNascita = dataDiNascita;
  }
  public String getNome() { return nome;}
  public String getCognome() { return cognome;}
  public Date getDataDiNascita() { return dataDiNascita;}
}

Domanda 1

public class InfoAdapter implements IDataSource {
  private Info info;
  public InfoAdapter(Info info) { this.info = info; }
  public String getNomeCompleto() {
    return info.getNome() + " " + info.getCognome();
  }
  public int getEta() {
    return LocalDate.now().getYear() - info.getDataDiNascita().getYear();
  }
}

Domanda 2

Utilizzare una variante del pattern per risolvere lo stesso problema.

public class InfoAdapter extends Info implements IDataSource {
  public InfoAdapter(String nome, String cognome, Date dataDiNascita) {
    super(nome, cognome, dataDiNascita);
  }
  public String getNomeCompleto() {
    return getNome() + " " + getCognome();
  }
  public int getEta() {
    return LocalDate.now().getYear() - getDataDiNascita().getYear();
  }
}

Esercizio 2

public interface Auto {
  public String getTipo();
  public int getPeso();
  public float getDistanza(int t);
}

public interface Motore {
  public int getPotenza();
}

public class Berlina implements Auto {
  private Motore m;
  public Berlina(Motore x) { m = x; }
  public String getTipo() { return "Berlina"; }
  public int getPeso() { return 800; }
  public float getDistanza(int t) {
    return (float) t * t * m.getPotenza() / getPeso();
  }
}

public class Fire implements Motore {
  public int getPotenza() { return 1000; }
}

Domanda 1

Domanda 2

Implementare la classe C1 che istanzia le classi Berlina e Fire in modo opportuno.

public class C1 {
  public static Auto getNewAuto() {
    Motore m = new Fire();
    Auto a = new Berlina(m);
  }
}

Domanda 3

Implementare la classe C2 che chiama i metodi definiti in Auto.

public class C2 {
  public static main(String args[]) {
    Auto auto = C1.getNewAuto();
    System.out.println(auto.getTipo());
    System.out.println(auto.getPeso());
    System.out.println(auto.getDistanza(10));
  }
}

Domanda 4

Disegnare il diagramma UML delle classi per il codice mostrato e per le classi C1 e C2 indicate

Loading diagram...

Domanda 5

Disegnare il diagramma UML di sequenza per il codice mostrato e per le classi C1 e C2 indicate

Loading diagram...

Esercizio 3

public interface Esame {
  public void prenota();
  public void registra();
}
public class Nuovo implements Esame {
  public void prenota() { System.out.println("Presentazione Ok"); }
  public void registra() { System.out.println("Impossibile registrare l’esame"); }
}
public class Prenotato implements Esame {
  public void prenota() { System.out.println("Impossibile prenotare l'esame"); }
  public void registra() { System.out.println("Registrazione Ok"); }
}

Domanda 1

Completare l'implementazione del design Pattern State con almeno due classi.

// Context
public class Appello {
  private Esame state = new Nuovo(this);
  public void prenota() {
    this.state = this.state.prenota();
  }
  public void registra() {
    this.state = this.state.registra();
  }
}

// Concrete State 1
public class Nuovo implements Esame {
  private Appello appello;
  public Nuovo(Appello appello) { this.appello = appello; }
  public Esame prenota() {
    System.out.println("Presentazione Ok");
    return new Prenotato(appello);
  }
  public Esame registra() {
    System.out.println("Non è possibile registrare l’esame");
    return this;
  }
}

// Concrete State 2
public class Prenotato implements Esame {
  private Appello appello;
  public Prenotato(Appello appello) { this.appello = appello; }
  public Esame prenota() {
    System.out.println("Non è possibile prenotare l’esame");
    return this;
  }
  public Esame registra() {
    System.out.println("Registrazione Ok");
    return new Registrato(appello);
  }
}

// Concrete State 3
public class Registrato implements Esame {
  private Appello appello;
  public Registrato(Appello appello) { this.appello = appello; }
  public Esame prenota() {
    System.out.println("Non è possibile prenotare l’esame");
    return this;
  }
  public Esame registra() {
    System.out.println("Non è possibile registrare l’esame");
    return this;
  }
}

Domanda 2

Inserire in una delle classi la memorizzazione del nome della materia e della data dell'esame.

public class Appello {
  // ...
  private String materia;
  private LocalDate date;
  public Appello(String materia, LocalDate date) {
    this.materia = materia;
    this.date = date;
  }
  public String getMateria() { return this.materia; }
  public LocalDate getDate() { return this.data; }
  // ...
}

public class Nuovo implements Esame {
  // ...
  public Esame prenota() {
    if (appello.getDate().before(LocalDate.now())) {
      System.out.println("Presentazione Ok");
      return new Prenotato(appello);
    }
    System.out.println("Non è possibile prenotare l’esame");
    return this;
  }
  // ...
}

Domanda 3

Domanda 4

Disegnare il diagramma UML delle classi.

Loading diagram...

Domanda 5

Disegnare il diagramma UML di sequenza illustrando l'esecuzione a partire da una classe appropriata.

Loading diagram...

Esercizio 4

public class Student {
  private String nome = "Al";
  private int aperti = 0;
  private Modulo[] e = new Modulo[10];
  private int crediti = 0;
  public void inizia() {
    if (aperti < e.length) { e[aperti++] = new Modulo(); }
  }
  public void completa() {
    if (aperti > 0) { crediti += e[--aperti].getCrediti(); }
  }
}

public class Modulo {
  private boolean superato = false;
  public int getCrediti() { return 3; }
  public boolean superato() { return superato; }
  public void setSuperato() { superato = true; }
}

Domanda 1

Cambiare la classe Modulo in modo da far svolgere il ruolo di Concrete product del design pattern Factory Method.

public interface Modulo {
  int getCrediti();
  boolean superato();
}

public class ModuloSuperato extends Modulo {
  public int getCrediti() { return 3; }
  public boolean superato() { return true; }
}

public class ModuloIniziato extends Modulo {
  public int getCrediti() { return 0; }
  public boolean superato() { return false; }
}

Domanda 2

Implementare una classe che instanzia il Concrete product in modo appropriato al design pattern.

public class ModuloFactory {
  public static Modulo create(boolean isSuperato) {
    return isSuperato ? new ModuloSuperato() : new ModuloIniziato();
  }
}

Domanda 3

Cambiare la classe studente in modo da usare le classi ricavate precedentemente.

public class Student {
  // ...
  public void inizia() {
    if (aperti < e.length) { e[aperti++] = ModuloFactory.create(false); }
  }
  public void completa() {
    if (aperti > 0) {
      e[aperti] = ModuloFactory.create(true);
      crediti += e[aperti].getCrediti();
      aperti--;
    }
  }
}

Domanda 4

Disegnare il diagramma UML delle classi.

Loading diagram...

Domanda 5

Disegnare il diagramma UML di sequenza illustrando l'esecuzione a partire da una classe appropriata.

Loading diagram...

Stream

Soluzioni

Data una lista di persone, trovare i nomi dei programmatori con età minore di 30 anni.

public record Persona(String name, int age, String role) {}

List<Persona> l = List.of(new Persona("Kent", 29, "CTO"),
                          new Persona("Luigi", 25, "Programmer"),
                          new Persona("Andrea", 26, "GrLeader"),
                          new Persona("Sofia", 26, "Programmer"),
                          new Persona("Alfio", 63, "Programmer"));
// ...
// result = ["Luigi", "Sofia"]

Data una lista di istanze di Persona trovare i diversi ruoli.

public record Persona(String name, int age, String role) {}

List<Persona> l = List.of(new Persona("Kent", 29, "CTO"),
                          new Persona("Luigi", 25, "Programmer"),
                          new Persona("Andrea", 26, "GrLeader"),
                          new Persona("Sofia", 26, "Programmer"));
// ...
// result = ["CTO", "Programmer", "GrLeader"]

Data una lista di stringhe, produrre una lista che contiene solo le stringhe che cominciano con un certo prefisso noto.

List<String> l = List.of("author", "auto",
                          "autocorrect", "begin",
                          "big", "bigger", "biggish");
// ...
// se prefisso = "au", result = ["author", "auto", "autocorrect"]

Data una lista di stringhe, produrre una stringa contenente le iniziali di ciascuna stringa della lista.

List<String> l = List.of("to", "speak", "the", "truth",
                          "and", "pay", "your", "debts");
// ...
// result = "tsttapyd"

Data una lista di terne di numeri interi, per ciascuna terna verificare se essa costituisce un triangolo. Restituire la lista dei perimetri per le terne che rappresentano triangoli.
In un triangolo, ciascun lato è minore della somma degli altri due.
Si può rappresentare la terna come un array di tre elementi interi

List<List<Integer>> l = List.of(List.of(3, 4, 5), List.of(3, 4, 6),
                                List.of(3, 4, 7), List.of(3, 4, 8));
// ...
// result = [12, 13, 14]

Data una lista di numeri interi positivi, verificare se la lista è ordinata.
Suggerimenti:

• Si generano gli indici da 0 a n-1
• Per ciascun valore dell'indice i, si confrontano l'elemento con indice i ed il successivo, se il secondo è minore del primo la lista non è ordinata e si può fermare la verifica

Data una lista di prodotti, restituire il costo totale dei prodotti che hanno un prezzo maggiore di 10.

public record Prodotto(String nome, double prezzo) {}

List<Prodotto> l = List.of(new Prodotto("p1", 5.0), new Prodotto("p2", 10.0),
                            new Prodotto("p3", 15.0), new Prodotto("p4", 20.0));
// ...
// result = 35.0

Produrre una lista contenente i primi n multipli di 7.

int n = 10;
// ...
// result = [0, 7, 14, 21, 28, 35, 42, 49, 56, 63]

Data una lista di utenti, restituire tutti i loro commenti ordinati per data.

public record Utente(String nome, List<Commento> commenti) {}
public record Commento(String testo, Date data) {}

List<Utente> l = List.of(
        new Utente("u1",
                List.of(new Commento("c2", LocalDate.of(2021, 1, 2)),
                        new Commento("c1", LocalDate.of(2021, 1, 1)),
                        new Commento("c5", LocalDate.of(2021, 1, 5)))),
        new Utente("u2",
                List.of(new Commento("c4", LocalDate.of(2021, 1, 4)),
                        new Commento("c3", LocalDate.of(2021, 1, 3)))));
// result = ["c1", "c2", "c3", "c4", "c5"]

Restituire gli utenti che hanno pubblicato almeno un commento prima di una certa data

LocalDate date = LocalDate.of(2021, 1, 3);
List<Utente> l = List.of(
        new Utente("u1",
                List.of(new Commento("c2", LocalDate.of(2021, 1, 2)),
                        new Commento("c1", LocalDate.of(2021, 1, 1)),
                        new Commento("c5", LocalDate.of(2021, 1, 5)))),
        new Utente("u2",
                List.of(new Commento("c4", LocalDate.of(2021, 1, 4)),
                        new Commento("c3", LocalDate.of(2021, 1, 3)))));
// result = ["u1"]
}

Restituire l'utente che ha pubblicato il commento più recente

List<Utente> l = List.of(
        new Utente("u1",
                List.of(new Commento("c2", LocalDate.of(2021, 1, 2)),
                        new Commento("c1", LocalDate.of(2021, 1, 1)),
                        new Commento("c5", LocalDate.of(2021, 1, 5)))),
        new Utente("u2",
                List.of(new Commento("c4", LocalDate.of(2021, 1, 4)),
                        new Commento("c3", LocalDate.of(2021, 1, 3)))));
// result = "u1"

Restituire il prodotto più economico

List<Prodotto> l = List.of(new Prodotto("p1", 80), new Prodotto("p2", 50),
                           new Prodotto("p3", 10), new Prodotto("p4", 20));

// result = "p3"
}

Restituire tutte le figure che siano rettangoli o quadrati (tutti gli angoli uguali)

public record Figura(int l1, int l2, int l3, int l4,
                     int a1, int a2, int a3, int a4) {}

List<Figura> l = List.of(new Figura(12, 12, 12, 12, 45, 45, 135, 135),
                         new Figura(2, 2, 2, 2, 90, 90, 90, 90),
                         new Figura(1, 2, 1, 2, 90, 90, 90, 90));
// ...
// result = [Figura2, Figura3]

Restituire uno stream che contenga il lato minore per ogni figura

List<Figura> l = List.of(new Figura(12, 12, 12, 12, 45, 45, 135, 135),
                         new Figura(2, 2, 2, 2, 90, 90, 90, 90),
                         new Figura(1, 2, 1, 2, 90, 90, 90, 90));
// ...
// result = [12, 2, 1]

Restituire il perimetro minore tra tutte le figure

List<Figura> l = List.of(new Figura(12, 12, 12, 12, 45, 45, 135, 135),
                         new Figura(2, 2, 2, 2, 90, 90, 90, 90),
                         new Figura(1, 2, 1, 2, 90, 90, 90, 90));
// ...
// result = 6

Ottenere la somma del valore dell'area di tutte le figure

List<Figura> l = List.of(new Figura(12, 12, 12, 12, 45, 45, 135, 135),
                         new Figura(2, 2, 2, 2, 90, 90, 90, 90),
                         new Figura(1, 2, 1, 2, 90, 90, 90, 90));
// ...
// result = 150

Restituire la somma totale dei costi dei 2 prodotti meno cari

List<Prodotto> l = List.of(new Prodotto("p1", 80),
                           new Prodotto("p2", 40),
                           new Prodotto("p3", 10),
                           new Prodotto("p4", 90));
// ...
// result = 50

Restituire la lista di lati maggiori dei triangoli.

List<Triangolo> l = List.of(new Triangolo(3, 4, 5, 30, 60, 90),
                            new Triangolo(4, 5, 4, 30, 30, 120),
                            new Triangolo(13, 5, 12, 30, 60, 90),
                            new Triangolo(17, 15, 8, 30, 60, 90));
// ...
// result = [5, 5, 13, 17]

Restituire una lista di triangoli isosceli. Un triangolo è isoscele se due suoi lati sono uguali.

List<Triangolo> l = List.of(new Triangolo(3, 4, 5, 30, 60, 90),
                            new Triangolo(4, 5, 4, 30, 30, 120),
                            new Triangolo(13, 5, 12, 30, 60, 90),
                            new Triangolo(17, 15, 8, 30, 60, 90));
// ...
// result = [Triangolo2]

Creare un metodo che prende in ingresso due parametri, min e max, e restituisce una lista di istanze di persona costituita da elementi di gente che hanno età compresa fra min e max.

public record Persona(String nome, int eta, String nazione) {}

int min = 20, max = 40;
List<Persona> l = List.of(new Persona("p1", 10, "n1"),
                          new Persona("p2", 20, "n1"),
                          new Persona("p3", 30, "n2"),
                          new Persona("p4", 40, "n3"),
                          new Persona("p5", 50, "n3"));
// ...
// result = [p2, p3, p4]

Calcolare la somma delle età di tutte le persone nella lista.

public record Persona(String nome, int eta, String nazione) {}

int min = 20, max = 40;
List<Persona> l = List.of(new Persona("p1", 10, "n1"),
                          new Persona("p2", 20, "n1"),
                          new Persona("p3", 30, "n2"),
                          new Persona("p4", 40, "n3"),
                          new Persona("p5", 50, "n3"));
// ...
// result = 140

Restituire la lista di nazioni senza ripetizioni presenti in una lista di gente.

public record Persona(String nome, int eta, String nazione) {}

int min = 20, max = 40;
List<Persona> l = List.of(new Persona("p1", 10, "n1"),
                          new Persona("p2", 20, "n1"),
                          new Persona("p3", 30, "n2"),
                          new Persona("p4", 40, "n3"),
                          new Persona("p5", 50, "n3"));
// ...
// result = [n1, n2, n3]

Restituire una mappa contenente le coppie (nome persone - nazione).

public record Persona(String nome, int eta, String nazione) {}

int min = 20, max = 40;
List<Persona> l = List.of(new Persona("p1", 10, "n1"),
                          new Persona("p2", 20, "n1"),
                          new Persona("p3", 30, "n2"),
                          new Persona("p4", 40, "n3"),
                          new Persona("p5", 50, "n3"));
// ...
// result = {"p1" -> "n1", "p2" -> "n1", "p3" -> "n2", "p4" -> "n3", "p5" -> "n3"}