├── .gitignore ├── README.md ├── esercizio labirinto ├── Immagini │ ├── immagini.txt │ ├── laby.gif │ ├── preview.png │ └── rogue.png └── readme.md ├── modulo10 └── readme.md ├── modulo13 ├── miniEcommerce │ └── readme.md └── tree_express │ └── readme.md ├── modulo4 ├── esercizio_automobili │ ├── src │ │ ├── Automobile.java │ │ └── Main.java │ └── traccia.txt ├── esercizio_cc │ └── README.md ├── negozio │ ├── Cliente.java │ ├── GenereProdotto.java │ ├── GiorniSettimana.java │ ├── Main.java │ ├── Negozio.MD │ ├── Negozio.java │ └── Prodotto.java ├── readme.txt └── riparazioni │ ├── DittaRiparazioni.java │ ├── DittaRiparazioniClassDiagram.png │ ├── DittaRiparazioniMain.java │ ├── README.MD │ ├── Riparazione.java │ └── Tecnico.java ├── modulo5 ├── CompagniaSharedMobility │ ├── Automobile.java │ ├── Bicicletta.java │ ├── CompagniaSharedMobility.java │ ├── CompagniaSharedMobilityClassDiagram.png │ ├── CompagniaSharedMobilityMain.java │ ├── Database.java │ ├── Furgoncino.java │ ├── MonopattinoElettrico.java │ ├── Noleggio.java │ ├── Patente.java │ ├── Scooter.java │ ├── Utente.java │ ├── Veicolo.java │ ├── VeicoloImmatricolato.java │ ├── VeicoloNonImmatricolato.java │ └── readme.md ├── FormeGeometriche │ ├── FormaGeometrica.java │ ├── FormeGeometriche.MD │ ├── FormeGeometricheClassDiagram.png │ ├── FormeGeometricheMain.java │ ├── Quadrato.java │ └── Rettangolo.java ├── SerieAChart │ ├── ClassificaSerieA.java │ ├── Giocatore.java │ ├── SerieAChartClassDiagram.png │ ├── SerieAChartMain.java │ ├── SerieAChart🏍.md │ └── Squadra.java ├── distributore bevande │ ├── Caffe.java │ ├── Cappuccino.java │ ├── DistributoreDiBevande.java │ ├── DistributoreProdotti.java │ ├── Main.java │ ├── Prodotti.java │ ├── Prodotto.java │ ├── distributore_bevande │ │ ├── Caffe.java │ │ ├── Cappuccino.java │ │ ├── DistributoreProdotti.java │ │ ├── Main.java │ │ └── Prodotti.java │ └── readme.md └── gestore veicoli │ ├── Autocarro.java │ ├── Automobile.java │ ├── GestioneVeicoli.java │ ├── Veicolo.java │ └── readme.md ├── modulo6 ├── iterabile │ ├── Iterabile.java │ ├── IterabileAstract.java │ ├── IterabileMain.java │ ├── ListaDiInteri.java │ ├── MiaStringa.java │ └── readme.md └── lista │ ├── AbstractLista.java │ ├── Lista.java │ ├── ListaDiInteri.java │ ├── Main.java │ ├── MiaStringa.java │ └── readme.md ├── modulo7 ├── dizionario │ ├── Dictionary.java │ ├── DictionaryMain.java │ └── readme.md ├── dragonball │ ├── Attacco.java │ ├── Combattimento.java │ ├── DragonBallMain.java │ ├── Personaggio.java │ ├── RazzaPersonaggio.java │ ├── Utility.java │ └── readme.md ├── libreria │ ├── Autore.java │ ├── Biblioteca.java │ ├── LibreriaMain.java │ ├── Libro.java │ └── readme.md ├── pila │ ├── ElementoListaLinkata.java │ ├── ListaLinkata.java │ ├── ListaLinkataMain.java │ ├── Pila.java │ └── readme.md ├── supermarket │ ├── Cliente.java │ ├── ClienteComparator.java │ ├── SupermarketMain.java │ ├── Supermercato.java │ └── readme.md └── tinder_like │ ├── Interest.java │ ├── TinderLike.java │ ├── TinderLikeMain.java │ ├── User.java │ └── readme.md ├── modulo8 └── turista │ └── readme.md └── modulo9 ├── parole └── readme.md └── righe ├── readme.md └── righe.txt /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled class file 2 | *.class 3 | 4 | # Log file 5 | *.log 6 | 7 | # BlueJ files 8 | *.ctxt 9 | 10 | # Mobile Tools for Java (J2ME) 11 | .mtj.tmp/ 12 | 13 | # Package Files # 14 | *.jar 15 | *.war 16 | *.nar 17 | *.ear 18 | *.zip 19 | *.tar.gz 20 | *.rar 21 | 22 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 23 | hs_err_pid* 24 | 25 | .DS_Store 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Corso-Java-Backend-2022-02 2 | Repository dove verranno caricate le soluzioni degli esercizi del corso 3 | -------------------------------------------------------------------------------- /esercizio labirinto/Immagini/immagini.txt: -------------------------------------------------------------------------------- 1 | cartella con le immagini dell'esercizio 2 | -------------------------------------------------------------------------------- /esercizio labirinto/Immagini/laby.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/esercizio labirinto/Immagini/laby.gif -------------------------------------------------------------------------------- /esercizio labirinto/Immagini/preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/esercizio labirinto/Immagini/preview.png -------------------------------------------------------------------------------- /esercizio labirinto/Immagini/rogue.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/esercizio labirinto/Immagini/rogue.png -------------------------------------------------------------------------------- /esercizio labirinto/readme.md: -------------------------------------------------------------------------------- 1 | # Labyrinth 2 | 3 | Negli anni 80 molti videogiochi :video_game: avevano una grafica "testuale" e cioè usavano i caratteri base del computer per disegnare a schermo. 4 | 5 | ![Rogue](Immagini/rogue.png) 6 | 7 | Possiamo rappresentare un labirinto come una matrice di caratteri, in cui il carattere "-" rappresenta uno spazio vuoto, la "P" la posizione del giocatore e la "E" l’uscita. 8 | 9 | 10 | ![Possibile labirinto](Immagini/preview.png) 11 | 12 | 13 | 14 | Scrivete un programma che permette ad un utente di giocare al vostro labirinto. Per farlo potrà scrivere sulla console di java le lettere «WASD» per muoversi (come in molti videogiochi per PC). Quando il giocatore raggiunge il traguardo, verrà avvisato di aver vinto e il programma termina. 15 | 16 | 17 | ## Esempio di come funziona 18 | ![test](Immagini/laby.gif) 19 | 20 | 21 | ## :smiling_face_with_three_hearts: Bonus stage: 22 | 23 | Generate il labirinto randomicamente 24 | 25 | # :skull_and_crossbones: Ultra mega bonus stage: 26 | ## Io ve lo dico, è difficile... 27 | Fate in modo che il computer sia in grado di risolvere da solo il labirinto. 28 | -------------------------------------------------------------------------------- /modulo10/readme.md: -------------------------------------------------------------------------------- 1 | ## MyStringBuilder 🛴 2 | 3 | Progettare una classe `MyStringBuilder` che consenta di costruire una stringa (che possiamo "wrappare" in una classe 4 | `MyString`) e di concatenarne altre step-by-btep. 5 | 6 | Il risultato finale dovrebbe essere analogo al comportamento della classe `StringBuilder` già esistente 7 | ([qui](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html) la documentazione). 8 | 9 | ```Java 10 | StringBuilder sb = new StringBuilder(); 11 | 12 | sb.append("Facilissimo") 13 | .append(" concatenare") 14 | .append(" stringhe!"); 15 | 16 | String finalString = sb.toString(); 17 | 18 | System.out.println(finalString); 19 | ``` 20 | 21 | La classe `MyStringBuilder` dovrà quindi implementare almeno: 22 | - la possibilità di costruire una `MyString` a partire da una stringa o partendo da zero 23 | - un metodo `append` che consenta di aggiungere una stringa all'istanza attuale 24 | - un metodo `build` che si occupi di costruire e restituire l'istanza finale della classe `MyString` 25 | 26 | E consentire la corretta esecuzione del seguente codice: 27 | 28 | ```Java 29 | MyStringBuilder msb = new MyStringBuilder(); 30 | // oppure MyString.Builder msb = new MyString.Builder(); 31 | // se avete utilizzato una classe innestata 32 | 33 | msb.append("Facilissimo") 34 | .append(" concatenare") 35 | .append(" stringhe!"); 36 | 37 | MyString myFinalString = msb.build(); 38 | 39 | System.out.println(myFinalString.toString()); 40 | ``` 41 | 42 | Feel free to improve your StringBuilder! -------------------------------------------------------------------------------- /modulo13/miniEcommerce/readme.md: -------------------------------------------------------------------------------- 1 | Esercizio Mini E-Commerce 🛴 2 | 3 | Creare un Web Service in grado di gestire una piccola piattaforma di e-commerce dedicata 4 | alla vendita di prodotti. Ogni prodotto acquistabile possiede un id univoco, un nome, una breve 5 | descrizione, una quantità di disponibilità in stock e un prezzo. 6 | In particolare, devono essere esposte tramite API le seguenti operazioni: 7 | 8 | - aggiungi prodotto: aggiunge un prodotto alla lista dei prodotti disponibili 9 | - elimina prodotto: rimuove un prodotto dalla lista dei prodotti disponibili 10 | - elenco prodotti disponibili: ritorna la lista dei prodotti disponibili 11 | - PLUS 🛵: acquista prodotto (specificando l'id del prodotto e la quantità) 12 | 13 | Utilizzate i giusti codici di stato per gestire ad esempio prodotti inesistenti, stock 14 | terminato ecc. 15 | 16 | Se avete difficoltà col formato JSON, chiamatemi e lo facciamo insieme :) -------------------------------------------------------------------------------- /modulo13/tree_express/readme.md: -------------------------------------------------------------------------------- 1 | Esercizio TreeExpress 🛵 2 | 3 | Creare un Web Service in grado di gestire un servizio di spedizione di pacchi. Ogni spedizione 4 | può avere 2 stati: in consegna e consegnata. Ogni utente possiede un nome, un cognome e 5 | un indirizzo. 6 | In particolare, devono essere esposte tramite API le seguenti operazioni: 7 | 8 | - crea utente: crea un utente 9 | - crea spedizione: crea una nuova spedizione a partire da un codice 10 | utente mittente, un codice utente destinatario e un peso. Inoltre, la mette in consegna. 11 | - annulla spedizione: rimuove una spedizione, se non è già stata consegnata 12 | - consegna spedizione: imposta una spedizione come consegnata 13 | - spedizioni in transito: restituisce le spedizioni in transito 14 | - spedizioni in ingresso di un utente: dato un utente, ritorna la sua lista di spedizioni 15 | delle quali è destinatario 16 | 17 | Ogni spedizione ha un codice, un peso, un mittente e un destinatario. 18 | 19 | Utilizzate i giusti codici di stato per gestire ad esempio prodotti inesistenti, stock 20 | terminato ecc. 21 | 22 | Se avete difficoltà col formato JSON, chiamatemi e lo facciamo insieme -------------------------------------------------------------------------------- /modulo4/esercizio_automobili/src/Automobile.java: -------------------------------------------------------------------------------- 1 | public class Automobile { 2 | 3 | // attributi d'istanza 4 | private String marchio; 5 | private String modello; 6 | private int cilindrata; 7 | private int nMarce; 8 | // attributi di stato 9 | private int marciaInserita; 10 | private boolean motoreAcceso; 11 | 12 | // costruttori 13 | public Automobile(String marchio, String modello, int cilindrata, int nMarce) { 14 | this.marchio = marchio; 15 | this.modello = modello; 16 | this.cilindrata = cilindrata; 17 | this.nMarce = nMarce; 18 | this.marciaInserita = 0; 19 | this.motoreAcceso = false; 20 | } 21 | 22 | // metodi 23 | 24 | /* questo metodo cambia lo stato del motore da spento ad acceso */ 25 | public void accendiMotore() { 26 | if (!motoreAcceso) { 27 | motoreAcceso = true; 28 | } 29 | else { 30 | System.out.println("Non puoi accendere un motore già acceso!"); 31 | } 32 | } 33 | 34 | /* questo metodo cambia lo stato del motore da acceso a spento */ 35 | public void spegniMotore() { 36 | if (motoreAcceso) { 37 | motoreAcceso = false; 38 | marciaInserita = 0; 39 | } 40 | else { 41 | System.out.println("Non puoi spegnere un motore già spento!"); 42 | } 43 | } 44 | 45 | /* questo metodo aumenta la marcia dell'auto */ 46 | public void aumentaMarcia() { 47 | if (marciaInserita != nMarce) { 48 | this.marciaInserita++; 49 | } 50 | else { 51 | System.out.println("Non puoi aumentare una marcia se stai già sull'ultima!"); 52 | } 53 | } 54 | 55 | /* questo metodo scala la marcia dell'auto */ 56 | public void scalaMarcia() { 57 | if (marciaInserita != -1) { 58 | this.marciaInserita--; 59 | } 60 | else { 61 | System.out.println("Non puoi scalare oltre la retromarcia!"); 62 | } 63 | } 64 | 65 | /* questo metodo cambia la marcia inserita nella marcia n presa in input */ 66 | public void inserisciMarcia(int n) { 67 | if (n >= -1 && n <= nMarce) { 68 | this.marciaInserita = n; 69 | } 70 | else { 71 | System.out.println("Marcia inserita non valida"); 72 | } 73 | } 74 | 75 | public String toString() { 76 | String s = ""; 77 | s += "Marchio: " + this.marchio + "\n"; 78 | s += "Modello: " + this.modello + "\n"; 79 | s += "Cilindrata: " + this.cilindrata + "\n"; 80 | s += "Numero di marce: " + this.nMarce + "\n"; 81 | s += "Il motore è acceso: " + this.motoreAcceso + "\n"; 82 | s += "La marcia inserita è: " + this.marciaInserita + "\n"; 83 | return s; 84 | } 85 | 86 | } 87 | -------------------------------------------------------------------------------- /modulo4/esercizio_automobili/src/Main.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | 3 | public static void main(String[] args) { 4 | Automobile automobile = new Automobile("Ferrari", "Testarossa", 4000, 6); 5 | System.out.println(automobile); 6 | System.out.println(); 7 | automobile.accendiMotore(); 8 | System.out.println(automobile); 9 | System.out.println(); 10 | automobile.aumentaMarcia(); 11 | automobile.aumentaMarcia(); 12 | System.out.println(automobile); 13 | System.out.println(); 14 | automobile.scalaMarcia(); 15 | System.out.println(automobile); 16 | System.out.println(); 17 | automobile.inserisciMarcia(6); 18 | System.out.println(automobile); 19 | System.out.println(); 20 | automobile.aumentaMarcia(); 21 | automobile.spegniMotore(); 22 | System.out.println(automobile); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /modulo4/esercizio_automobili/traccia.txt: -------------------------------------------------------------------------------- 1 | Scrivere un programma che gestisca delle automobili. Creare dunque una classe Automobile 2 | con i seguenti attributi: 3 | - modello 4 | - marchio 5 | - cilindrata 6 | - numero di marce 7 | - marcia inserita 8 | - motore acceso, di default il motore è spento 9 | 10 | I metodi da progettare sono i seguenti: 11 | - accendiMotore() che accende il motore nel caso in cui il motore sia spento 12 | - spegniMotore() che spegne il motore nel caso in cui il motore sia acceso 13 | - aumentaMarcia() che incrementa la marcia a quella successiva 14 | - scalaMarcia() che decrementa la marcia a quella inferiore 15 | - inserisciMarcia(n) che setta la marcia ad n 16 | 17 | Creare poi un main per testare i vari metodi. 18 | -------------------------------------------------------------------------------- /modulo4/esercizio_cc/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo4/esercizio_cc/README.md -------------------------------------------------------------------------------- /modulo4/negozio/Cliente.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public class Cliente { 4 | private int eta; 5 | private String nome; 6 | 7 | public Cliente(int eta, String nome) { 8 | this.eta = eta; 9 | this.nome = nome; 10 | } 11 | 12 | public int getEta() { 13 | return eta; 14 | } 15 | 16 | public String getNome() { 17 | return nome; 18 | } 19 | 20 | public void setNome(String nome) { 21 | this.nome = nome; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /modulo4/negozio/GenereProdotto.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public enum GenereProdotto { 4 | ALIMENTARE, NON_ALIMENTARE 5 | } 6 | -------------------------------------------------------------------------------- /modulo4/negozio/GiorniSettimana.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public enum GiorniSettimana { 4 | LUNEDI, MARTEDI, MERCOLEDI, GIOVEDI, VENERDI, SABATO, DOMENICA 5 | } 6 | -------------------------------------------------------------------------------- /modulo4/negozio/Main.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo4/negozio/Main.java -------------------------------------------------------------------------------- /modulo4/negozio/Negozio.MD: -------------------------------------------------------------------------------- 1 | Creare un sistema in grado di gestire i prodotti venduti in un negozio. Si tratta di un negozio in pieno centro storico, quindi potrà gestire al massimo 100 tipi diversi di prodotto. In particolare, il si tratta di un supermercato dove si vendono sia beni alimentari che non. Inoltre, il proprietario ha deciso di fare uno sconto del 20% sui prodotti di genere alimentare tutti i lunedì e mercoledì per i clienti con più di 60 anni. Ogni prodotto ha un nome e un prezzo. E' ovviamente possibile acquistare più prodotti simultaneamente. Deve essere possibile per il negoziante: 2 | 3 | aggiungere un nuovo prodotto (Se un prodotto è già presente, va aggiornata solo la quantità rimanente) 4 | rimuovere un prodotto 5 | ottenere la quantità rimanente di ogni prodotto 6 | Deve essere possibile per il cliente: 7 | 8 | acquistare uno o più prodotti (ottenendo il totale da pagare) 9 | Non deve essere possibile acquistare un prodotto se la quantità rimanente è 0. 10 | 11 | Plus 1: implementare una logica di pagamento rateizzato che in base al numero di mesi e all'importo 12 | da pagare restituisca l'ammontare mensile della rata 13 | 14 | Plus 2: "I regalissimi": ogni 10 euro spesi 1 punto regalo, ogni 10 punti regalo 1 euro di sconto -------------------------------------------------------------------------------- /modulo4/negozio/Negozio.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo4/negozio/Negozio.java -------------------------------------------------------------------------------- /modulo4/negozio/Prodotto.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public class Prodotto { 4 | private String codice; 5 | private double prezzo; 6 | private int quantita; 7 | private GenereProdotto genere; 8 | 9 | public Prodotto(String codice, double prezzo, int quantita, GenereProdotto genere) { 10 | this.codice = codice; 11 | this.prezzo = prezzo; 12 | this.quantita = quantita; 13 | this.genere = genere; 14 | } 15 | 16 | public String getCodice() { 17 | return codice; 18 | } 19 | 20 | public void setCodice(String codice) { 21 | this.codice = codice; 22 | } 23 | 24 | public double getPrezzo() { 25 | return prezzo; 26 | } 27 | 28 | public void setPrezzo(double prezzo) { 29 | this.prezzo = prezzo; 30 | } 31 | 32 | public int getQuantita() { 33 | return quantita; 34 | } 35 | 36 | public void setQuantita(int quantita) { 37 | this.quantita = quantita; 38 | } 39 | 40 | public GenereProdotto getGenere() { 41 | return genere; 42 | } 43 | 44 | public void setGenere(GenereProdotto genere) { 45 | this.genere = genere; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /modulo4/readme.txt: -------------------------------------------------------------------------------- 1 | Modulo sulla OOP 2 | -------------------------------------------------------------------------------- /modulo4/riparazioni/DittaRiparazioni.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | import java.util.Arrays; 4 | 5 | public class DittaRiparazioni { 6 | // Attributi 7 | 8 | private Tecnico[] listaTecnici; 9 | private Riparazione[] listaRiparazioni; 10 | 11 | // Costruttore 12 | 13 | public DittaRiparazioni() { 14 | this.listaTecnici = new Tecnico[0]; 15 | this.listaRiparazioni = new Riparazione[0]; 16 | } 17 | 18 | // Setter 19 | 20 | public void setListaTecnici(Tecnico[] listaTecnici) { 21 | this.listaTecnici = listaTecnici; 22 | } 23 | 24 | public void setListaRiparazioni(Riparazione[] listaRiparazioni) { 25 | this.listaRiparazioni = listaRiparazioni; 26 | } 27 | 28 | // Getter 29 | 30 | public Tecnico[] getListaTecnici() { 31 | return listaTecnici; 32 | } 33 | 34 | public Riparazione[] getListaRiparazioni() { 35 | return listaRiparazioni; 36 | } 37 | 38 | // Funzioni 39 | 40 | public void aggiungiRiparazione(String indirizzo, int priorita) { 41 | if (priorita >= 1 && priorita <= 10) { 42 | Riparazione nuovaRiparazione = new Riparazione(indirizzo, priorita); 43 | 44 | Riparazione[] riparazioniAggiornate = new Riparazione[this.listaRiparazioni.length + 1]; 45 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 46 | riparazioniAggiornate[i] = this.listaRiparazioni[i]; 47 | } 48 | riparazioniAggiornate[this.listaRiparazioni.length] = nuovaRiparazione; 49 | this.listaRiparazioni = riparazioniAggiornate; 50 | } else { 51 | System.out.println("Livello di priorità " + priorita + " non valido. Inserire un valore compreso tra 1 e 10"); 52 | } 53 | } 54 | 55 | public Riparazione[] getListaRiparazioniInAttesa() { 56 | int numRiparazioniInAttesa = 0; 57 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 58 | if (this.listaRiparazioni[i].getTecnicoAssegnato() == null) { 59 | numRiparazioniInAttesa++; 60 | } 61 | } 62 | 63 | int indexRiparazioniInAttesa = 0; 64 | Riparazione[] listaRiparazioniInAttesa = new Riparazione[numRiparazioniInAttesa]; 65 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 66 | if (this.listaRiparazioni[i].getTecnicoAssegnato() == null) { 67 | listaRiparazioniInAttesa[indexRiparazioniInAttesa] = this.listaRiparazioni[i]; 68 | indexRiparazioniInAttesa++; 69 | } 70 | } 71 | 72 | return listaRiparazioniInAttesa; 73 | } 74 | 75 | public Riparazione getRiparazioneByIndirizzo(String indirizzo) { 76 | Riparazione riparazioneTrovata = null; 77 | 78 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 79 | if (this.listaRiparazioni[i].getIndirizzo().equals(indirizzo)) { 80 | riparazioneTrovata = this.listaRiparazioni[i]; 81 | break; 82 | } 83 | } 84 | 85 | return riparazioneTrovata; 86 | } 87 | 88 | public Riparazione getNextRiparazioneMaxPriorita() { 89 | Riparazione riparazioneMaxPriorita = null; 90 | Riparazione[] listaRiparazioniInAttesa = this.getListaRiparazioniInAttesa(); 91 | 92 | if (listaRiparazioniInAttesa.length > 0) { 93 | for (int i = 0; i < listaRiparazioniInAttesa.length; i++) { 94 | if (riparazioneMaxPriorita == null || listaRiparazioniInAttesa[i].getPriorita() > riparazioneMaxPriorita.getPriorita()) { 95 | riparazioneMaxPriorita = listaRiparazioniInAttesa[i]; 96 | } 97 | } 98 | } 99 | 100 | return riparazioneMaxPriorita; 101 | } 102 | 103 | public void assegnaRiparazione(String indirizzoRiparazione, String nomeTecnico) { 104 | Riparazione riparazioneTrovata = getRiparazioneByIndirizzo(indirizzoRiparazione); 105 | 106 | if (riparazioneTrovata != null && riparazioneTrovata.getTecnicoAssegnato() == null) { 107 | Tecnico tecnicoTrovato = getTecnicoByNome(nomeTecnico); 108 | 109 | if (tecnicoTrovato != null && !tecnicoTrovato.isInFerie()) { 110 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 111 | if (this.listaRiparazioni[i].getIndirizzo().equals(indirizzoRiparazione)) { 112 | this.listaRiparazioni[i].setTecnicoAssegnato(tecnicoTrovato); 113 | } 114 | } 115 | } else { 116 | System.out.println("Tecnico con nome " + nomeTecnico + " non trovato o in ferie"); 117 | } 118 | } else { 119 | System.out.println("Riparazione presso indirizzo " + indirizzoRiparazione + " non trovata o già assegnata"); 120 | } 121 | } 122 | 123 | public void segnaRiparazioneConclusa(String nomeTecnico) { 124 | Tecnico tecnicoTrovato = getTecnicoByNome(nomeTecnico); 125 | 126 | if (tecnicoTrovato != null) { 127 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 128 | if (this.listaRiparazioni[i].getTecnicoAssegnato() != null && 129 | this.listaRiparazioni[i].getTecnicoAssegnato().getNome().equals(nomeTecnico)) { 130 | this.listaRiparazioni[i].setConclusa(true); 131 | } 132 | } 133 | } else { 134 | System.out.println("Tecnico con nome " + nomeTecnico + " non trovato"); 135 | } 136 | } 137 | 138 | public Riparazione getRiparazioneNonConclusaByNomeTecnico(String nomeTecnico) { 139 | Riparazione riparazioneTrovata = null; 140 | 141 | for (int i = 0; i < this.listaRiparazioni.length; i++) { 142 | if (this.listaRiparazioni[i].getTecnicoAssegnato() != null && 143 | this.listaRiparazioni[i].getTecnicoAssegnato().getNome().equals(nomeTecnico) && 144 | !this.listaRiparazioni[i].isConclusa()) { 145 | riparazioneTrovata = this.listaRiparazioni[i]; 146 | break; 147 | } 148 | } 149 | 150 | return riparazioneTrovata; 151 | } 152 | 153 | public Tecnico getTecnicoByNome(String nome) { 154 | Tecnico tecnicoTrovato = null; 155 | 156 | for (int i = 0; i < this.listaTecnici.length; i++) { 157 | if (this.listaTecnici[i].getNome().equals(nome)) { 158 | tecnicoTrovato = this.listaTecnici[i]; 159 | break; 160 | } 161 | } 162 | 163 | return tecnicoTrovato; 164 | } 165 | 166 | public void aggiungiTecnico(String nomeTecnico) { 167 | Tecnico tecnicoTrovato = getTecnicoByNome(nomeTecnico); 168 | 169 | if (tecnicoTrovato == null) { 170 | Tecnico nuovoTecnico = new Tecnico(nomeTecnico); 171 | 172 | Tecnico[] tecniciAggiornati = new Tecnico[this.listaTecnici.length + 1]; 173 | for (int i = 0; i < this.listaTecnici.length; i++) { 174 | tecniciAggiornati[i] = this.listaTecnici[i]; 175 | } 176 | tecniciAggiornati[this.listaTecnici.length] = nuovoTecnico; 177 | this.listaTecnici = tecniciAggiornati; 178 | } else { 179 | System.out.println("Tecnico con nome " + nomeTecnico + " già presente in ditta"); 180 | } 181 | } 182 | 183 | public void mandaTecniciInFerie(String[] nomiTecnici) { 184 | for (int i = 0; i < nomiTecnici.length; i++) { 185 | Tecnico tecnicoTrovato = this.getTecnicoByNome(nomiTecnici[i]); 186 | if (tecnicoTrovato != null) { 187 | Riparazione riparazioneAssegnata = this.getRiparazioneNonConclusaByNomeTecnico(tecnicoTrovato.getNome()); 188 | if (riparazioneAssegnata == null) { 189 | tecnicoTrovato.setInFerie(true); 190 | System.out.println("Tecnico con nome " + nomiTecnici[i] + " mandato in ferie"); 191 | } else { 192 | System.out.println("Tecnico con nome " + nomiTecnici[i] + " già assegnato a riparazione " + 193 | riparazioneAssegnata.getIndirizzo() + ", impossibile mandare in ferie"); 194 | } 195 | } else { 196 | System.out.println("Tecnico con nome " + nomiTecnici[i] + " non trovato"); 197 | } 198 | } 199 | } 200 | 201 | @Override 202 | public String toString() { 203 | return "DittaRiparazioni{" + 204 | "listaTecnici=" + Arrays.toString(listaTecnici) + 205 | ", listaRiparazioni=" + Arrays.toString(listaRiparazioni) + 206 | '}'; 207 | } 208 | } 209 | -------------------------------------------------------------------------------- /modulo4/riparazioni/DittaRiparazioniClassDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo4/riparazioni/DittaRiparazioniClassDiagram.png -------------------------------------------------------------------------------- /modulo4/riparazioni/DittaRiparazioniMain.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | import java.util.Arrays; 4 | 5 | public class DittaRiparazioniMain { 6 | public static void main(String[] args) { 7 | DittaRiparazioni dittaRiparazioni = new DittaRiparazioni(); 8 | 9 | dittaRiparazioni.aggiungiTecnico("Luca"); 10 | dittaRiparazioni.aggiungiTecnico("Marco"); 11 | dittaRiparazioni.aggiungiTecnico("Marco"); 12 | dittaRiparazioni.aggiungiTecnico("Filippo"); 13 | 14 | System.out.println(Arrays.toString(dittaRiparazioni.getListaTecnici())); 15 | 16 | dittaRiparazioni.aggiungiRiparazione("via delle Rose, 3 - Roma", 6); 17 | dittaRiparazioni.aggiungiRiparazione("via degli Aranci, 10 - Roma", 8); 18 | dittaRiparazioni.aggiungiRiparazione("via delle Orchidee, 134 - Roma", 3); 19 | 20 | dittaRiparazioni.assegnaRiparazione(dittaRiparazioni.getNextRiparazioneMaxPriorita().getIndirizzo(), "Marco"); 21 | dittaRiparazioni.assegnaRiparazione(dittaRiparazioni.getNextRiparazioneMaxPriorita().getIndirizzo(), "Luca"); 22 | System.out.println(Arrays.toString(dittaRiparazioni.getListaRiparazioniInAttesa())); 23 | 24 | dittaRiparazioni.assegnaRiparazione("via delle Rose, 3 - Roma", "Filippo"); 25 | 26 | dittaRiparazioni.mandaTecniciInFerie(new String[]{"Luca", "Filippo"}); 27 | 28 | dittaRiparazioni.assegnaRiparazione(dittaRiparazioni.getNextRiparazioneMaxPriorita().getIndirizzo(), "Filippo"); 29 | 30 | dittaRiparazioni.segnaRiparazioneConclusa("Luca"); 31 | dittaRiparazioni.mandaTecniciInFerie(new String[]{"Luca"}); 32 | 33 | System.out.println(Arrays.toString(dittaRiparazioni.getListaTecnici())); 34 | System.out.println(Arrays.toString(dittaRiparazioni.getListaRiparazioni())); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /modulo4/riparazioni/README.MD: -------------------------------------------------------------------------------- 1 | # Ditta di Riparazioni 2 | 3 | Una ditta di riparazioni di caldaie vuole gestire gli interventi a domicilio. 4 | Progettare una classe Riparazione, che contiene l'indirizzo a cui recarsi, la priorità dell'intervento (es. un intero). 5 | Progettare una classe Tecnico, che rappresenta il tecnico che si occuperà della riparazione. 6 | 7 | Progettare quindi una classe DittaRiparazioni, che contiene un insieme di tecnici, che gestisce le seguenti funzioni: 8 | * aggiungere una nuova riparazione da fare 9 | * ottenere la lista delle riparazioni in attesa 10 | * ottenere la prossima riparazione con la maggior priorità 11 | * assegnare una riparazione ad un tecnico 12 | * marcare una riparazione come conclusa (può essere identificata dal nome del tecnico che la sta effettuando) 13 | * aggiungere un tecnico alla ditta 14 | * mandare in ferie un insieme di tecnici (identificati per nome) 15 | 16 | note: 17 | * dato che i tencici sono identificati per nome, non devono poter esistere due tecnici con lo stesso nome 18 | * non bisogna assegnare la stessa riparazione a due tecnici -------------------------------------------------------------------------------- /modulo4/riparazioni/Riparazione.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public class Riparazione { 4 | // Attributi 5 | 6 | private String indirizzo; 7 | private int priorita; // Valori: da 1 (min) a 10 (max) 8 | private Tecnico tecnicoAssegnato; 9 | private boolean conclusa; 10 | 11 | // Costruttore 12 | 13 | public Riparazione(String indirizzo, int priorita) { 14 | this.indirizzo = indirizzo; 15 | this.priorita = priorita; 16 | this.tecnicoAssegnato = null; 17 | this.conclusa = false; 18 | } 19 | 20 | // Setter 21 | 22 | public void setIndirizzo(String indirizzo) { 23 | this.indirizzo = indirizzo; 24 | } 25 | 26 | public void setPriorita(int priorita) { 27 | this.priorita = priorita; 28 | } 29 | 30 | public void setTecnicoAssegnato(Tecnico tecnicoAssegnato) { 31 | this.tecnicoAssegnato = tecnicoAssegnato; 32 | } 33 | 34 | public void setConclusa(boolean conclusa) { 35 | this.conclusa = conclusa; 36 | } 37 | 38 | // Getter 39 | 40 | public String getIndirizzo() { 41 | return indirizzo; 42 | } 43 | 44 | public int getPriorita() { 45 | return priorita; 46 | } 47 | 48 | public Tecnico getTecnicoAssegnato() { 49 | return tecnicoAssegnato; 50 | } 51 | 52 | public boolean isConclusa() { 53 | return conclusa; 54 | } 55 | 56 | // Funzioni 57 | 58 | @Override 59 | public String toString() { 60 | return "Riparazione{" + 61 | "indirizzo='" + indirizzo + '\'' + 62 | ", priorita=" + priorita + 63 | ", tecnicoAssegnato=" + tecnicoAssegnato + 64 | ", conclusa=" + conclusa + 65 | '}'; 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /modulo4/riparazioni/Tecnico.java: -------------------------------------------------------------------------------- 1 | package negozio; 2 | 3 | public class Tecnico { 4 | // Attributi 5 | 6 | private String nome; 7 | private boolean inFerie; 8 | 9 | // Costruttore 10 | 11 | public Tecnico(String nome) { 12 | this.nome = nome; 13 | this.inFerie = false; 14 | } 15 | 16 | // Setter 17 | 18 | public void setNome(String nome) { 19 | this.nome = nome; 20 | } 21 | 22 | public void setInFerie(boolean inFerie) { 23 | this.inFerie = inFerie; 24 | } 25 | 26 | // Getter 27 | 28 | public String getNome() { 29 | return nome; 30 | } 31 | 32 | public boolean isInFerie() { 33 | return inFerie; 34 | } 35 | 36 | // Funzioni 37 | 38 | @Override 39 | public String toString() { 40 | return "Tecnico{" + 41 | "nome='" + nome + '\'' + 42 | ", inFerie=" + inFerie + 43 | '}'; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Automobile.java: -------------------------------------------------------------------------------- 1 | public class Automobile extends VeicoloImmatricolato { 2 | // Costruttore 3 | 4 | public Automobile(String posizioneGeografica, int tariffaAlMinuto, String targa) { 5 | super(posizioneGeografica, tariffaAlMinuto, false, Patente.B, targa); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "\nAutomobile {\n" + 13 | super.toString() + 14 | "\n}\n"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Bicicletta.java: -------------------------------------------------------------------------------- 1 | public class Bicicletta extends VeicoloNonImmatricolato { 2 | // Costruttore 3 | 4 | public Bicicletta(String posizioneGeografica, int tariffaAlMinuto) { 5 | super(posizioneGeografica, tariffaAlMinuto, true, null); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "\nBicicletta \n{" + 13 | super.toString() + 14 | "\n}\n"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/CompagniaSharedMobility.java: -------------------------------------------------------------------------------- 1 | public class CompagniaSharedMobility { 2 | // Attributi 3 | 4 | private String nome; 5 | private Database database; 6 | 7 | // Costruttore 8 | 9 | public CompagniaSharedMobility(String nome) { 10 | this.nome = nome; 11 | this.database = new Database(); 12 | } 13 | 14 | // Getter e Setter 15 | 16 | public String getNome() { 17 | return nome; 18 | } 19 | 20 | public void setNome(String nome) { 21 | this.nome = nome; 22 | } 23 | 24 | // Metodi 25 | 26 | public void registrazioneCliente(Utente cliente) { 27 | this.database.aggiungiCliente(cliente); 28 | System.out.println("Cliente " + cliente.getNome() + " " + cliente.getCognome() + " registrato alla compagnia " + this.nome); 29 | } 30 | 31 | public void aggiuntaVeicolo(Veicolo veicolo) { 32 | this.database.aggiungiVeicolo(veicolo); 33 | System.out.println("Veicolo " + veicolo.getId() + " aggiunto alla compagnia " + this.nome); 34 | } 35 | 36 | public Veicolo[] getVeicoliDisponibili() { 37 | return this.database.getVeicoliDisponibili(); 38 | } 39 | 40 | public Utente[] getClientiRegistrati() { 41 | return this.database.getListaClientiRegistrati(); 42 | } 43 | 44 | public Noleggio[] getStoricoNoleggi() { 45 | return this.database.getStoricoNoleggi(); 46 | } 47 | 48 | public void noleggioVeicolo(Veicolo veicolo, Utente cliente, int durata) { 49 | // Check: credito residuo 50 | 51 | // Check 1: Durata >= 5 52 | if (durata >= 5) { 53 | // Check 2: Presenza Utente 54 | if (this.database.findUtenteByID(cliente.getId())) { 55 | // Check 3: Presenza Veicolo AND Disponibilità Veicolo 56 | if (this.database.findVeicoloDisponibileByID(veicolo.getId())) { 57 | // Check 4: Casco richiesto 58 | if (!veicolo.isCascoRichiesto() || ( veicolo.isCascoRichiesto()) && cliente.isCasco() ) { 59 | // Check 5: Patente richiesta 60 | boolean patenteTrovata = false; 61 | for (int i = 0; i < cliente.getPatenti().length; i++) { 62 | if (veicolo.getPatenteRichiesta() == cliente.getPatenti()[i]) { 63 | patenteTrovata = true; 64 | break; 65 | } 66 | } 67 | 68 | if (patenteTrovata) { 69 | // Check 6: Credito residuo 70 | int creditoDaScalare = durata * veicolo.getTariffaAlMinuto(); 71 | 72 | if (cliente.getCredito() >= creditoDaScalare) { 73 | Noleggio nuovoNoleggio = new Noleggio("25/06/2022", durata, creditoDaScalare, cliente, veicolo); 74 | this.database.aggiungiNoleggio(nuovoNoleggio); 75 | veicolo.setNoleggiato(true); 76 | System.out.println("Veicolo " + veicolo.getId() + " noleggiato dal cliente " + cliente.getNome() + " " + cliente.getCognome()); 77 | } else { 78 | System.out.println("L'utente " + cliente.getNome() + " " + cliente.getCognome() + " non possiede credito sufficiente"); 79 | } 80 | } else { 81 | System.out.println("L'utente " + cliente.getNome() + " " + cliente.getCognome() + " non possiede la patente richiesta"); 82 | } 83 | } else { 84 | System.out.println("L'utente " + cliente.getNome() + " " + cliente.getCognome() + " non possiede il casco, che è richiesto"); 85 | } 86 | } else { 87 | System.out.println("Veicolo " + veicolo.getId() + " non trovato o non disponibile"); 88 | } 89 | } else { 90 | System.out.println("Utente " + cliente.getNome() + " " + cliente.getCognome() + " non trovato"); 91 | } 92 | } else { 93 | System.out.println("Durata noleggio non valida, impostare un valore maggiore o uguale a 5 minuti"); 94 | } 95 | } 96 | 97 | public void restituzioneVeicolo(Veicolo veicolo) { 98 | // Check: Presenza Veicolo 99 | if (this.database.findVeicoloByID(veicolo.getId())) { 100 | veicolo.setNoleggiato(false); 101 | System.out.println("Veicolo " + veicolo.getId() + " restituito"); 102 | } else { 103 | System.out.println("Veicolo " + veicolo.getId() + " non trovato"); 104 | } 105 | } 106 | 107 | @Override 108 | public String toString() { 109 | return "CompagniaSharedMobility {" + 110 | "nome='" + nome + '\'' + 111 | ", database=" + database + 112 | '}'; 113 | } 114 | } 115 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/CompagniaSharedMobilityClassDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/CompagniaSharedMobility/CompagniaSharedMobilityClassDiagram.png -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/CompagniaSharedMobilityMain.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class CompagniaSharedMobilityMain { 4 | public static void main(String[] args) { 5 | // Aggiunta automobili 6 | Veicolo nissanMicra = new Automobile("Roma", 2, "BC123CF"); 7 | Veicolo fiatPanda = new Automobile("Milano", 1, "EE432GA"); 8 | Veicolo opelMokka = new Automobile("Lecce", 3, "GA934BC"); 9 | 10 | // Aggiunta Scooter 11 | Veicolo yamahaXMAX = new Scooter("Padova", 1, "LJ3663"); 12 | 13 | // Aggiunta Furgoncini 14 | Veicolo fiatDucato = new Furgoncino("Napoli", 4, "FF332ID"); 15 | 16 | // Aggiunta Bicicletta 17 | Veicolo niloxJ5 = new Bicicletta("Roma", 2); 18 | 19 | // Aggiunta Monopattino Elettrico 20 | Veicolo xiaomiMi = new MonopattinoElettrico("Trento",1); 21 | 22 | // Creazione CompagniaSharedMobility 23 | CompagniaSharedMobility enjoy = new CompagniaSharedMobility("Enjoy"); 24 | 25 | enjoy.aggiuntaVeicolo(nissanMicra); 26 | enjoy.aggiuntaVeicolo(fiatPanda); 27 | enjoy.aggiuntaVeicolo(opelMokka); 28 | enjoy.aggiuntaVeicolo(yamahaXMAX); 29 | enjoy.aggiuntaVeicolo(fiatDucato); 30 | enjoy.aggiuntaVeicolo(niloxJ5); 31 | 32 | System.out.println(Arrays.toString(enjoy.getVeicoliDisponibili())); 33 | 34 | Utente luca = new Utente("Luca", "Di Pietro Martinelli", "12/04/1989", "DPTCLU89D12...", new Patente[]{Patente.B}, false, 100); 35 | Utente paolo = new Utente("Paolo", "Rossi", "01/01/1946", "RSSPLA46A01...", new Patente[]{Patente.C}, true, 150); 36 | Utente mario = new Utente("Mario", "Bianchi", "02/02/1953", "BNCMRA53B02...", new Patente[]{Patente.A}, false, 200); 37 | 38 | enjoy.registrazioneCliente(luca); 39 | enjoy.registrazioneCliente(paolo); 40 | enjoy.registrazioneCliente(mario); 41 | 42 | System.out.println(Arrays.toString(enjoy.getClientiRegistrati())); 43 | 44 | enjoy.noleggioVeicolo(nissanMicra, luca, 30); 45 | System.out.println(Arrays.toString(enjoy.getClientiRegistrati())); 46 | System.out.println(Arrays.toString(enjoy.getStoricoNoleggi())); 47 | System.out.println(Arrays.toString(enjoy.getVeicoliDisponibili())); 48 | 49 | // Test Check Noleggio 1 (Durata) 50 | System.out.println("\nCheck Noleggio 1 (Durata):\n"); 51 | enjoy.noleggioVeicolo(opelMokka, paolo, 3); 52 | 53 | // Test Check Noleggio 2 (Presenza Utente) 54 | Utente giuseppe = new Utente("Giuseppe", "Felici", "11/03/1990", "...", new Patente[]{Patente.B}, false, 100); 55 | System.out.println("\nCheck Noleggio 2 (Presenza Utente):"); 56 | enjoy.noleggioVeicolo(opelMokka, giuseppe, 10); 57 | 58 | // Test Check Noleggio 3 (Presenza Veicolo) 59 | System.out.println("\nCheck Noleggio 3 (Presenza Veicolo):"); 60 | enjoy.noleggioVeicolo(xiaomiMi, paolo, 10); 61 | 62 | // Test Check Noleggio 4 (Casco Richiesto) 63 | System.out.println("\nCheck Noleggio 4 (Casco Richiesto):"); 64 | enjoy.noleggioVeicolo(niloxJ5, mario, 10); 65 | 66 | // Test Check Noleggio 5 (Patente Richiesta) 67 | System.out.println("\nCheck Noleggio 5 (Patente Richiesta):"); 68 | enjoy.noleggioVeicolo(yamahaXMAX, paolo, 10); 69 | 70 | // Test Check Noleggio 6 (Credito Residuo) 71 | enjoy.restituzioneVeicolo(nissanMicra); 72 | enjoy.noleggioVeicolo(fiatPanda, luca, 50); 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Database.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class Database { 4 | // Attributi 5 | 6 | private Utente[] listaClientiRegistrati; 7 | private Veicolo[] listaVeicoli; 8 | private Noleggio[] storicoNoleggi; 9 | 10 | // Costruttore 11 | 12 | public Database() { 13 | this.listaClientiRegistrati = new Utente[0]; 14 | this.listaVeicoli = new Veicolo[0]; 15 | this.storicoNoleggi = new Noleggio[0]; 16 | } 17 | 18 | // Getter e Setter 19 | 20 | public Utente[] getListaClientiRegistrati() { 21 | return listaClientiRegistrati; 22 | } 23 | 24 | public void setListaClientiRegistrati(Utente[] listaClientiRegistrati) { 25 | this.listaClientiRegistrati = listaClientiRegistrati; 26 | } 27 | 28 | public Veicolo[] getListaVeicoli() { 29 | return listaVeicoli; 30 | } 31 | 32 | public void setListaVeicoli(Veicolo[] listaVeicoli) { 33 | this.listaVeicoli = listaVeicoli; 34 | } 35 | 36 | public Noleggio[] getStoricoNoleggi() { 37 | return storicoNoleggi; 38 | } 39 | 40 | public void setStoricoNoleggi(Noleggio[] storicoNoleggi) { 41 | this.storicoNoleggi = storicoNoleggi; 42 | } 43 | 44 | // Metodi 45 | 46 | public Veicolo[] getVeicoliDisponibili() { 47 | int numVeicoliDisponibili = 0; 48 | 49 | for (int i = 0; i < this.listaVeicoli.length; i++) { 50 | if (!this.listaVeicoli[i].isNoleggiato()) { 51 | numVeicoliDisponibili++; 52 | } 53 | } 54 | 55 | int indexVeicoliDisponibili = 0; 56 | Veicolo[] veicoliDisponibili = new Veicolo[numVeicoliDisponibili]; 57 | 58 | for (int i = 0; i < this.listaVeicoli.length; i++) { 59 | if (!this.listaVeicoli[i].isNoleggiato()) { 60 | veicoliDisponibili[indexVeicoliDisponibili] = this.listaVeicoli[i]; 61 | indexVeicoliDisponibili++; 62 | } 63 | } 64 | 65 | return veicoliDisponibili; 66 | } 67 | 68 | public boolean findVeicoloByID(int idVeicolo) { 69 | boolean veicoloFound = false; 70 | 71 | for (int i = 0; i < this.listaVeicoli.length; i++) { 72 | if (this.listaVeicoli[i].getId() == idVeicolo) { 73 | veicoloFound = true; 74 | break; 75 | } 76 | } 77 | 78 | return veicoloFound; 79 | } 80 | 81 | public boolean findVeicoloDisponibileByID(int idVeicolo) { 82 | boolean veicoloFound = false; 83 | Veicolo[] veicoliDisponibili = this.getVeicoliDisponibili(); 84 | 85 | for (int i = 0; i < veicoliDisponibili.length; i++) { 86 | if (veicoliDisponibili[i].getId() == idVeicolo) { 87 | veicoloFound = true; 88 | break; 89 | } 90 | } 91 | 92 | return veicoloFound; 93 | } 94 | 95 | public boolean findUtenteByID(int idUtente) { 96 | boolean utenteFound = false; 97 | 98 | for (int i = 0; i < this.listaClientiRegistrati.length; i++) { 99 | if (this.listaClientiRegistrati[i].getId() == idUtente) { 100 | utenteFound = true; 101 | break; 102 | } 103 | } 104 | 105 | return utenteFound; 106 | } 107 | 108 | public void aggiungiCliente(Utente utente) { 109 | Utente[] listaClientiAggiornata = new Utente[this.listaClientiRegistrati.length + 1]; 110 | 111 | for (int i = 0; i < this.listaClientiRegistrati.length; i++) { 112 | listaClientiAggiornata[i] = this.listaClientiRegistrati[i]; 113 | } 114 | 115 | listaClientiAggiornata[this.listaClientiRegistrati.length] = utente; 116 | this.listaClientiRegistrati = listaClientiAggiornata; 117 | } 118 | 119 | public void aggiungiVeicolo(Veicolo veicolo) { 120 | Veicolo[] listaVeicoliAggiornata = new Veicolo[this.listaVeicoli.length + 1]; 121 | 122 | for (int i = 0; i < this.listaVeicoli.length; i++) { 123 | listaVeicoliAggiornata[i] = this.listaVeicoli[i]; 124 | } 125 | 126 | listaVeicoliAggiornata[this.listaVeicoli.length] = veicolo; 127 | this.listaVeicoli = listaVeicoliAggiornata; 128 | } 129 | 130 | public void aggiungiNoleggio(Noleggio noleggio) { 131 | Noleggio[] listaNoleggiAggiornata = new Noleggio[this.storicoNoleggi.length + 1]; 132 | 133 | for (int i = 0; i < this.storicoNoleggi.length; i++) { 134 | listaNoleggiAggiornata[i] = this.storicoNoleggi[i]; 135 | } 136 | 137 | listaNoleggiAggiornata[this.storicoNoleggi.length] = noleggio; 138 | this.storicoNoleggi = listaNoleggiAggiornata; 139 | 140 | noleggio.getCliente().setCredito(noleggio.getCliente().getCredito() - ( noleggio.getDurata() * noleggio.getVeicolo().getTariffaAlMinuto() )); 141 | } 142 | 143 | @Override 144 | public String toString() { 145 | return "Database {" + 146 | "listaClientiRegistrati=" + Arrays.toString(listaClientiRegistrati) + 147 | ", listaVeicoli=" + Arrays.toString(listaVeicoli) + 148 | ", storicoNoleggi=" + Arrays.toString(storicoNoleggi) + 149 | '}'; 150 | } 151 | } 152 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Furgoncino.java: -------------------------------------------------------------------------------- 1 | public class Furgoncino extends VeicoloImmatricolato { 2 | // Costruttore 3 | 4 | public Furgoncino(String posizioneGeografica, int tariffaAlMinuto, String targa) { 5 | super(posizioneGeografica, tariffaAlMinuto, false, Patente.C, targa); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "\nFurgoncino \n{" + 13 | super.toString() + 14 | "\n}"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/MonopattinoElettrico.java: -------------------------------------------------------------------------------- 1 | public class MonopattinoElettrico extends VeicoloNonImmatricolato { 2 | // Attributi 3 | 4 | private int livelloCarica; 5 | 6 | // Costruttore 7 | 8 | public MonopattinoElettrico(String posizioneGeografica, int tariffaAlMinuto) { 9 | super(posizioneGeografica, tariffaAlMinuto, false, null); 10 | this.livelloCarica = 100; // Min 0 - Max 100 11 | } 12 | 13 | // Getter e Setter 14 | 15 | public int getLivelloCarica() { 16 | return livelloCarica; 17 | } 18 | 19 | public void setLivelloCarica(int livelloCarica) { 20 | this.livelloCarica = livelloCarica; 21 | } 22 | 23 | // Metodi 24 | 25 | @Override 26 | public String toString() { 27 | return "\nMonopattinoElettrico \n{" + 28 | super.toString() + 29 | ",\n livelloCarica=" + livelloCarica + 30 | "\n}\n"; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Noleggio.java: -------------------------------------------------------------------------------- 1 | public class Noleggio { 2 | // Attributi 3 | 4 | private static int count = 1; 5 | private final int id; 6 | private String data; 7 | private int durata; 8 | private int costo; 9 | private Utente cliente; 10 | private Veicolo veicolo; 11 | 12 | // Costruttore 13 | 14 | public Noleggio(String data, int durata, int costo, Utente cliente, Veicolo veicolo) { 15 | this.id = count++; 16 | this.data = data; 17 | this.durata = durata; 18 | this.costo = costo; 19 | this.cliente = cliente; 20 | this.veicolo = veicolo; 21 | } 22 | 23 | // Getter e Setter 24 | 25 | public int getId() { 26 | return id; 27 | } 28 | 29 | public String getData() { 30 | return data; 31 | } 32 | 33 | public void setData(String data) { 34 | this.data = data; 35 | } 36 | 37 | public int getDurata() { 38 | return durata; 39 | } 40 | 41 | public void setDurata(int durata) { 42 | this.durata = durata; 43 | } 44 | 45 | public int getCosto() { 46 | return costo; 47 | } 48 | 49 | public void setCosto(int costo) { 50 | this.costo = costo; 51 | } 52 | 53 | public Utente getCliente() { 54 | return cliente; 55 | } 56 | 57 | public void setCliente(Utente cliente) { 58 | this.cliente = cliente; 59 | } 60 | 61 | public Veicolo getVeicolo() { 62 | return veicolo; 63 | } 64 | 65 | public void setVeicolo(Veicolo veicolo) { 66 | this.veicolo = veicolo; 67 | } 68 | 69 | // Metodi 70 | 71 | @Override 72 | public String toString() { 73 | return "Noleggio {" + 74 | "id=" + id + 75 | ", data='" + data + '\'' + 76 | ", durata=" + durata + 77 | ", costo=" + costo + 78 | ", cliente=" + cliente + 79 | ", veicolo=" + veicolo + 80 | '}'; 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Patente.java: -------------------------------------------------------------------------------- 1 | public enum Patente { 2 | A, 3 | B, 4 | C 5 | } 6 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Scooter.java: -------------------------------------------------------------------------------- 1 | public class Scooter extends VeicoloImmatricolato { 2 | // Costruttore 3 | 4 | public Scooter(String posizioneGeografica, int tariffaAlMinuto, String targa) { 5 | super(posizioneGeografica, tariffaAlMinuto, true, Patente.A, targa); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "\nScooter \n{" + 13 | super.toString() + 14 | "\n}"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Utente.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class Utente { 4 | // Attributi 5 | private static int count = 1; 6 | private final int id; 7 | private String nome; 8 | private String cognome; 9 | private String dataNascita; 10 | private String codiceFiscale; 11 | private Patente[] patenti; 12 | private boolean casco; 13 | private int credito; 14 | 15 | // Costruttore 16 | 17 | public Utente(String nome, String cognome, String dataNascita, String codiceFiscale, Patente[] patenti, boolean casco, int credito) { 18 | this.id = count++; 19 | this.nome = nome; 20 | this.cognome = cognome; 21 | this.dataNascita = dataNascita; 22 | this.codiceFiscale = codiceFiscale; 23 | this.patenti = patenti; 24 | this.casco = casco; 25 | this.credito = credito; 26 | } 27 | 28 | // Getter e Setter 29 | 30 | public int getId() { 31 | return id; 32 | } 33 | 34 | public String getNome() { 35 | return nome; 36 | } 37 | 38 | public void setNome(String nome) { 39 | this.nome = nome; 40 | } 41 | 42 | public String getCognome() { 43 | return cognome; 44 | } 45 | 46 | public void setCognome(String cognome) { 47 | this.cognome = cognome; 48 | } 49 | 50 | public String getDataNascita() { 51 | return dataNascita; 52 | } 53 | 54 | public void setDataNascita(String dataNascita) { 55 | this.dataNascita = dataNascita; 56 | } 57 | 58 | public String getCodiceFiscale() { 59 | return codiceFiscale; 60 | } 61 | 62 | public void setCodiceFiscale(String codiceFiscale) { 63 | this.codiceFiscale = codiceFiscale; 64 | } 65 | 66 | public Patente[] getPatenti() { 67 | return patenti; 68 | } 69 | 70 | public void setPatenti(Patente[] patenti) { 71 | this.patenti = patenti; 72 | } 73 | 74 | public boolean isCasco() { 75 | return casco; 76 | } 77 | 78 | public void setCasco(boolean casco) { 79 | this.casco = casco; 80 | } 81 | 82 | public int getCredito() { 83 | return credito; 84 | } 85 | 86 | public void setCredito(int credito) { 87 | this.credito = credito; 88 | } 89 | 90 | // Metodi 91 | 92 | public void ricaricaCredito(int creditoAggiuntivo) { 93 | if (creditoAggiuntivo > 0) { 94 | this.credito += creditoAggiuntivo; 95 | } else { 96 | System.out.println("Impossibile ricaricare, indicare un valore di credito positivo"); 97 | } 98 | } 99 | 100 | @Override 101 | public String toString() { 102 | return "\nUtente \n{" + 103 | "\nid=" + id + 104 | ",\n nome='" + nome + '\'' + 105 | ",\n cognome='" + cognome + '\'' + 106 | ",\n dataNascita='" + dataNascita + '\'' + 107 | ",\n codiceFiscale='" + codiceFiscale + '\'' + 108 | ",\n patenti=" + Arrays.toString(patenti) + 109 | ",\n casco=" + casco + 110 | ",\n credito=" + credito + 111 | "\n}"; 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/Veicolo.java: -------------------------------------------------------------------------------- 1 | public class Veicolo { 2 | // Attributi 3 | 4 | private static int count = 1; 5 | private final int id; 6 | private String posizioneGeografica; 7 | private int tariffaAlMinuto; 8 | private boolean cascoRichiesto; 9 | private boolean noleggiato; 10 | private Patente patenteRichiesta; 11 | 12 | // Costruttore 13 | 14 | public Veicolo(String posizioneGeografica, int tariffaAlMinuto, boolean cascoRichiesto, Patente patenteRichiesta) { 15 | this.id = count++; 16 | this.posizioneGeografica = posizioneGeografica; 17 | this.tariffaAlMinuto = tariffaAlMinuto; 18 | this.cascoRichiesto = cascoRichiesto; 19 | this.noleggiato = false; 20 | this.patenteRichiesta = patenteRichiesta; 21 | } 22 | 23 | // Getter e Setter 24 | 25 | public int getId() { 26 | return id; 27 | } 28 | 29 | public String getPosizioneGeografica() { 30 | return posizioneGeografica; 31 | } 32 | 33 | public void setPosizioneGeografica(String posizioneGeografica) { 34 | this.posizioneGeografica = posizioneGeografica; 35 | } 36 | 37 | public int getTariffaAlMinuto() { 38 | return tariffaAlMinuto; 39 | } 40 | 41 | public void setTariffaAlMinuto(int tariffaAlMinuto) { 42 | this.tariffaAlMinuto = tariffaAlMinuto; 43 | } 44 | 45 | public boolean isCascoRichiesto() { 46 | return cascoRichiesto; 47 | } 48 | 49 | public void setCascoRichiesto(boolean cascoRichiesto) { 50 | this.cascoRichiesto = cascoRichiesto; 51 | } 52 | 53 | public boolean isNoleggiato() { 54 | return noleggiato; 55 | } 56 | 57 | public void setNoleggiato(boolean noleggiato) { 58 | this.noleggiato = noleggiato; 59 | } 60 | 61 | public Patente getPatenteRichiesta() { 62 | return patenteRichiesta; 63 | } 64 | 65 | public void setPatenteRichiesta(Patente patenteRichiesta) { 66 | this.patenteRichiesta = patenteRichiesta; 67 | } 68 | 69 | // Metodo 70 | 71 | @Override 72 | public String toString() { 73 | return " id=" + id + 74 | ",\n posizioneGeografica='" + posizioneGeografica + '\'' + 75 | ",\n tariffaAlMinuto=" + tariffaAlMinuto + 76 | ",\n cascoRichiesto=" + cascoRichiesto + 77 | ",\n noleggiato=" + noleggiato + 78 | ",\n patenteRichiesta=" + patenteRichiesta; 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/VeicoloImmatricolato.java: -------------------------------------------------------------------------------- 1 | public class VeicoloImmatricolato extends Veicolo { 2 | // Attributi 3 | 4 | private String targa; 5 | private int livelloCarburante; 6 | 7 | // Costruttore 8 | 9 | public VeicoloImmatricolato(String posizioneGeografica, int tariffaAlMinuto, boolean cascoRichiesto, Patente patenteRichiesta, String targa) { 10 | super(posizioneGeografica, tariffaAlMinuto, cascoRichiesto, patenteRichiesta); 11 | this.targa = targa; 12 | this.livelloCarburante = 100; 13 | } 14 | 15 | 16 | // Getter e Setter 17 | 18 | public String getTarga() { 19 | return targa; 20 | } 21 | 22 | public void setTarga(String targa) { 23 | this.targa = targa; 24 | } 25 | 26 | public int getLivelloCarburante() { 27 | return livelloCarburante; 28 | } 29 | 30 | public void setLivelloCarburante(int livelloCarburante) { 31 | this.livelloCarburante = livelloCarburante; 32 | } 33 | 34 | // Metodi 35 | 36 | @Override 37 | public String toString() { 38 | return super.toString() + ",\n targa='" + targa + '\'' + 39 | ",\n livelloCarburante=" + livelloCarburante; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/VeicoloNonImmatricolato.java: -------------------------------------------------------------------------------- 1 | public class VeicoloNonImmatricolato extends Veicolo { 2 | // Costruttore 3 | 4 | public VeicoloNonImmatricolato(String posizioneGeografica, int tariffaAlMinuto, boolean cascoRichiesto, Patente patenteRichiesta) { 5 | super(posizioneGeografica, tariffaAlMinuto, cascoRichiesto, patenteRichiesta); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return super.toString(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /modulo5/CompagniaSharedMobility/readme.md: -------------------------------------------------------------------------------- 1 | # Compagnia Shared Mobility 🛵 2 | 3 |

4 | 5 |

6 | 7 | 8 | Una compagnia di [shared mobility](https://en.wikipedia.org/wiki/Shared_transport) vuole creare un'infrastruttura software per gestire i propri servizi e la proprio flotta. Il tipo di veicoli che offre agli utenti sono: automobili, moto scooter, biciclette, monopattini elettrici, furgoncini. La compagnia da un ID univoco interno ad ogni veicolo ma automobili, furgoncini e motorini hanno anche una targa. 9 | 10 | Eccetto le biciclette che non hanno bisogno di essere rifornite, automobili, scooter e furgoncini hanno bisogno di **carburante** mentre i monopattini elettrici hanno bisogno di **elettricità**. Inoltre biciclette e motorini hanno bisogno degli adeguati **caschi** per essere utilizzati mentre furgoni, automobili e scooter dell'adeguata **patente di guida**. 11 | 12 | La compagnia vuole poter conoscere per ogni veicolo la sua **posizione geografica**, se in un determinato momento è **affittato** o disponibile e infine lo stato del carburante o batteria (a seconda del tipo di veicolo). 13 | 14 | Un utente può affittare un veicolo pagando una certa tariffa al minuto (i prezzi li scegliete voi), **non è possibile affittare un veicolo per meno di 5 minuti.** 15 | 16 | Per quanto riguarda gli **utenti**, la compagnia vuole registrare i seguenti dati anagrafici: 17 | 18 | * Nome 19 | * Cognome 20 | * Data di nascita 21 | * Codice fiscale 22 | 23 | Oltre questi dati, l'azienda vuole dare un id univoco ad ogni utente, sapere quali patenti di guida possiede, se possiede un casco e permettere agli utenti di aggiungere del credito da spendere per gli affitti. 24 | 25 | Il sistema deve permettere ad un utente di registrarsi, cercare veicoli disponibili, affittare un veicolo, lasciare e cioè restituire un veicolo. 26 | 27 | 28 | Realizzate le classi e le funzionalità di questo sistema e fatevi un main dove testate il tutto. 29 | 30 | # DISCLAIMER 31 | 32 | Ovviamente un reale sistema del genere richiederebbe per gestire i dati un database che ancora non vi abbiamo spiegato. Createvi quindi una classe "Database" con all'interno liste degli oggetti che utilizzerete per questo sistema (lista utenti, lista automobili etc...). 33 | 34 | La traccia poi non è molto precisa su alcuni punti, questo perché vogliamo sia darvi la massima libertà per affrontare il problema e soprattutto darvi una situazione abbastanza realistica del mondo del lavoro reale, capita spesso che non soltanto vi possiate interfacciare con una persona non tecnica ma spesso il cliente non sa nemmeno di preciso cosa vuole veramente, sta a voi fare le domande giuste per arrivare ad un ottimo prodotto. 35 | 36 | # Modalità di lavoro 37 | 38 | Questo è un esercizio pensato per essere fatto in **gruppo** perciò ci aspettiamo una soluzione per ogni stanza. È obbligatorio creare una repository su cui aggiungere come collaboratore ogni membro del team. Massima libertà su come spartirvi il lavoro. Non è obbligatorio ma **fortemente gradito** un disegno con lo schema delle classi (va bene anche su carta, basta che si capisce). 39 | 40 | ## Suggerimenti 41 | 42 | HINT 1: Non esiste "la soluzione" di questo esercizio, è possibile tirare fuori due schemi di classi molto diversi tra di loro ed entrambi validi, esistono però soluzioni sbagliate che possono creare problemi di vario tipo. 43 | 44 | HINT 2: Se avete una domanda da fare sul sistema, fatela sul canale discord, è più veloce e potrebbe essere d'aiuto per altri gruppi. 45 | 46 | HINT 3: Se pensate che una certa libreria esterna può esservi utile per risolvere un determinato problema...Usatela! 47 | -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/FormaGeometrica.java: -------------------------------------------------------------------------------- 1 | public class FormaGeometrica { 2 | // Attributi 3 | 4 | private int base; 5 | private int altezza; 6 | 7 | // Costruttore 8 | public FormaGeometrica(int base, int altezza) { 9 | this.base = base; 10 | this.altezza = altezza; 11 | } 12 | 13 | // Setter 14 | 15 | public void setBase(int base) { 16 | this.base = base; 17 | } 18 | 19 | public void setAltezza(int altezza) { 20 | this.altezza = altezza; 21 | } 22 | 23 | // Getter 24 | 25 | public int getBase() { 26 | return base; 27 | } 28 | 29 | public int getAltezza() { 30 | return altezza; 31 | } 32 | 33 | // Metodi 34 | 35 | public int getArea() { 36 | return this.base * this.altezza; 37 | } 38 | 39 | public int getPerimeter() { 40 | return (this.base + this.altezza) * 2; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/FormeGeometriche.MD: -------------------------------------------------------------------------------- 1 | Esercizio Forme Geometriche 🛴 2 | 3 | Scrivere un programma in grado di modellare il concetto di forma geometrica 4 | associato a quadrati e rettangoli. In particolare, create le classi 5 | Quadrato e Rettangolo entrambe con le seguenti caratteristiche: 6 | Ogni Quadrato deve esporre 3 metodi: 7 | - getArea: ritorna un intero 8 | - getPerimeter: ritorna il perimetro dell’oggetto 9 | - toString: ritorna «quadrato» o «rettangolo» a seconda del tipo di oggetto 10 | 11 | Deve essere possibile eseguire il seguente codice: 12 | 13 | ``` 14 | Quadrato quadrato = new Quadrato(5); 15 | Rettangolo rettangolo = new Rettangolo(5,6); 16 | ``` 17 | 18 | Suggerimento: usate l’ereditarietà -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/FormeGeometricheClassDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/FormeGeometriche/FormeGeometricheClassDiagram.png -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/FormeGeometricheMain.java: -------------------------------------------------------------------------------- 1 | public class FormeGeometricheMain { 2 | public static void main(String[] args) { 3 | // Test Quadrato 4 | Quadrato quadrato = new Quadrato(5); 5 | System.out.println(quadrato); 6 | System.out.println("Area quadrato: " + quadrato.getArea()); 7 | System.out.println("Perimetro quadrato: " + quadrato.getPerimeter() + "\n"); 8 | 9 | // Test Rettangolo 10 | Rettangolo rettangolo = new Rettangolo(5,6); 11 | System.out.println(rettangolo); 12 | System.out.println("Area rettangolo: " + rettangolo.getArea()); 13 | System.out.println("Perimetro rettangolo: " + rettangolo.getPerimeter()); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/Quadrato.java: -------------------------------------------------------------------------------- 1 | public class Quadrato extends FormaGeometrica { 2 | // Costruttore 3 | 4 | public Quadrato(int lato) { 5 | super(lato, lato); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "Quadrato"; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /modulo5/FormeGeometriche/Rettangolo.java: -------------------------------------------------------------------------------- 1 | public class Rettangolo extends FormaGeometrica { 2 | // Costruttore 3 | 4 | public Rettangolo(int base, int altezza) { 5 | super(base, altezza); 6 | } 7 | 8 | // Metodi 9 | 10 | @Override 11 | public String toString() { 12 | return "Rettangolo"; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /modulo5/SerieAChart/ClassificaSerieA.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.Comparator; 3 | 4 | public class ClassificaSerieA { 5 | // Attributi 6 | 7 | private Squadra[] classifica; 8 | 9 | // Costruttore 10 | 11 | public ClassificaSerieA(Squadra[] classifica) { 12 | this.classifica = classifica; 13 | } 14 | 15 | // Getter e Setter 16 | 17 | public Squadra[] getClassifica() { 18 | return classifica; 19 | } 20 | 21 | public void setClassifica(Squadra[] classifica) { 22 | this.classifica = classifica; 23 | } 24 | 25 | // Metodi 26 | 27 | public void esitoPartita(Squadra squadraCasa, int golCasa, Squadra squadraOspite, int golOspite) { 28 | if (golCasa > golOspite) { 29 | squadraCasa.setPunteggio(squadraCasa.getPunteggio() + 3); 30 | } else if (golCasa < golOspite) { 31 | squadraOspite.setPunteggio(squadraOspite.getPunteggio() + 3); 32 | } else { 33 | squadraCasa.setPunteggio(squadraCasa.getPunteggio() + 1); 34 | squadraOspite.setPunteggio(squadraOspite.getPunteggio() + 1); 35 | } 36 | 37 | squadraCasa.setGolFatti(squadraCasa.getGolFatti() + golCasa); 38 | squadraOspite.setGolFatti(squadraOspite.getGolFatti() + golOspite); 39 | 40 | squadraCasa.setGolSubiti(squadraCasa.getGolSubiti() + golOspite); 41 | squadraOspite.setGolSubiti(squadraOspite.getGolSubiti() + golCasa); 42 | 43 | Arrays.sort(this.classifica, Comparator.comparingInt(Squadra::getPunteggio) 44 | .thenComparing(Squadra::getGolFatti) 45 | .thenComparing(Squadra::getId).reversed()); 46 | } 47 | 48 | public Squadra getMigliorAttacco() { 49 | Squadra squadraMigliorAttacco = null; 50 | 51 | for (int i = 0; i < this.classifica.length; i++) { 52 | if (squadraMigliorAttacco == null || this.classifica[i].getGolFatti() > squadraMigliorAttacco.getGolFatti()) { 53 | squadraMigliorAttacco = this.classifica[i]; 54 | } 55 | } 56 | 57 | return squadraMigliorAttacco; 58 | } 59 | 60 | public Squadra getPeggiorDifesa() { 61 | Squadra squadraPeggiorDifesa = null; 62 | 63 | for (int i = 0; i < this.classifica.length; i++) { 64 | if (squadraPeggiorDifesa == null || this.classifica[i].getGolSubiti() > squadraPeggiorDifesa.getGolSubiti()) { 65 | squadraPeggiorDifesa = this.classifica[i]; 66 | } 67 | } 68 | 69 | return squadraPeggiorDifesa; 70 | } 71 | 72 | @Override 73 | public String toString() { 74 | String output = "\nCLASSIFICA SERIE A:\n\nSquadra\t\tP\tGF\tGS\n"; 75 | 76 | for (int i = 0; i < classifica.length; i++) { 77 | output += classifica[i].getNome() + "\t" + 78 | classifica[i].getPunteggio() + "\t" + 79 | classifica[i].getGolFatti() + "\t" + 80 | classifica[i].getGolSubiti() + "\n"; 81 | } 82 | 83 | return output; 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /modulo5/SerieAChart/Giocatore.java: -------------------------------------------------------------------------------- 1 | public class Giocatore { 2 | // Attributi 3 | 4 | private static int count = 1; 5 | private final int id; 6 | private String nome; 7 | private String cognome; 8 | 9 | // Costruttore 10 | 11 | public Giocatore(String nome, String cognome) { 12 | this.id = count++; 13 | this.nome = nome; 14 | this.cognome = cognome; 15 | } 16 | 17 | // Getter e Setter 18 | 19 | public int getId() { 20 | return id; 21 | } 22 | 23 | public String getNome() { 24 | return nome; 25 | } 26 | 27 | public void setNome(String nome) { 28 | this.nome = nome; 29 | } 30 | 31 | public String getCognome() { 32 | return cognome; 33 | } 34 | 35 | public void setCognome(String cognome) { 36 | this.cognome = cognome; 37 | } 38 | 39 | // Metodi 40 | 41 | @Override 42 | public String toString() { 43 | return "Giocatore {" + 44 | "\n id=" + id + 45 | ",\n nome='" + nome + '\'' + 46 | ",\n cognome='" + cognome + '\'' + 47 | "\n}"; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /modulo5/SerieAChart/SerieAChartClassDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/SerieAChart/SerieAChartClassDiagram.png -------------------------------------------------------------------------------- /modulo5/SerieAChart/SerieAChartMain.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class SerieAChartMain { 4 | public static void main(String[] args) { 5 | Giocatore nicoloZaniolo = new Giocatore("Nicolò", "Zaniolo"); 6 | Giocatore tammyAbraham = new Giocatore("Tammy", "Abraham"); 7 | Squadra roma = new Squadra("A.S. Roma", new Giocatore[]{nicoloZaniolo, tammyAbraham}); 8 | 9 | Giocatore luisAlberto = new Giocatore("Luis", "Alberto"); 10 | Giocatore ciroImmobile = new Giocatore("Ciro", "Immobile"); 11 | Squadra lazio = new Squadra("S.S. Lazio", new Giocatore[]{luisAlberto, ciroImmobile}); 12 | 13 | Giocatore lautaroMartinez = new Giocatore("Lautaro", "Martinez"); 14 | Giocatore edinDzeko = new Giocatore("Edin", "Dzeko"); 15 | Squadra inter = new Squadra("F.C. Inter", new Giocatore[]{lautaroMartinez, edinDzeko}); 16 | 17 | Giocatore leaoMartinez = new Giocatore("Leao", "Martinez"); 18 | Giocatore zlatanIbrahimovic = new Giocatore("Zlatan", "Ibrahimovic"); 19 | Squadra milan = new Squadra("A.C. Milan", new Giocatore[]{leaoMartinez, zlatanIbrahimovic}); 20 | 21 | ClassificaSerieA classificaSerieA = new ClassificaSerieA(new Squadra[]{roma, lazio, inter, milan}); 22 | 23 | classificaSerieA.esitoPartita(roma, 3, lazio, 0); 24 | classificaSerieA.esitoPartita(milan, 1, inter, 0); 25 | 26 | classificaSerieA.esitoPartita(inter, 2, roma, 3); 27 | classificaSerieA.esitoPartita(lazio, 2, milan, 2); 28 | 29 | System.out.println(Arrays.toString(classificaSerieA.getClassifica())); 30 | System.out.println("\nMiglior attacco:\n" + classificaSerieA.getMigliorAttacco()); 31 | System.out.println("\nPeggior difesa:\n" + classificaSerieA.getPeggiorDifesa()); 32 | System.out.println(classificaSerieA); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /modulo5/SerieAChart/SerieAChart🏍.md: -------------------------------------------------------------------------------- 1 | # Esercizio Classifica Serie A 🏍 2 | 3 | Progettare una classe Classifica che permetta di gestire la classifica di Serie A costruita a partire da 20 squadre di calcio. Ogni squadra di calcio ha i seguenti attributi: 4 | 5 | * id 6 | * nome 7 | * rosa di giocatori 8 | * punteggio 9 | * gol fatti 10 | * gol subiti 11 | 12 | Ogni giocatore ha un id, un nome e un cognome. In particolare, deve essere possibile gestire le seguenti operazioni: 13 | 14 | * esitoPartita(squadraCasa, golCasa, squadraOspite, golOspite): gestisce il punteggio delle due squadre in base all'esito 15 | * getClassifica(): ritorna la classifica attuale, ordinata per punteggio 16 | * getMigliorAttacco(): ritorna la squadra che ha segnato più gol 17 | * getPeggiorDifesa(): ritorna la squadra che ha concesso più gol -------------------------------------------------------------------------------- /modulo5/SerieAChart/Squadra.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class Squadra { 4 | // Attributi 5 | 6 | private static int count = 1; 7 | private final int id; 8 | private String nome; 9 | private Giocatore[] rosaGiocatori; 10 | private int punteggio; 11 | private int golFatti; 12 | private int golSubiti; 13 | 14 | // Costruttore 15 | 16 | public Squadra(String nome, Giocatore[] rosaGiocatori) { 17 | this.id = count++; 18 | this.nome = nome; 19 | this.rosaGiocatori = rosaGiocatori; 20 | this.punteggio = 0; 21 | this.golFatti = 0; 22 | this.golSubiti = 0; 23 | } 24 | 25 | // Getter e Setter 26 | 27 | public int getId() { 28 | return id; 29 | } 30 | 31 | public String getNome() { 32 | return nome; 33 | } 34 | 35 | public void setNome(String nome) { 36 | this.nome = nome; 37 | } 38 | 39 | public Giocatore[] getRosaGiocatori() { 40 | return rosaGiocatori; 41 | } 42 | 43 | public void setRosaGiocatori(Giocatore[] rosaGiocatori) { 44 | this.rosaGiocatori = rosaGiocatori; 45 | } 46 | 47 | public int getPunteggio() { 48 | return punteggio; 49 | } 50 | 51 | public void setPunteggio(int punteggio) { 52 | this.punteggio = punteggio; 53 | } 54 | 55 | public int getGolFatti() { 56 | return golFatti; 57 | } 58 | 59 | public void setGolFatti(int golFatti) { 60 | this.golFatti = golFatti; 61 | } 62 | 63 | public int getGolSubiti() { 64 | return golSubiti; 65 | } 66 | 67 | public void setGolSubiti(int golSubiti) { 68 | this.golSubiti = golSubiti; 69 | } 70 | 71 | // Metodi 72 | 73 | @Override 74 | public String toString() { 75 | return "Squadra {" + 76 | " \nid=" + id + 77 | ",\n nome='" + nome + '\'' + 78 | ",\n rosaGiocatori=" + Arrays.toString(rosaGiocatori) + 79 | ",\n punteggio=" + punteggio + 80 | ",\n golFatti=" + golFatti + 81 | ",\n golSubiti=" + golSubiti + 82 | "\n}"; 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/Caffe.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Caffe extends Prodotti { 4 | 5 | public Caffe(String codice, double prezzo) { 6 | super(codice, prezzo); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/Cappuccino.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Cappuccino extends Prodotti { 4 | public Cappuccino(String codice, double prezzo) { 5 | super(codice, prezzo); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/DistributoreDiBevande.java: -------------------------------------------------------------------------------- 1 | public class DistributoreDiBevande { 2 | 3 | private double importoAttuale; 4 | private Prodotto[] prodotti; 5 | 6 | public void caricaProdotto(Prodotto prodotto){} 7 | 8 | public void rimuoviProdotto(int indice){} 9 | 10 | public void inserisciImporto(double importo){} 11 | 12 | public Prodotto scegliProdotto(String codice){ 13 | return null; 14 | } 15 | 16 | public double saldoAttuale(){ 17 | return this.importoAttuale; 18 | } 19 | 20 | public double getResto(){ 21 | return 0.00; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/DistributoreProdotti.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class DistributoreProdotti { 4 | 5 | private double importoAttuale; 6 | private Prodotti[] prodotti; 7 | 8 | public DistributoreProdotti(int capienza) { 9 | this.prodotti = new Prodotti[capienza]; 10 | this.importoAttuale = 0; 11 | } 12 | 13 | public void caricaProdotto(Prodotti prodotto) { 14 | for(int i = 0; i < this.prodotti.length; i++) { 15 | if(this.prodotti[i] == null) { 16 | prodotti[i] = prodotto; 17 | break; 18 | } 19 | } 20 | } 21 | public void rimuoviProdotto(int indice) { 22 | if(indice <= prodotti.length -1) { 23 | prodotti[indice] = null; 24 | } 25 | } 26 | public void inserisciImporto(double importo) { 27 | this.importoAttuale += importo; 28 | } 29 | public Prodotti scegliProdotto(String codice) { 30 | for(int i = 0; i < this.prodotti.length; i++) { 31 | if(prodotti[i] != null && prodotti[i].getCodice().equals(codice) && prodotti[i].getPrezzo() <= importoAttuale) { 32 | Prodotti tmp = prodotti[i]; 33 | importoAttuale -= prodotti[i].getPrezzo(); 34 | rimuoviProdotto(i); 35 | return tmp; 36 | } 37 | } 38 | return null; 39 | } 40 | public double saldo() { 41 | return importoAttuale; 42 | } 43 | public double getResto() { 44 | double app = importoAttuale; 45 | importoAttuale = 0; 46 | return app; 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/Main.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Caffe caffe = new Caffe("caffe", 0.5); 7 | Cappuccino cappuccino = new Cappuccino("cappuccino", 1); 8 | DistributoreProdotti distributoreDiBevande = new DistributoreProdotti(10); 9 | distributoreDiBevande.caricaProdotto(caffe); 10 | distributoreDiBevande.caricaProdotto(caffe); 11 | distributoreDiBevande.caricaProdotto(cappuccino); 12 | distributoreDiBevande.caricaProdotto(caffe); 13 | distributoreDiBevande.caricaProdotto(caffe); 14 | distributoreDiBevande.caricaProdotto(cappuccino); 15 | distributoreDiBevande.caricaProdotto(caffe); 16 | System.out.println(distributoreDiBevande.saldo() == 0); 17 | System.out.println(distributoreDiBevande.getResto() == 0); 18 | distributoreDiBevande.inserisciImporto(0.4); 19 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 20 | distributoreDiBevande.inserisciImporto(0.2); 21 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 22 | System.out.println(distributoreDiBevande.getResto() - 0.10 < 1E-6); 23 | System.out.println(distributoreDiBevande.saldo() == 0); 24 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 25 | distributoreDiBevande.inserisciImporto(2.0); 26 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 27 | System.out.println(distributoreDiBevande.scegliProdotto("cappuccino") != null); 28 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 29 | System.out.println(distributoreDiBevande.saldo() == 0); 30 | System.out.println(distributoreDiBevande.getResto() - 0.10 < 1E-6); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/Prodotti.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Prodotti { 4 | 5 | private String codice; 6 | private double prezzo; 7 | 8 | public Prodotti(String codice, double prezzo) { 9 | this.codice = codice; 10 | this.prezzo = prezzo; 11 | } 12 | public String getCodice() { 13 | return codice; 14 | } 15 | public double getPrezzo() { 16 | return prezzo; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/Prodotto.java: -------------------------------------------------------------------------------- 1 | public class Prodotto { 2 | private String codice; 3 | private double prezzo; 4 | 5 | public Prodotto(String codice, double prezzo){ 6 | this.codice = codice; 7 | this.prezzo = prezzo; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/distributore_bevande/Caffe.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Caffe extends Prodotti { 4 | 5 | public Caffe(String codice, double prezzo) { 6 | super(codice, prezzo); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/distributore_bevande/Cappuccino.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Cappuccino extends Prodotti { 4 | public Cappuccino(String codice, double prezzo) { 5 | super(codice, prezzo); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/distributore_bevande/DistributoreProdotti.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class DistributoreProdotti { 4 | 5 | private double importoAttuale; 6 | private Prodotti[] prodotti; 7 | 8 | public DistributoreProdotti(int capienza) { 9 | this.prodotti = new Prodotti[capienza]; 10 | this.importoAttuale = 0; 11 | } 12 | 13 | public void caricaProdotto(Prodotti prodotto) { 14 | for(int i = 0; i < this.prodotti.length; i++) { 15 | if(this.prodotti[i] == null) { 16 | prodotti[i] = prodotto; 17 | break; 18 | } 19 | } 20 | } 21 | public void rimuoviProdotto(int indice) { 22 | if(indice <= prodotti.length -1) { 23 | prodotti[indice] = null; 24 | } 25 | } 26 | public void inserisciImporto(double importo) { 27 | this.importoAttuale += importo; 28 | } 29 | public Prodotti scegliProdotto(String codice) { 30 | for(int i = 0; i < this.prodotti.length; i++) { 31 | if(prodotti[i] != null && prodotti[i].getCodice().equals(codice) && prodotti[i].getPrezzo() <= importoAttuale) { 32 | Prodotti tmp = prodotti[i]; 33 | importoAttuale -= prodotti[i].getPrezzo(); 34 | rimuoviProdotto(i); 35 | return tmp; 36 | } 37 | } 38 | return null; 39 | } 40 | public double saldo() { 41 | return importoAttuale; 42 | } 43 | public double getResto() { 44 | double app = importoAttuale; 45 | importoAttuale = 0; 46 | return app; 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/distributore_bevande/Main.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Caffe caffe = new Caffe("caffe", 0.5); 7 | Cappuccino cappuccino = new Cappuccino("cappuccino", 1); 8 | DistributoreProdotti distributoreDiBevande = new DistributoreProdotti(10); 9 | distributoreDiBevande.caricaProdotto(caffe); 10 | distributoreDiBevande.caricaProdotto(caffe); 11 | distributoreDiBevande.caricaProdotto(cappuccino); 12 | distributoreDiBevande.caricaProdotto(caffe); 13 | distributoreDiBevande.caricaProdotto(caffe); 14 | distributoreDiBevande.caricaProdotto(cappuccino); 15 | distributoreDiBevande.caricaProdotto(caffe); 16 | System.out.println(distributoreDiBevande.saldo() == 0); 17 | System.out.println(distributoreDiBevande.getResto() == 0); 18 | distributoreDiBevande.inserisciImporto(0.4); 19 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 20 | distributoreDiBevande.inserisciImporto(0.2); 21 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 22 | System.out.println(distributoreDiBevande.getResto() - 0.10 < 1E-6); 23 | System.out.println(distributoreDiBevande.saldo() == 0); 24 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 25 | distributoreDiBevande.inserisciImporto(2.0); 26 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 27 | System.out.println(distributoreDiBevande.scegliProdotto("cappuccino") != null); 28 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 29 | System.out.println(distributoreDiBevande.saldo() == 0); 30 | System.out.println(distributoreDiBevande.getResto() - 0.10 < 1E-6); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/distributore_bevande/Prodotti.java: -------------------------------------------------------------------------------- 1 | package distributore_bevande; 2 | 3 | public class Prodotti { 4 | 5 | private String codice; 6 | private double prezzo; 7 | 8 | public Prodotti(String codice, double prezzo) { 9 | this.codice = codice; 10 | this.prezzo = prezzo; 11 | } 12 | public String getCodice() { 13 | return codice; 14 | } 15 | public double getPrezzo() { 16 | return prezzo; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /modulo5/distributore bevande/readme.md: -------------------------------------------------------------------------------- 1 | Distributore di Bevande 🛵 2 | 3 | Scrivere un programma in grado di modellare la gestione di un distributore di bevande. Il distributore gestirà una lista di 2 tipi diversi di prodotti: Caffè e Cappuccino. 4 | Progettare la classe DistributoreDiBevande costruito con un intero n che determina il numero di prodotti nel distributore 5 | Ogni tipo di prodotto può avere un codice univoco e un prezzo uguali nel tempo (ossia per uno stesso tipo di prodotto). 6 | 7 | La classe prevede i seguenti metodi: 8 | 9 | - caricaProdotto: dato un Prodotto p in input, lo carica nel distributore 10 | - inserisciImporto: permette di inserire un importo nella macchinetta 11 | - scegliProdotto: dato in ingresso un codice di prodotto, restituisca il 12 | prodotto associato a quel codice (se l’importo inserito lo consente) e 13 | decrementi il saldo disponibile nel distributore 14 | - saldoAttuale: restituisce il saldo attuale del distributore 15 | - getResto: restituisce il resto dovuto e azzeri il saldo 16 | 17 | 18 | Potete usare questo codice come test 19 | 20 | ``` 21 | Caffe caffe = new Caffe("caffe", 0.5); 22 | Cappuccino cappuccino = new Cappuccino("cappuccino", 1); 23 | DistributoreDiBevande distributoreDiBevande = new DistributoreDiBevande(10); 24 | distributoreDiBevande.caricaProdotto(caffe); 25 | distributoreDiBevande.caricaProdotto(caffe); 26 | distributoreDiBevande.caricaProdotto(cappuccino); 27 | distributoreDiBevande.caricaProdotto(caffe); 28 | distributoreDiBevande.caricaProdotto(caffe); 29 | distributoreDiBevande.caricaProdotto(cappuccino); 30 | distributoreDiBevande.caricaProdotto(caffe); 31 | System.out.println(distributoreDiBevande.saldoAttuale() == 0); 32 | System.out.println(distributoreDiBevande.getResto() == 0); 33 | distributoreDiBevande.inserisciImporto(0.4); 34 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 35 | distributoreDiBevande.inserisciImporto(0.2); 36 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 37 | System.out.println(distributoreDiBevande.getResto()-0.10 < 1E-6); 38 | System.out.println(distributoreDiBevande.saldoAttuale() == 0); 39 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") == null); 40 | distributoreDiBevande.inserisciImporto(2.0); 41 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 42 | System.out.println(distributoreDiBevande.scegliProdotto("cappuccino") != null); 43 | System.out.println(distributoreDiBevande.scegliProdotto("caffe") != null); 44 | System.out.println(distributoreDiBevande.saldoAttuale() == 0); 45 | System.out.println(distributoreDiBevande.getResto()-0.10 < 1E-6); 46 | ``` 47 | 48 | Suggerimento: usate l’ereditarietà 49 | 50 | -------------------------------------------------------------------------------- /modulo5/gestore veicoli/Autocarro.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/gestore veicoli/Autocarro.java -------------------------------------------------------------------------------- /modulo5/gestore veicoli/Automobile.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/gestore veicoli/Automobile.java -------------------------------------------------------------------------------- /modulo5/gestore veicoli/GestioneVeicoli.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo5/gestore veicoli/GestioneVeicoli.java -------------------------------------------------------------------------------- /modulo5/gestore veicoli/Veicolo.java: -------------------------------------------------------------------------------- 1 | package gestione_veicoli; 2 | 3 | public abstract class Veicolo { 4 | private String targa; 5 | private int numeroPosti; 6 | 7 | public Veicolo(String targa, int numeroPosti) { 8 | this.targa = targa; 9 | this.numeroPosti = numeroPosti; 10 | } 11 | 12 | public String getTarga() { 13 | return targa; 14 | } 15 | 16 | public void setTarga(String targa) { 17 | this.targa = targa; 18 | } 19 | 20 | public int getNumeroPosti() { 21 | return numeroPosti; 22 | } 23 | 24 | public void setNumeroPosti(int numeroPosti) { 25 | this.numeroPosti = numeroPosti; 26 | } 27 | 28 | 29 | } 30 | -------------------------------------------------------------------------------- /modulo5/gestore veicoli/readme.md: -------------------------------------------------------------------------------- 1 | # Gestore Veicoli 🛴 2 | 3 | Scrivere un programma in grado di modellare la gestione di diversi tipi di veicoli: automobili e 4 | autocarri. In particolare, create le classi Autocarro e Automobile entrambe con le seguenti 5 | aratteristiche: 6 | Ogni veicolo è caratterizzato da: 7 | - Targa 8 | - Numero di posti 9 | 10 | Gli autocarri hanno una proprietà aggiuntiva: la capacità massima di carico (espressa in quintali). Le automobili, invece, il numero di porte. 11 | Il metodo toString degli oggetti Automobile deve ritornare il numero di targa e il numero di porte, separati dal carattere «:». 12 | Il metodo toString degli oggetti Autocarro, invece, deve ritornare il numero di targa e la massima capacità in quintali, separati dal carattere «:». 13 | 14 | Deve essere possibile eseguire il seguente codice: 15 | 16 | ``` 17 | Automobile automobile = new AutoMobile("cf123rm", 4, 4); 18 | gestione_veicoli.AutoCarro autoCarro = new AutoCarro("ca133sm", 4, 2); 19 | ``` 20 | 21 | Suggerimento: usate l’ereditarietà 22 | -------------------------------------------------------------------------------- /modulo6/iterabile/Iterabile.java: -------------------------------------------------------------------------------- 1 | public interface Iterabile { 2 | Object next(); 3 | boolean hasNext(); 4 | void reset(); 5 | } -------------------------------------------------------------------------------- /modulo6/iterabile/IterabileAstract.java: -------------------------------------------------------------------------------- 1 | public abstract class IterabileAstract implements Iterabile { 2 | // Attributi 3 | 4 | protected int index; 5 | 6 | // Costruttore 7 | 8 | public IterabileAstract() { 9 | this.index = 0; 10 | } 11 | 12 | // Metodi 13 | 14 | public void reset() { 15 | this.index = 0; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /modulo6/iterabile/IterabileMain.java: -------------------------------------------------------------------------------- 1 | public class IterabileMain { 2 | public static void main(String[] args) { 3 | // Test ListaDiInteri 4 | int[] listaInteri = new int[]{3, 4, 6, 9, 10, 11}; 5 | ListaDiInteri iterabileListaDiInteri = new ListaDiInteri(listaInteri); 6 | 7 | for (int i = 0; i < 3; i++) { 8 | System.out.println("Prossimo intero: " + iterabileListaDiInteri.next()); 9 | if (iterabileListaDiInteri.hasNext()) { 10 | System.out.println("Presente un intero successivo, proseguo"); 11 | } else { 12 | break; 13 | } 14 | } 15 | 16 | iterabileListaDiInteri.reset(); 17 | while (iterabileListaDiInteri.hasNext()) { 18 | System.out.println("Corrente intero: " + iterabileListaDiInteri.next()); 19 | if (iterabileListaDiInteri.hasNext()) { 20 | System.out.println("Presente un intero successivo, proseguo"); 21 | } else { 22 | break; 23 | } 24 | } 25 | 26 | // Test MiaStringa 27 | String miaStringa = "test"; 28 | MiaStringa iterabileStringa = new MiaStringa(miaStringa); 29 | 30 | for (int i = 0; i < 2; i++) { 31 | System.out.println("Prossimo carattere: " + iterabileStringa.next()); 32 | if (iterabileStringa.hasNext()) { 33 | System.out.println("Presente carattere successivo, proseguo"); 34 | } else { 35 | break; 36 | } 37 | } 38 | 39 | iterabileStringa.reset(); 40 | while (iterabileStringa.hasNext()) { 41 | System.out.println("Prossimo carattere: " + iterabileStringa.next()); 42 | if (iterabileStringa.hasNext()) { 43 | System.out.println("Presente carattere successivo, proseguo"); 44 | } else { 45 | break; 46 | } 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /modulo6/iterabile/ListaDiInteri.java: -------------------------------------------------------------------------------- 1 | public class ListaDiInteri extends IterabileAstract { 2 | // Attributi 3 | 4 | private int[] listaDiInteri; 5 | 6 | // Costruttore 7 | 8 | public ListaDiInteri(int[] listaDiInteri) { 9 | this.listaDiInteri = listaDiInteri; 10 | } 11 | 12 | // Getter e Setter 13 | 14 | public int[] getListaDiInteri() { 15 | return listaDiInteri; 16 | } 17 | 18 | public void setListaDiInteri(int[] listaDiInteri) { 19 | this.listaDiInteri = listaDiInteri; 20 | } 21 | 22 | // Metodi 23 | @Override 24 | public Object next() { 25 | if (this.hasNext()) { 26 | return this.listaDiInteri[this.index++]; 27 | } else { 28 | System.out.println("Lista terminata"); 29 | return null; 30 | } 31 | } 32 | 33 | @Override 34 | public boolean hasNext() { 35 | return this.index < this.listaDiInteri.length; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /modulo6/iterabile/MiaStringa.java: -------------------------------------------------------------------------------- 1 | public class MiaStringa extends IterabileAstract { 2 | // Attributi 3 | 4 | private String myString; 5 | 6 | // Costruttore 7 | 8 | public MiaStringa(String myString) { 9 | this.myString = myString; 10 | } 11 | 12 | // Getter e Setter 13 | 14 | public String getMyString() { 15 | return myString; 16 | } 17 | 18 | public void setMyString(String myString) { 19 | this.myString = myString; 20 | } 21 | 22 | // Metodi 23 | 24 | @Override 25 | public Object next() { 26 | if (this.hasNext()) { 27 | return this.myString.charAt(this.index++); 28 | } else { 29 | System.out.println("Stringa terminata"); 30 | return null; 31 | } 32 | } 33 | 34 | @Override 35 | public boolean hasNext() { 36 | return this.index < this.myString.length(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /modulo6/iterabile/readme.md: -------------------------------------------------------------------------------- 1 | ## Iterabile 🛴 2 | 3 | Progettare un'interfaccia Iterabile che permette di fare le seguenti operazioni 4 | * Object next() che permette di ottenere il prossimo elemento 5 | * boolean hasNext() che indica se è presente un prossimo elemento nella sequenza 6 | * void reset() che fa resetta l'iterazione 7 | 8 | Progettare due classi ListaDiInteri, costruita con un array di interi, e MiaStringa, costruita con una stringa, che usano l'interfaccia Iterabile e ne implementano i metodi 9 | (Considerare una stringa come una sequenza di char) 10 | 11 | Usare il codice di test per verificare le funzioni -------------------------------------------------------------------------------- /modulo6/lista/AbstractLista.java: -------------------------------------------------------------------------------- 1 | package lista; 2 | 3 | import java.util.Arrays; 4 | 5 | public abstract class AbstractLista implements Lista{ 6 | 7 | protected Object[] lista; 8 | 9 | public AbstractLista() { 10 | lista = new Object[0]; 11 | } 12 | public int size() { 13 | return lista.length; 14 | } 15 | public boolean remove(int i) { 16 | if(i >= 0 && i < lista.length -1) { 17 | for(int j = i; j < lista.length; j++) { 18 | if(j == lista.length-1) { 19 | lista[j] = null; 20 | } 21 | else 22 | lista[j] = lista[j+1]; 23 | } 24 | lista = Arrays.copyOf(lista, lista.length-1); 25 | return true; 26 | } 27 | else { 28 | return false; 29 | } 30 | } 31 | 32 | public Object get(int i) { 33 | if(i >= 0 && i < lista.length) { 34 | return lista[i]; 35 | } 36 | return null; 37 | } 38 | 39 | public void clear() { 40 | lista = new Object[0]; 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /modulo6/lista/Lista.java: -------------------------------------------------------------------------------- 1 | package lista; 2 | 3 | public interface Lista { 4 | 5 | public Object get(int i); 6 | public boolean contains(Object o); 7 | public int size(); 8 | public void add(Object o); 9 | public boolean remove(int i); 10 | public void clear(); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /modulo6/lista/ListaDiInteri.java: -------------------------------------------------------------------------------- 1 | package lista; 2 | 3 | import java.util.Arrays; 4 | 5 | public class ListaDiInteri extends AbstractLista{ 6 | 7 | 8 | public ListaDiInteri() { 9 | super(); 10 | } 11 | public boolean contains(Object o) { 12 | if( o instanceof Integer) { 13 | for(int i = 0; i < this.lista.length; i++) { 14 | if(this.lista[i] == o) { 15 | return true; 16 | } 17 | } 18 | } 19 | return false; 20 | } 21 | public void add(Object o) { 22 | if( o instanceof Integer) { 23 | lista = Arrays.copyOf(lista, lista.length+1); 24 | lista[lista.length-1] = o; 25 | } 26 | } 27 | 28 | 29 | } 30 | -------------------------------------------------------------------------------- /modulo6/lista/Main.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Backend-Developer-School-Tree/Corso-Java-Backend-2022-02/cacf06c69d2ae1f18a763e99286e449e0aa15a07/modulo6/lista/Main.java -------------------------------------------------------------------------------- /modulo6/lista/MiaStringa.java: -------------------------------------------------------------------------------- 1 | package lista; 2 | 3 | import java.util.Arrays; 4 | 5 | public class MiaStringa extends AbstractLista{ 6 | 7 | public MiaStringa() { 8 | super(); 9 | } 10 | public boolean contains(Object o) { 11 | if( o instanceof Character) { 12 | for(int i = 0; i < this.lista.length; i++) { 13 | if(this.lista[i] == o) { 14 | return true; 15 | } 16 | } 17 | } 18 | return false; 19 | } 20 | public void add(Object o) { 21 | if( o instanceof Character) { 22 | lista = Arrays.copyOf(lista, lista.length+1); 23 | lista[lista.length-1] = o; 24 | } 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /modulo6/lista/readme.md: -------------------------------------------------------------------------------- 1 | # Lista 🛴 2 | 3 | Progettare un'interfaccia Lista che permette di fare le seguenti operazioni 4 | * get(int i) che restituisce l'elemento alla posizione i della sequenza 5 | * contains(Object o) che restituisce true se l'elemento o è presente nella sequenza 6 | * size() che restituisce quanti elementi sono presenti all'interno della sequenza 7 | * add(Object o) che aggiunge un elemento alla sequenza 8 | * remove(int i) che rimuove l'elemento alla posizione i della sequenza, torna true se l'elemento è stato rimosso, false se non l'ha trovato 9 | * clear() rimuove tutti gli elementi dalla sequenza 10 | 11 | Aggiungere l'interfaccia Lista alle classi ListaDiInteri e MiaStringa, ed implementarne i metodi 12 | 13 | Usare il codice di test per verificare le funzioni -------------------------------------------------------------------------------- /modulo7/dizionario/Dictionary.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | import java.util.TreeMap; 3 | import java.util.TreeSet; 4 | 5 | public class Dictionary { 6 | private TreeMap>> dictionary; 7 | 8 | // Costruttore 9 | 10 | public Dictionary() { 11 | this.dictionary = new TreeMap<>(); 12 | for (char c = 'A'; c <= 'Z'; c++) { 13 | this.dictionary.put(c, new TreeMap<>()); 14 | } 15 | } 16 | 17 | // Metodi 18 | 19 | public void insertWord(String word, HashSet meanings) { 20 | if (meanings != null && meanings.size() > 0) { 21 | Character firstWordLetter = word.charAt(0); 22 | 23 | // Considero di non aggiungere una parola già esistente 24 | TreeMap> wordDetail = this.dictionary.get(firstWordLetter); 25 | wordDetail.put(word, meanings); 26 | } else { 27 | System.out.println("Fornire un insieme di significati valido"); 28 | } 29 | } 30 | 31 | public void insertMeaningByWord(String word, String meaning) { 32 | Character firstWordLetter = word.charAt(0); 33 | 34 | HashSet wordMeanings = this.dictionary.get(firstWordLetter).get(word); 35 | wordMeanings.add(meaning); 36 | } 37 | 38 | public void print() { 39 | String output = ""; 40 | 41 | for (Character character : this.dictionary.keySet()) { 42 | TreeSet words = new TreeSet<>(); 43 | for (String word : this.dictionary.get(character).keySet()) { 44 | String meanings = String.join("; ", this.dictionary.get(character).get(word)); 45 | words.add(word + ": (" + meanings + ")"); 46 | } 47 | output += character + ": [" + String.join(", ", words) + "]\n"; 48 | } 49 | 50 | System.out.println(output); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /modulo7/dizionario/DictionaryMain.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | 3 | public class DictionaryMain { 4 | public static void main(String[] args) { 5 | Dictionary dictionary = new Dictionary(); 6 | 7 | HashSet calcioMeanings = new HashSet<>(); 8 | calcioMeanings.add("Sport di squadra"); 9 | calcioMeanings.add("Elemento chimico"); 10 | calcioMeanings.add("Comune di 5353 abitanti"); 11 | calcioMeanings.add("Impugnatura del fucile"); 12 | dictionary.insertWord("Calcio", calcioMeanings); 13 | dictionary.insertMeaningByWord("Calcio", "Colpo sferrato con il piede"); 14 | 15 | HashSet retinaMeanings = new HashSet<>(); 16 | retinaMeanings.add("Membrana più interna del bulbo oculare"); 17 | retinaMeanings.add("Rete, spesso elastica, indossata sopra i capelli lunghi per tenerli in posizione"); 18 | dictionary.insertWord("Retina", retinaMeanings); 19 | 20 | HashSet circuitoMeanings = new HashSet<>(); 21 | circuitoMeanings.add("Catena di elementi attraversati da corrente elettrica"); 22 | circuitoMeanings.add("Luogo in cui si svolgono corse"); 23 | dictionary.insertWord("Circuito", circuitoMeanings); 24 | 25 | dictionary.print(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /modulo7/dizionario/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Dizionario 🏍 2 | 3 | Scrivere un programma per gestire un dizionario. In particolare, ad ogni lettera 4 | dell'alfabeto è associata una lista di parole che iniziano con quella lettera e ad 5 | ogni parola è, a sua volta, associata una lista di significati diversi della parola. 6 | 7 | Esempio: 8 | c -> calcio -> sport 9 | c -> calcio -> elemento chimico 10 | 11 | Devono essere possibili le seguenti operazioni: 12 | - inserisci parola (con almeno un significato associato) 13 | - aggiungi significato per una certa parola 14 | - stampa dizionario, che ritorna una stringa contenente ogni parola e significato 15 | (in ordine lessicografico ascendente in base alla lettera) nella forma: 16 | 17 | ``` 18 | lettera1:[parola1: (significato1;significato2;...;), parola2: (significato1;...;...;)] 19 | lettera2:[parola1: significato1;significato2;...;), parola2: (significato1;...;...;)] 20 | ... 21 | letteraN:[parola1: significato1;significato2;...;),parola2: (significato1;...;...;)] 22 | ``` -------------------------------------------------------------------------------- /modulo7/dragonball/Attacco.java: -------------------------------------------------------------------------------- 1 | public class Attacco { 2 | // Attributi 3 | 4 | private final String nome; 5 | private final int danno; 6 | private final double probabilita; 7 | 8 | // Costruttore 9 | 10 | public Attacco(String nome, int danno, double probabilita) { 11 | this.nome = nome; 12 | this.danno = danno; 13 | this.probabilita = probabilita; 14 | } 15 | 16 | // Getter 17 | 18 | 19 | public String getNome() { 20 | return nome; 21 | } 22 | 23 | public int getDanno() { 24 | return danno; 25 | } 26 | 27 | public double getProbabilita() { 28 | return probabilita; 29 | } 30 | 31 | // Metodi 32 | 33 | @Override 34 | public String toString() { 35 | return "Attacco{" + 36 | "nome='" + nome + '\'' + 37 | ", danno=" + danno + 38 | ", probabilita=" + probabilita + 39 | '}'; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /modulo7/dragonball/Combattimento.java: -------------------------------------------------------------------------------- 1 | import java.io.IOException; 2 | import java.nio.file.Files; 3 | import java.nio.file.Paths; 4 | import java.nio.file.StandardOpenOption; 5 | 6 | public class Combattimento { 7 | // Attributi 8 | 9 | private final Personaggio[] personaggi; 10 | 11 | // Costruttore 12 | 13 | public Combattimento(Personaggio personaggio1, Personaggio personaggio2) { 14 | this.personaggi = new Personaggio[]{ personaggio1, personaggio2 }; 15 | } 16 | 17 | // Metodi 18 | 19 | public void combatti() { 20 | System.out.println("COMBATTIMENTO: " + this.personaggi[0].getNome() + " VS. " + this.personaggi[1].getNome()); 21 | 22 | // Salvataggio PV per ripristino al termine del combattimento 23 | int puntiVitaStartPersonaggio1 = this.personaggi[0].getPuntiVita(); 24 | int puntiVitaStartPersonaggio2 = this.personaggi[1].getPuntiVita(); 25 | 26 | // Estrazione random attaccante 27 | int indiceAttaccante = Utility.getRandomIntByMax(1); 28 | Personaggio attaccante = this.personaggi[indiceAttaccante]; 29 | Personaggio difensore = this.personaggi[(indiceAttaccante == 0) ? 1 : 0]; 30 | 31 | // Continuo a eseguire attacchi a turno finché uno dei due PG non ha PV = 0 32 | while (attaccante.getPuntiVita() > 0 && difensore.getPuntiVita() > 0) { 33 | System.out.println("Attaccante: " + attaccante.getNome() + "(PV: " + attaccante.getPuntiVita() + ")"); 34 | System.out.println("Difensore: " + difensore.getNome() + "(PV: " + difensore.getPuntiVita() + ")"); 35 | 36 | // Estrazione random attacco 37 | Attacco attaccoRandom = this.getAttaccoRandom(attaccante); 38 | System.out.println("Tentativo di Attacco " + attaccoRandom.getNome() + " in corso..."); 39 | 40 | // Calcolo probabilità che l'attacco vada a segno 41 | double probabilitaAttaccoASegno = this.getProbabilitaAttaccoASegno(attaccoRandom, difensore); 42 | 43 | if (Math.random() < probabilitaAttaccoASegno) { 44 | // Applicazione danno al difensore 45 | int dannoInflitto = this.getDannoInflitto(attaccoRandom, difensore); 46 | difensore.subisciDanno(dannoInflitto); 47 | System.out.println("Attacco andato a segno! Danni subiti: " + dannoInflitto); 48 | } else { 49 | System.out.println("Attacco schivato!"); 50 | } 51 | 52 | indiceAttaccante = (indiceAttaccante == 0) ? 1 : 0; 53 | attaccante = this.personaggi[indiceAttaccante]; 54 | difensore = this.personaggi[(indiceAttaccante == 0) ? 1 : 0]; 55 | } 56 | 57 | String vincitore = (attaccante.getPuntiVita() == 0) ? difensore.getNome() : attaccante.getNome(); 58 | System.out.println("Combattimento terminato! Vincitore => " + vincitore); 59 | 60 | // Ripristino PV personaggi 61 | this.personaggi[0].setPuntiVita(puntiVitaStartPersonaggio1); 62 | this.personaggi[1].setPuntiVita(puntiVitaStartPersonaggio2); 63 | 64 | try { 65 | Files.writeString( 66 | Paths.get("log_combattimenti.txt"), 67 | "Combattimento " + attaccante.getNome() + " vs. " + difensore.getNome() + " => Vincitore: " + vincitore + "\n", 68 | StandardOpenOption.CREATE, 69 | StandardOpenOption.APPEND 70 | ); 71 | } catch (IOException e) { 72 | e.printStackTrace(); 73 | } 74 | } 75 | 76 | public double getProbabilitaAttaccoASegno(Attacco attacco, Personaggio difensore) { 77 | return attacco.getProbabilita() * difensore.getCapacitaSchivata(); 78 | } 79 | 80 | public Attacco getAttaccoRandom(Personaggio personaggio) { 81 | return personaggio.getAttacchi().get(Utility.getRandomIntByMax(4)); 82 | } 83 | 84 | public int getDannoInflitto(Attacco attacco, Personaggio difensore) { 85 | return (int) Math.round(attacco.getDanno() * difensore.getResistenzaFisica()); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /modulo7/dragonball/DragonBallMain.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Arrays; 3 | 4 | public class DragonBallMain { 5 | public static void main(String[] args) { 6 | ArrayList attacchiGoku = new ArrayList<>(Arrays.asList( 7 | new Attacco("Kamehameha", 10, 0.6), 8 | new Attacco("Kaiohken", 20, 0.4), 9 | new Attacco("Genkidama", 50, 0.3), 10 | new Attacco("Ultra Instinct", 60, 0.7) 11 | )); 12 | Personaggio goku = new Personaggio("Goku", 100, attacchiGoku,0.7, 30, 13 | 0.5, 0.4, RazzaPersonaggio.Sayan); 14 | 15 | ArrayList attacchiVegeta = new ArrayList<>(Arrays.asList( 16 | new Attacco("Big Bang Attack", 30, 0.6), 17 | new Attacco("Final Flash", 35, 0.4), 18 | new Attacco("Final Impact", 40, 0.7), 19 | new Attacco("Galick Cannon", 20, 0.9) 20 | )); 21 | Personaggio vegeta = new Personaggio("Vegeta", 98, attacchiVegeta, 0.7, 29, 22 | 0.5, 0.4, RazzaPersonaggio.Sayan); 23 | 24 | ArrayList attacchiCrilin = new ArrayList<>(Arrays.asList( 25 | new Attacco("Kamehameha", 5, 0.4), 26 | new Attacco("Destructo Disk", 15, 0.6), 27 | new Attacco("Solar Flare", 3, 0.3), 28 | new Attacco("Split Energy Wave", 10, 0.5) 29 | )); 30 | Personaggio crilin = new Personaggio("Crilin", 50, attacchiCrilin, 0.6, 20, 31 | 0.3, 0.6, RazzaPersonaggio.Umano); 32 | 33 | Combattimento combattimentoGokuVsVegeta = new Combattimento(goku, vegeta); 34 | combattimentoGokuVsVegeta.combatti(); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /modulo7/dragonball/Personaggio.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | 3 | public class Personaggio { 4 | // Attributi 5 | 6 | private final String nome; 7 | private int puntiVita; 8 | private final ArrayList attacchi; 9 | private final int forzaFisica; 10 | private final double capacitaSchivata; 11 | private final double resistenzaFisica; 12 | private final RazzaPersonaggio razza; 13 | 14 | // Costruttore 15 | 16 | public Personaggio(String nome, int puntiVita, ArrayList attacchi, double probabilitaAttaccoBase, 17 | int forzaFisica, double capacitaSchivata, double resistenzaFisica, RazzaPersonaggio razza) { 18 | this.nome = nome; 19 | this.puntiVita = puntiVita; 20 | this.attacchi = attacchi; 21 | this.attacchi.add(new Attacco("Attacco Base", forzaFisica, probabilitaAttaccoBase)); 22 | this.forzaFisica = forzaFisica; 23 | this.capacitaSchivata = capacitaSchivata; 24 | this.resistenzaFisica = resistenzaFisica; 25 | this.razza = razza; 26 | } 27 | 28 | // Getter 29 | 30 | public String getNome() { 31 | return nome; 32 | } 33 | 34 | public int getPuntiVita() { 35 | return puntiVita; 36 | } 37 | 38 | public void setPuntiVita(int puntiVita) { 39 | this.puntiVita = puntiVita; 40 | } 41 | 42 | public ArrayList getAttacchi() { 43 | return attacchi; 44 | } 45 | 46 | public int getForzaFisica() { 47 | return forzaFisica; 48 | } 49 | 50 | public double getCapacitaSchivata() { 51 | return capacitaSchivata; 52 | } 53 | 54 | public double getResistenzaFisica() { 55 | return resistenzaFisica; 56 | } 57 | 58 | public RazzaPersonaggio getRazza() { 59 | return razza; 60 | } 61 | 62 | // Metodi 63 | 64 | public void subisciDanno(int dannoInflitto) { 65 | if (dannoInflitto <= this.puntiVita) { 66 | this.puntiVita -= dannoInflitto; 67 | } else { 68 | this.puntiVita = 0; 69 | } 70 | } 71 | 72 | @Override 73 | public String toString() { 74 | return "Personaggio{" + 75 | "nome='" + nome + '\'' + 76 | ", puntiVita=" + puntiVita + 77 | ", attacchi=" + attacchi + 78 | ", forzaFisica=" + forzaFisica + 79 | ", capacitaSchivata=" + capacitaSchivata + 80 | ", resistenzaFisica=" + resistenzaFisica + 81 | ", razza=" + razza + 82 | '}'; 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /modulo7/dragonball/RazzaPersonaggio.java: -------------------------------------------------------------------------------- 1 | public enum RazzaPersonaggio { 2 | Umano, 3 | Sayan, 4 | Namecciano, 5 | Cyborg, 6 | Demone, 7 | Alieno 8 | } 9 | -------------------------------------------------------------------------------- /modulo7/dragonball/Utility.java: -------------------------------------------------------------------------------- 1 | import java.util.Random; 2 | 3 | public class Utility { 4 | public static int getRandomIntByMax(int max) { 5 | return new Random().nextInt(max + 1); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /modulo7/dragonball/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Dragon Ball 🏍 2 | 3 | Vogliamo creare un videogioco basato sul famosissimo manga di Akira Toriyama, nel quale i vari 4 | personaggi possono combattere tra di loro in una sorta di Torneo Tenkaichi. 5 | Ogni personaggio ha un nome, dei punti vita, una lista di 4 possibili attacchi personalizzati e una 6 | forza fisica. Inoltre ogni personaggio ha un valore compreso tra 0 ed 1 che rappresenta la sua 7 | capacità di schivare attacchi e un valore compreso tra 0 ed 1 che rappresenta la sua resistenza fisica. 8 | Ogni attacco possibile ha un nome, un valore rappresentante la quantità di danno e un valore 9 | compreso tra 0 ed 1 che rappresenta la probabilità che l’attacco vada a segno. Notare che per 10 | calcolare la probabilità che un attacco A vada a segno su un personaggio P sarà data dal prodotto 11 | della probabilità che l’attacco vada a segno con la probabilità che l’attacco venga schivato. Quindi 12 | se per esempio il personaggio Goku utilizza il’attacco “Kaioken” che ha probabilità 0.9 di successo 13 | sul personaggio Freezer che ha probabilità 0.4 di schivare un attacco, la probabilità che l’attacco 14 | vada a segno è: 15 | 16 | 0.90*0.40 = 0.36 (in pratica il 36% delle volte va a segno). 17 | 18 | Nota: un diverso attacco può essere nel kit di più personaggi. Per esempio l’attacco “Kamehameha” 19 | è un attacco sia di Goku che di Gohan che del Maestro delle Tartarughe ecc. 20 | Nota 2: per gli attacchi si consiglia di utilizzare una interfaccia Attacco che poi ogni singolo attacco 21 | andrà ad implementare. 22 | 23 | Torniamo ai personaggi. Essi possono essere di diverso tipo: Umano, Sayan, Namecciano, Cyborg, 24 | Demone (per esempio Majin-bu) e Alieno (per esempio Freezer). Tutti i personaggi, a parte i 4 25 | attacchi personali, hanno un attacco fisico di base, e una probabilità che esso vada a segno che 26 | cambia a seconda del personaggio. Questo attacco fisico di base è a tutti gli effetti un attacco, e il 27 | suo danno è uguale alla forza fisica del personaggio. 28 | 29 | Creare infine una classe Combattimento che rappresenta un combattimento tra due personaggi. 30 | Questa classe avrà tra gli attributi i personaggi stessi e implementerà al proprio interno un metodo 31 | combatti() che simulerà un combattimento. Il metodo eseguirà i seguenti passaggi: 32 | - Sceglie a caso il combattente che inizierà per primo. 33 | - A turno, i combattenti scaglieranno un attacco preso random dalla lista dei suoi attacchi, calcolerà 34 | randomicamente se l’attacco andrà a segno o meno, e se l’attacco va a segno infligge danno 35 | all’avversario pari al danno che l’attacco infligge moltiplicato per la resistenza fisica dell’avversario 36 | (quindi più questo valore per un personaggio è vicino allo 0 più è resistente, più e vicino ad 1 meno 37 | è resistente). Ad esempio, se Goku riesce ad infliggere un attacco “Kamehameha” a Majin-Bu che 38 | infligge 50 danni, se Majin-Bu ha una resistenza pari a 0.3 il danno inflitto sarà 50*0.3 = 15. 39 | - Il combattimento termina quando uno dei due personaggi raggiungerà un numero di punti vita <= 0. 40 | In tal caso il combattimento finisce e i punti vita dei personaggi vengono ripristinati al massimo. 41 | 42 | Creare una classe Main dove vengano creati dei personaggi, degli attacchi, e vengano simulati dei 43 | combattimenti. Salvare i risultati dei combattimenti (sotto forma di stringhe descrittive) all’interno 44 | di un apposito file .txt. 45 | Nota: ovviamente se provate a fare più volte lo stesso combattimento potrete accorgervi di avere 46 | risultati diversi: è normale vista la randomicità coinvolta! 47 | -------------------------------------------------------------------------------- /modulo7/libreria/Autore.java: -------------------------------------------------------------------------------- 1 | import java.util.Objects; 2 | 3 | public class Autore { 4 | // Attributi 5 | 6 | private final String codice; 7 | private String nome; 8 | private String cognome; 9 | 10 | // Costruttore 11 | 12 | public Autore(String codice, String nome, String cognome) { 13 | this.codice = codice; 14 | this.nome = nome; 15 | this.cognome = cognome; 16 | } 17 | 18 | // Getter e Setter 19 | 20 | public String getCodice() { 21 | return codice; 22 | } 23 | 24 | public String getNome() { 25 | return nome; 26 | } 27 | 28 | public void setNome(String nome) { 29 | this.nome = nome; 30 | } 31 | 32 | public String getCognome() { 33 | return cognome; 34 | } 35 | 36 | public void setCognome(String cognome) { 37 | this.cognome = cognome; 38 | } 39 | 40 | // Metodi 41 | 42 | @Override 43 | public String toString() { 44 | return "Autore{" + 45 | "codice='" + codice + '\'' + 46 | ", nome='" + nome + '\'' + 47 | ", cognome='" + cognome + '\'' + 48 | '}'; 49 | } 50 | 51 | @Override 52 | public boolean equals(Object o) { 53 | if (this == o) return true; 54 | if (!(o instanceof Autore)) return false; 55 | Autore autore = (Autore) o; 56 | return getCodice().equals(autore.getCodice()); 57 | } 58 | 59 | @Override 60 | public int hashCode() { 61 | return Objects.hash(getCodice(), getNome(), getCognome()); 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /modulo7/libreria/Biblioteca.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Comparator; 3 | 4 | public class Biblioteca { 5 | // Attributi 6 | 7 | private ArrayList libri; 8 | 9 | // Costruttore 10 | 11 | public Biblioteca() { 12 | this.libri = new ArrayList<>(); 13 | } 14 | 15 | // Getter 16 | 17 | public ArrayList getLibri() { 18 | return libri; 19 | } 20 | 21 | // Metodi 22 | 23 | public void inserimentoLibro(Libro libro) { 24 | this.libri.add(libro); 25 | } 26 | 27 | public void rimozioneLibro(Libro libro) { 28 | this.libri.remove(libro); 29 | } 30 | 31 | public Libro getLibroByCodice(String codice) { 32 | Libro libroTrovato = null; 33 | 34 | for (Libro libro: this.libri) { 35 | if (libro.getCodice().equals(codice)) { 36 | libroTrovato = libro; 37 | break; 38 | } 39 | } 40 | 41 | return libroTrovato; 42 | } 43 | 44 | public ArrayList getLibriByTitolo(String titolo) { 45 | ArrayList libriTrovati = new ArrayList<>(); 46 | 47 | for (Libro libro: this.libri) { 48 | if (libro.getTitolo().equals(titolo)) { 49 | libriTrovati.add(libro); 50 | } 51 | } 52 | 53 | return libriTrovati; 54 | } 55 | 56 | public ArrayList getLibriByAutore(Autore autore) { 57 | ArrayList libriTrovati = new ArrayList<>(); 58 | 59 | for (Libro libro: this.libri) { 60 | if (libro.getAutore().equals(autore)) { 61 | libriTrovati.add(libro); 62 | } 63 | } 64 | 65 | return libriTrovati; 66 | } 67 | 68 | public void stampaLibriByAutore(Autore autore) { 69 | ArrayList libriTrovatiByAutore = this.getLibriByAutore(autore); 70 | 71 | libriTrovatiByAutore.sort(Comparator.comparing(Libro::getTitolo)); 72 | for (Libro libro : libriTrovatiByAutore) { 73 | System.out.println(libro.getTitolo() + ": " + libro.getSinossi()); 74 | } 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /modulo7/libreria/LibreriaMain.java: -------------------------------------------------------------------------------- 1 | public class LibreriaMain { 2 | public static void main(String[] args) { 3 | Autore autore1 = new Autore("ABC12345", "Paolo", "Bianchi"); 4 | Autore autore2 = new Autore("DEF67890", "Mario", "Rossi"); 5 | Autore autore3 = new Autore("GHI34567", "Giacomo", "Poretti"); 6 | Autore autore4 = new Autore("LMN56789", "Giovanni", "Storti"); 7 | 8 | Libro libro4 = new Libro("456456", "Nuovo Libro 4", "Parla di tante belle cose (4)", autore3); 9 | Libro libro1 = new Libro("123123", "Nuovo Libro 1", "Parla di tante belle cose (1)", autore3); 10 | Libro libro2 = new Libro("234234", "Nuovo Libro 2", "Parla di tante belle cose (2)", autore2); 11 | Libro libro3 = new Libro("345345", "Nuovo Libro 3", "Parla di tante belle cose (3)", autore1); 12 | Libro libro5 = new Libro("567567", "Nuovo Libro 5", "Parla di tante belle cose (5)", autore4); 13 | 14 | Biblioteca biblioteca = new Biblioteca(); 15 | biblioteca.inserimentoLibro(libro1); 16 | biblioteca.inserimentoLibro(libro2); 17 | biblioteca.inserimentoLibro(libro3); 18 | biblioteca.inserimentoLibro(libro4); 19 | biblioteca.inserimentoLibro(libro5); 20 | 21 | biblioteca.stampaLibriByAutore(autore3); 22 | System.out.println(biblioteca.getLibriByAutore(autore1)); 23 | System.out.println(biblioteca.getLibriByAutore(autore3)); 24 | 25 | System.out.println(biblioteca.getLibroByCodice("234234")); 26 | 27 | biblioteca.rimozioneLibro(libro1); 28 | biblioteca.stampaLibriByAutore(autore3); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /modulo7/libreria/Libro.java: -------------------------------------------------------------------------------- 1 | public class Libro { 2 | // Attributi 3 | 4 | private final String codice; 5 | private String titolo; 6 | private String sinossi; 7 | private Autore autore; 8 | 9 | // Costruttore 10 | 11 | public Libro(String codice, String titolo, String sinossi, Autore autore) { 12 | this.codice = codice; 13 | this.titolo = titolo; 14 | this.sinossi = sinossi; 15 | this.autore = autore; 16 | } 17 | 18 | // Getter e Setter 19 | 20 | public String getCodice() { 21 | return codice; 22 | } 23 | 24 | public String getTitolo() { 25 | return titolo; 26 | } 27 | 28 | public void setTitolo(String titolo) { 29 | this.titolo = titolo; 30 | } 31 | 32 | public String getSinossi() { 33 | return sinossi; 34 | } 35 | 36 | public void setSinossi(String sinossi) { 37 | this.sinossi = sinossi; 38 | } 39 | 40 | public Autore getAutore() { 41 | return autore; 42 | } 43 | 44 | public void setAutore(Autore autore) { 45 | this.autore = autore; 46 | } 47 | 48 | // Metodi 49 | 50 | @Override 51 | public String toString() { 52 | return "Libro{" + 53 | "codice='" + codice + '\'' + 54 | ", titolo='" + titolo + '\'' + 55 | ", sinossi='" + sinossi + '\'' + 56 | ", autore=" + autore + 57 | '}'; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /modulo7/libreria/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Libreria 🛵 2 | 3 | Scrivere un programma Java che permetta di creare e gestire 4 | una biblioteca. La classe Biblioteca dovrà permettere la gestione di un 5 | archivio di libri. 6 | Ogni Libro ha un codice (univoco), un titolo, una sinossi e un Autore. 7 | 8 | Ogni Autore possiede un codice (univoco), un nome, un cognome e una lista di Libri scritti 9 | 10 | Realizzare i metodi della classe Biblioteca che permettano le seguenti azioni: 11 | - inserimento di un Libro 12 | - cancellazione di un Libro 13 | - ricerca di un Libro a partire da codice, titolo o Autore 14 | - stampa di “titolo: sinossi” di tutti i titoli di un determinato Autore, ordinati 15 | in ordine lessicografico ascendente (in base al titolo) usando "\n" come carattere separatore 16 | 17 | Suggerimento: Effettuare l’override dei metodi equals, hashcode e toString dove necessario 18 | -------------------------------------------------------------------------------- /modulo7/pila/ElementoListaLinkata.java: -------------------------------------------------------------------------------- 1 | public class ElementoListaLinkata { 2 | // Attributi 3 | 4 | private final T data; 5 | private final ElementoListaLinkata nextElement; 6 | 7 | // Costruttore 8 | 9 | public ElementoListaLinkata(T data, ElementoListaLinkata nextElement) { 10 | this.data = data; 11 | this.nextElement = nextElement; 12 | } 13 | 14 | // Getter e Setter 15 | 16 | public T getData() { 17 | return data; 18 | } 19 | 20 | public ElementoListaLinkata getNextElement() { 21 | return nextElement; 22 | } 23 | 24 | // Metodi 25 | 26 | @Override 27 | public String toString() { 28 | return "ElementoListaLinkata{" + 29 | "data=" + data + 30 | ", nextElement=" + nextElement + 31 | '}'; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /modulo7/pila/ListaLinkata.java: -------------------------------------------------------------------------------- 1 | public abstract class ListaLinkata { 2 | // Attributi 3 | 4 | private ElementoListaLinkata head; 5 | 6 | // Costruttore 7 | 8 | public ListaLinkata() { 9 | this.head = null; 10 | } 11 | 12 | // Getter e Setter 13 | 14 | public ElementoListaLinkata getHead() { 15 | return head; 16 | } 17 | 18 | public void setHead(ElementoListaLinkata head) { 19 | this.head = head; 20 | } 21 | 22 | // Metodi 23 | 24 | public void addFirst(T data) { 25 | this.head = new ElementoListaLinkata<>(data, this.head); 26 | } 27 | 28 | public void removeFirst() { 29 | this.head = this.head.getNextElement(); 30 | } 31 | 32 | @Override 33 | public String toString() { 34 | String output = "{ "; 35 | 36 | if (this.head != null) { 37 | ElementoListaLinkata currentElement = this.head; 38 | 39 | while (currentElement.getNextElement() != null) { 40 | output += currentElement.getData() + ", "; 41 | currentElement = currentElement.getNextElement(); 42 | } 43 | output += currentElement.getData(); 44 | } 45 | 46 | output += " }"; 47 | return output; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /modulo7/pila/ListaLinkataMain.java: -------------------------------------------------------------------------------- 1 | public class ListaLinkataMain { 2 | public static void main(String[] args) { 3 | /* 4 | ListaLinkata listaLinkata = new ListaLinkata<>(); 5 | 6 | listaLinkata.addFirst("ciao"); 7 | listaLinkata.addFirst("come"); 8 | listaLinkata.addFirst("stai"); 9 | listaLinkata.addFirst("grazie"); 10 | System.out.println(listaLinkata); 11 | 12 | listaLinkata.removeFirst(); 13 | System.out.println(listaLinkata); 14 | 15 | listaLinkata.removeFirst(); 16 | listaLinkata.removeFirst(); 17 | System.out.println(listaLinkata); 18 | */ 19 | 20 | Pila pila = new Pila<>(); 21 | 22 | pila.push("va?"); 23 | pila.push("come"); 24 | pila.push("a tutti"); 25 | pila.push("Buonasera"); 26 | 27 | System.out.println(pila); 28 | 29 | pila.pop(); 30 | pila.pop(); 31 | 32 | System.out.println(pila); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /modulo7/pila/Pila.java: -------------------------------------------------------------------------------- 1 | public class Pila extends ListaLinkata { 2 | // Metodi 3 | 4 | public void push(T data) { 5 | this.addFirst(data); 6 | } 7 | 8 | public T pop() { 9 | T dataToRemove = this.getHead().getData(); 10 | this.removeFirst(); 11 | return dataToRemove; 12 | } 13 | 14 | public T peek() { 15 | return this.getHead().getData(); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /modulo7/pila/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Lista Linkata + Pila 🛴 2 | 3 | Progettate una classe ListaLinkata generica. 4 | 5 |
6 | 7 |
8 | 9 | Ogni elemento della lista contiene un valore e il riferimento al prossimo elemento. 10 | 11 | Implementate poi i metodi che realizzano le seguenti funzionalità: 12 | 13 | - inserimento di un elemento in cima alla lista; 14 | - rimozione di un elemento dalla cima della lista. 15 | 16 | Utilizzando poi la classe ListaLinkata appena realizzata e i suoi metodi progettate dunque una classe Pila. 17 | 18 | Come una pila di piatti è possibile inserire un elemento solo in cima alla pila, ed è possibile rimuovere solo il primo elemento. 19 | 20 | Implementate infine i seguenti metodi: 21 | 22 | - push: che inserisce un elemento in cima alla pila; 23 | - pop: che rimuove e restituisce il primo elemento della pila; 24 | - peek: che restituisce il primo elemento della pila senza rimuoverlo. -------------------------------------------------------------------------------- /modulo7/supermarket/Cliente.java: -------------------------------------------------------------------------------- 1 | public class Cliente implements Comparable { 2 | // Attributi 3 | 4 | private static int count = 1; 5 | private final int id; 6 | private String nome; 7 | private String cognome; 8 | private int eta; 9 | 10 | // Costruttore 11 | 12 | public Cliente(String nome, String cognome, int eta) { 13 | this.id = count++; 14 | this.nome = nome; 15 | this.cognome = cognome; 16 | this.eta = eta; 17 | } 18 | 19 | // Getter e Setter 20 | 21 | public int getId() { 22 | return id; 23 | } 24 | 25 | public String getNome() { 26 | return nome; 27 | } 28 | 29 | public void setNome(String nome) { 30 | this.nome = nome; 31 | } 32 | 33 | public String getCognome() { 34 | return cognome; 35 | } 36 | 37 | public void setCognome(String cognome) { 38 | this.cognome = cognome; 39 | } 40 | 41 | public int getEta() { 42 | return eta; 43 | } 44 | 45 | public void setEta(int eta) { 46 | this.eta = eta; 47 | } 48 | 49 | // Metodi 50 | 51 | @Override 52 | public String toString() { 53 | return "Cliente{" + 54 | "id=" + id + 55 | ", nome='" + nome + '\'' + 56 | ", cognome='" + cognome + '\'' + 57 | ", eta=" + eta + 58 | '}'; 59 | } 60 | 61 | @Override 62 | public int compareTo(Cliente c) { 63 | if (this.getEta() > c.getEta()) { 64 | return -1; 65 | } else if (this.getEta() < c.getEta()) { 66 | return 1; 67 | } 68 | return 0; 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /modulo7/supermarket/ClienteComparator.java: -------------------------------------------------------------------------------- 1 | import java.util.Comparator; 2 | 3 | public class ClienteComparator implements Comparator { 4 | 5 | @Override 6 | public int compare(Cliente c1, Cliente c2) { 7 | if (c1.getEta() > c2.getEta()) { 8 | return -1; 9 | } else if (c1.getEta() < c2.getEta()) { 10 | return 1; 11 | } 12 | return 0; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /modulo7/supermarket/SupermarketMain.java: -------------------------------------------------------------------------------- 1 | public class SupermarketMain { 2 | public static void main(String[] args) { 3 | Cliente cliente1 = new Cliente("Mario", "Bianchi", 34); 4 | Cliente cliente2 = new Cliente("Paolo", "Rossi", 55); 5 | Cliente cliente3 = new Cliente("Giovanni", "Storti", 41); 6 | Cliente cliente4 = new Cliente("Giacomo", "Poretti", 73); 7 | Cliente cliente5 = new Cliente("Luca", "Di Pietro", 12); 8 | 9 | Supermercato supermercato = new Supermercato(); 10 | supermercato.inserimentoCliente(cliente1); 11 | supermercato.inserimentoCliente(cliente4); 12 | supermercato.inserimentoCliente(cliente5); 13 | supermercato.inserimentoCliente(cliente2); 14 | supermercato.inserimentoCliente(cliente3); 15 | 16 | // Ordinamento con la stampa semplice (toString) di una PriorityQueue non garantito 17 | System.out.println(supermercato); 18 | 19 | while (supermercato.getNumeroClienti() > 0) { 20 | supermercato.rimozioneNextCliente(); 21 | } 22 | 23 | /* Alternativa 24 | while (supermercato.getNumeroClienti() > 0) { 25 | Cliente clienteDaRimuovere = supermercato.getNextCliente(); 26 | if (supermercato.rimozioneCliente(clienteDaRimuovere)) { 27 | System.out.println("Cliente " + clienteDaRimuovere.getNome() + " " + clienteDaRimuovere.getCognome() + " (Età: " + 28 | clienteDaRimuovere.getEta() + ") rimosso dalla coda"); 29 | } else { 30 | System.out.println("Impossibile rimuovere prossimo cliente"); 31 | } 32 | } 33 | */ 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /modulo7/supermarket/Supermercato.java: -------------------------------------------------------------------------------- 1 | import java.util.Comparator; 2 | import java.util.PriorityQueue; 3 | 4 | public class Supermercato { 5 | // Attributi 6 | 7 | PriorityQueue coda; 8 | 9 | // Costruttore 10 | 11 | public Supermercato() { 12 | this.coda = new PriorityQueue<>(Comparator.comparingInt(Cliente::getEta).reversed()); 13 | // this.coda = new PriorityQueue<>(new ClienteComparator()); 14 | // this.coda = new PriorityQueue<>(); 15 | } 16 | 17 | // Metodi 18 | 19 | public boolean inserimentoCliente(Cliente cliente) { 20 | boolean resultInserimento = this.coda.add(cliente); 21 | if (resultInserimento) { 22 | System.out.println("Inserimento cliente " + cliente.getNome() + " " + cliente.getCognome() + 23 | " eseguito correttamente"); 24 | } else { 25 | System.out.println("Impossibile inserire cliente " + cliente.getNome() + " " + cliente.getCognome()); 26 | } 27 | return resultInserimento; 28 | } 29 | 30 | public boolean rimozioneCliente(Cliente cliente) { 31 | return this.coda.remove(cliente); 32 | } 33 | 34 | public void rimozioneNextCliente() { 35 | Cliente clienteRimosso = this.coda.poll(); 36 | if (clienteRimosso != null) { 37 | System.out.println("Cliente " + clienteRimosso.getNome() + " " + clienteRimosso.getCognome() + " (Età: " + 38 | clienteRimosso.getEta() + ") rimosso dalla coda"); 39 | } else { 40 | System.out.println("Nessun cliente rimasto da rimuovere"); 41 | } 42 | } 43 | 44 | public Cliente getNextCliente() { 45 | return this.coda.peek(); 46 | } 47 | 48 | public int getNumeroClienti() { 49 | return this.coda.size(); 50 | } 51 | 52 | @Override 53 | public String toString() { 54 | return "Supermercato{" + 55 | "coda=" + coda + 56 | '}'; 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /modulo7/supermarket/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Supermercato Versione 2 🛴 2 | 3 | Scrivere un programma Java che permetta di gestire la coda di un supermercato. 4 | In particolare, deve essere possibile eseguire le seguenti operazioni: 5 | 6 | - inserimento in coda di un cliente 7 | - rimozione dalla coda di un cliente 8 | - ottenere prossimo cliente da servire 9 | - ottenere il numero di clienti attualmente in coda 10 | 11 | Ogni cliente ha nome, cognome, età e un id univoco. 12 | La coda, ovviamente, va gestita secondo la politica FIFO. 13 | 14 | PLUS 🏍 : Modificare la coda per favorire le persone più anziane 15 | 16 | Suggerimento: scegliete bene la struttura dati (una possibile soluzione potrebbe 17 | essere la PriorityQueue, che è un tipo di coda fornito da Java ad esempio...) 18 | -------------------------------------------------------------------------------- /modulo7/tinder_like/Interest.java: -------------------------------------------------------------------------------- 1 | public class Interest { 2 | // Attributi 3 | 4 | private static int count = 1; 5 | private final int id; 6 | private final String text; 7 | 8 | // Costruttore 9 | 10 | public Interest(String text) { 11 | this.id = count++; 12 | this.text = text; 13 | } 14 | 15 | // Getter 16 | 17 | public int getId() { 18 | return id; 19 | } 20 | 21 | public String getText() { 22 | return text; 23 | } 24 | 25 | // Metodi 26 | 27 | @Override 28 | public String toString() { 29 | return "Interest{" + 30 | "id=" + id + 31 | ", text='" + text + '\'' + 32 | '}'; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /modulo7/tinder_like/TinderLike.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.HashSet; 3 | 4 | public class TinderLike { 5 | // Attributi 6 | 7 | private HashMap users; 8 | 9 | // Costruttore 10 | 11 | public TinderLike() { 12 | this.users = new HashMap<>(); 13 | } 14 | 15 | // Metodi 16 | 17 | public User insertUserWithInterests(String name, HashSet interests) { 18 | User newUser = new User(name, interests); 19 | this.users.put(newUser.getId(), newUser); 20 | return newUser; 21 | } 22 | 23 | public void removeUser(User user) { 24 | this.users.remove(user.getId()); 25 | } 26 | 27 | public User getMostSimilarUser(User user) { 28 | User mostSimilarUser = null; 29 | int count = 0; 30 | 31 | if (users.containsKey(user.getId())) { 32 | for (User currentUser : this.users.values()) { 33 | if (currentUser.equals(user)) { 34 | continue; 35 | } 36 | 37 | HashSet userInterests = new HashSet<>(user.getInterests()); 38 | userInterests.retainAll(currentUser.getInterests()); 39 | 40 | if (mostSimilarUser == null || userInterests.size() > count) { 41 | mostSimilarUser = currentUser; 42 | count = userInterests.size(); 43 | } 44 | } 45 | } 46 | 47 | return mostSimilarUser; 48 | } 49 | 50 | @Override 51 | public String toString() { 52 | return "TinderLike{" + 53 | "users=" + users + 54 | '}'; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /modulo7/tinder_like/TinderLikeMain.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.HashSet; 3 | 4 | public class TinderLikeMain { 5 | public static void main(String[] args) { 6 | TinderLike tinderLike = new TinderLike(); 7 | 8 | Interest i1 = new Interest("Calcio"); 9 | Interest i2 = new Interest("Tennis"); 10 | Interest i3 = new Interest("Ping Pong"); 11 | Interest i4 = new Interest("Pesca"); 12 | Interest i5 = new Interest("Libri"); 13 | Interest i6 = new Interest("Informatica"); 14 | Interest i7 = new Interest("Serie TV"); 15 | Interest i8 = new Interest("Cinema"); 16 | Interest i9 = new Interest("Bricolage"); 17 | Interest i10 = new Interest("Dormire"); 18 | 19 | HashSet interest1Set = new HashSet<>(Arrays.asList(i1, i2, i3, i4, i5, i6, i7)); 20 | User u1 = tinderLike.insertUserWithInterests("Marco", interest1Set); 21 | 22 | HashSet interest2Set = new HashSet<>(Arrays.asList(i1, i2, i8, i9, i10)); 23 | User u2 = tinderLike.insertUserWithInterests("Paola", interest2Set); 24 | 25 | HashSet interest3Set = new HashSet<>(Arrays.asList(i5, i6, i7, i8, i9)); 26 | User u3 = tinderLike.insertUserWithInterests("Filippo", interest3Set); 27 | 28 | System.out.println(tinderLike); 29 | System.out.println(tinderLike.getMostSimilarUser(u3)); 30 | 31 | tinderLike.removeUser(u1); 32 | System.out.println(tinderLike.getMostSimilarUser(u3)); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /modulo7/tinder_like/User.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | 3 | public class User { 4 | // Attributi 5 | 6 | private static int count = 1; 7 | private final int id; 8 | private final String name; 9 | private final HashSet interests; 10 | 11 | // Costruttore 12 | 13 | public User(String name, HashSet interests) { 14 | this.id = count++; 15 | this.name = name; 16 | this.interests = interests; 17 | } 18 | 19 | // Getter 20 | 21 | public int getId() { 22 | return id; 23 | } 24 | 25 | public String getName() { 26 | return name; 27 | } 28 | 29 | public HashSet getInterests() { 30 | return interests; 31 | } 32 | 33 | // Metodi 34 | 35 | @Override 36 | public String toString() { 37 | return "User{" + 38 | "id=" + id + 39 | ", name='" + name + '\'' + 40 | ", interests=" + interests + 41 | '}'; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /modulo7/tinder_like/readme.md: -------------------------------------------------------------------------------- 1 | # Esercizio Tinder Like 🛵 2 | 3 | Scrivere un programma per gestire gli interessi in comune tra le persone. 4 | In particolare, deve essere possibile gestire una quantità potenzialmente 5 | infinita di utenti, ognuno con i propri interessi (a ciascun utente può essere 6 | associato uno o più interessi). 7 | Ogni interesse ha un codice e un testo. 8 | 9 | Devono essere possibili le seguenti operazioni: 10 | - inserire un utente e i suoi interessi 11 | - cancellare un utente (e i suoi interessi associati) 12 | - dato un utente u1, ottenere l'utente u2 con più interessi in comune con u1 13 | - PLUS 🏍:ottenere gli utenti più simili (ossia con più interessi in comune) -------------------------------------------------------------------------------- /modulo8/turista/readme.md: -------------------------------------------------------------------------------- 1 | Un facoltoso turista americano ci ha chiesto di creare una piattaforma ispirata ad un famoso sito per affittare 2 | case vacanza. Tutti possono registrarsi alla piattaforma e, se approvati come host, caricare una o più abitazioni 3 | e specificare un prezzo, un periodo (data di inizio e data di fine) durante il quale l'abitazione è 4 | prenotabile da altri utenti. Ogni abitazione ha id, nome, indirizzo, numero di locali, numero di posti letto e piano. 5 | Ogni utente ha nome cognome, email, indirizzo e ogni host ha un codice host. In più, un super-host è tale 6 | se ha ricevuto, da quando si è registrato, almeno 100 prenotazioni. 7 | Di ogni prenotazione si deve mantenere un id univoco, le date di inizio e fine, l'abitazione relativa e l'utente che 8 | ha soggiornato. Ogni utente che ha soggiornato presso un abitazione può lasciare un feedback al proprietario 9 | dell'abitazione. Ogni feedback ha un id, un titolo, un testo e un punteggio (da 1 a 5). 10 | Deve essere possibile effettuare le seguenti operazioni nel sistema: 11 | 12 | - ottenere le abitazioni corrispondente ad un certo codice host 13 | - ottenere l'ultima prenotazione dato un id utente 14 | - ottenere l'abitazione più gettonata nell'ultimo mese 15 | - ottenere gli host con più prenotazioni nell'ultimo mese 16 | - ottenere tutti i super-host 17 | - ottenere i 5 utenti con più giorni prenotati nell'ultimo mese 18 | - ottenere il numero medio di posti letto calcolato in base a tutte le abitazioni caricate dagli host 19 | 20 | 21 | Per le date e i periodi potete utilizzare java.time.LocalDateTime e java.time.Duration 22 | esempio: 23 | 24 | ` 25 | Period.between(aDate, sixtyDaysBehind); 26 | ` 27 | Nota: inserire eccezioni dove pensate siano opportune 28 | Nota: gestite tutto con le collection, nessun database (per ora!) 29 | -------------------------------------------------------------------------------- /modulo9/parole/readme.md: -------------------------------------------------------------------------------- 1 | # FILE E PAROLE 🛴 2 | 3 | Spesso è interessante analizzare uno o più file di testo in una determinata lingua per comprendere quali siano le parole più frequenti (o anche le lettere più frequenti). Questo tipo di lavoro è molto utilizzato in vari ambiti, dalla crittografia alla linguistica al Natural Language Processing. La seguente classe da realizzare, la classe FileAndParole effettua alcune di queste operazioni. Essa è composta dai seguenti metodi: 4 | 5 | -stampaParole(Path file): questo metodo prende in input un oggetto della classe Path del package java.nio.file rappresentante un file di testo e stampa riga per riga tutte le parole contenute nel testo. Si supponga che ogni parola sia separata da spazio e non vi siano segni di punteggiatura. 6 | 7 | -occorrenzeParole(Path file): questo metodo prende in input un oggetto della classe Path del package java.nio.file rappresentante un file di testo e ritorna una HashMap dove le chiavi sono le parole e i valori sono il numero di occorrenze delle parole stesse nel testo. Si supponga che ogni parola sia separata da spazio, siano tutte minuscole e non vi siano segni di punteggiatura. 8 | 9 | -occorrenzeParoleTesto(Path file): questo metodo prende in input un oggetto della classe Path del package java.nio.file rappresentante un file di testo e ritorna una HashMap dove le chiavi sono le parole e i valori sono il numero di occorrenze delle parole stesse nel testo. In questo caso il testo può comprendere punteggiatura e lettere maiuscole. SUGGERIMENTO: per eliminare la punteggiatura da una riga di testo utilizzare il metodo riga.split("\W+"). 10 | 11 | -paroleInRima(Path file): questo metodo prende in input un oggetto della classe Path del package java.nio.file rappresentante un file di testo in italiano e il suo obiettivo è quello di catalogare le parole in rima. Due parole in italiano di intendono in rima se: -Terminano con una sequenza vocale-consonante-vocale identica. -Terminano con una sequenza vocale-consonante-consonante-vocale identica. Il metodo deve ritornare una HashMap dove le chiavi sono i dittonghi finali (le rime) e i valori sono ArrayList contenenti tutte le parole che terminano con quel dittongo (rima). Ad esempio se il testo è il seguente: 12 | 13 | "Il soldato è tornato passando per un ponte vicino a una fonte" 14 | 15 | Il metodo deve tornare: 16 | 17 | {"ato": ["soldato", "tornato"], "ando": ["passando"], "onte": ["ponte", "fonte"], 18 | "ino": ["vicino"] } 19 | 20 | NB: ignorare completamente le parole con lunghezza minore di 4 lettere. -------------------------------------------------------------------------------- /modulo9/righe/readme.md: -------------------------------------------------------------------------------- 1 | ## Collection di righe 🛴 2 | 3 | Leggere il file righe.txt usando le classi del package java.nio 4 | 5 | Aggiungere le righe in una collection 6 | 7 | Scrivere le righe nel file righeInverse.txt in ordine inverso, quindi l'ultima riga del file righe.txt deve essere la prima riga del file righeInverse.txt -------------------------------------------------------------------------------- /modulo9/righe/righe.txt: -------------------------------------------------------------------------------- 1 | 0 Aeque enim 2 | 1 contingit omnibus 3 | 2 fidibus, ut 4 | 3 incontentae sint. 5 | 4 Lorem ipsum 6 | 5 dolor sit 7 | 6 amet, consectetur 8 | 7 adipiscing elit. 9 | 8 Quae cum 10 | 9 ita sint, 11 | 10 effectum est 12 | 11 nihil esse 13 | 12 malum, quod 14 | 13 turpe non 15 | 14 sit. Itaque 16 | 15 nostrum est-quod 17 | 16 nostrum dico, 18 | 17 artis est-ad 19 | 18 ea principia, 20 | 19 quae accepimus. 21 | 20 Quod totum 22 | 21 contra est. 23 | 22 Duo Reges: 24 | 23 constructio interrete. 25 | 24 Atqui iste 26 | 25 locus est, 27 | 26 Piso, tibi 28 | 27 etiam atque 29 | 28 etiam confirmandus, 30 | 29 inquam; Quamvis 31 | 30 enim depravatae 32 | 31 non sint, 33 | 32 pravae tamen 34 | 33 esse possunt. 35 | 34 Duarum enim 36 | 35 vitarum nobis 37 | 36 erunt instituta 38 | 37 Non igitur 39 | 38 de improbo, 40 | 39 sed de 41 | 40 callido improbo 42 | 41 quaerimus, qualis 43 | 42 Q. Audio 44 | 43 equidem philosophi 45 | 44 vocem, Epicure, 46 | 45 sed quid 47 | 46 tibi dicendum 48 | 47 sit oblitus 49 | 48 es. Ex 50 | 49 ea difficultate 51 | 50 illae fallaciloquae, 52 | 51 ut ait 53 | 52 Accius, malitiae 54 | 53 natae sunt. 55 | 54 At multis 56 | 55 malis affectus. 57 | 56 Nam quibus 58 | 57 rebus efficiuntur 59 | 58 voluptates, eae 60 | 59 non sunt 61 | 60 in potestate 62 | 61 sapientis. Quis 63 | 62 est tam 64 | 63 dissimile homini. 65 | 64 Ut proverbia 66 | 65 non nulla 67 | 66 veriora sint 68 | 67 quam vestra 69 | 68 dogmata. Si 70 | 69 quicquam extra 71 | 70 virtutem habeatur 72 | 71 in bonis. 73 | 72 Sed plane 74 | 73 dicit quod 75 | 74 intellegit. Paulum, 76 | 75 cum regem 77 | 76 Persem captum 78 | 77 adduceret, eodem 79 | 78 flumine invectio? 80 | 79 Qui ita 81 | 80 affectus, beatum 82 | 81 esse numquam 83 | 82 probabis; Sed 84 | 83 nimis multa. 85 | 84 Nam prius 86 | 85 a se 87 | 86 poterit quisque 88 | 87 discedere quam 89 | 88 appetitum earum 90 | 89 rerum, quae 91 | 90 sibi conducant, 92 | 91 amittere. Familiares 93 | 92 nostros, credo, 94 | 93 Sironem dicis 95 | 94 et Philodemum, 96 | 95 cum optimos 97 | 96 viros, tum 98 | 97 homines doctissimos. 99 | 98 Quod iam 100 | 99 a me 101 | 100 expectare noli. 102 | 101 Quid ergo? 103 | 102 Eademne, quae 104 | 103 restincta siti? 105 | 104 Ita relinquet 106 | 105 duas, de 107 | 106 quibus etiam 108 | 107 atque etiam 109 | 108 consideret. Illa 110 | 109 videamus, quae 111 | 110 a te 112 | 111 de amicitia 113 | 112 dicta sunt. 114 | 113 Eaedem res 115 | 114 maneant alio 116 | 115 modo. Quid 117 | 116 ergo attinet 118 | 117 gloriose loqui, 119 | 118 nisi constanter 120 | 119 loquare? Prioris 121 | 120 generis est 122 | 121 docilitas, memoria; 123 | 122 Portenta haec 124 | 123 esse dicit, 125 | 124 neque ea 126 | 125 ratione ullo 127 | 126 modo posse 128 | 127 vivi; Beatum, 129 | 128 inquit. Bestiarum 130 | 129 vero nullum 131 | 130 iudicium puto. 132 | 131 Quem Tiberina 133 | 132 descensio festo 134 | 133 illo die 135 | 134 tanto gaudio 136 | 135 affecit, quanto 137 | 136 L. Quorum 138 | 137 sine causa 139 | 138 fieri nihil 140 | 139 putandum est. 141 | 140 Tria genera 142 | 141 bonorum; Nunc 143 | 142 dicam de 144 | 143 voluptate, nihil 145 | 144 scilicet novi, 146 | 145 ea tamen, 147 | 146 quae te 148 | 147 ipsum probaturum 149 | 148 esse confidam. 150 | 149 Illud dico, 151 | 150 ea, quae 152 | 151 dicat, praeclare 153 | 152 inter se 154 | 153 cohaerere. Fortemne 155 | 154 possumus dicere 156 | 155 eundem illum 157 | 156 Torquatum? Hoc 158 | 157 tu nunc 159 | 158 in illo 160 | 159 probas. Cur 161 | 160 post Tarentum 162 | 161 ad Archytam? 163 | 162 Indicant pueri, 164 | 163 in quibus 165 | 164 ut in 166 | 165 speculis natura 167 | 166 Sed tamen 168 | 167 est aliquid, 169 | 168 quod nobis 170 | 169 non liceat, 171 | 170 liceat illis. 172 | 171 Virtutis, magnitudinis 173 | 172 animi, patientiae, 174 | 173 fortitudinis fomentis 175 | 174 dolor mitigari 176 | 175 solet. Piso 177 | 176 igitur hoc 178 | 177 modo, vir 179 | 178 optimus tuique, 180 | 179 ut scis, 181 | 180 amantissimus. Non 182 | 181 prorsus, inquit, 183 | 182 omnisque, qui 184 | 183 sine dolore 185 | 184 sint, in 186 | 185 voluptate, et 187 | 186 ea quidem 188 | 187 summa, esse 189 | 188 dico. Potius 190 | 189 inflammat, ut 191 | 190 coercendi magis 192 | 191 quam dedocendi 193 | 192 esse videantur. 194 | 193 Virtutis, magnitudinis 195 | 194 animi, patientiae, 196 | 195 fortitudinis fomentis 197 | 196 dolor mitigari 198 | 197 solet. Quae 199 | 198 fere omnia 200 | 199 appellantur uno 201 | 200 ingenii nomine, 202 | 201 easque virtutes 203 | 202 qui habent, 204 | 203 ingeniosi vocantur. 205 | 204 Nec enim, 206 | 205 dum metuit, 207 | 206 iustus est, 208 | 207 et certe, 209 | 208 si metuere 210 | 209 destiterit, non --------------------------------------------------------------------------------