Esercizi Java

Sintassi di base

Gli esercizi sono gli stessi della programmazione C++: https://cipiaceinfo.it/docs/programmazione/esercizi-programmazione/esercizi-c-c-2/ con le dovute differenze di linguaggio (i/o, passaggio per valore/riferimento, stringhe, gestione files, struct). Si suggeriscono esercizi solo sui costrutti di base.

Oggetti e classi

1. Definire una classe Persona con attributi nome e cognome; creare un oggetto di questa classe nel main e stampare i valori degli attributi.
2. Creare una classe Studente con attributi nome, matricola e voto. Nel main creare due oggetti Studente e stampare i rispettivi attributi.
3. Aggiungere un costruttore alla classe Studente per inizializzare nome, matricola e voto. Testare la classe creando un oggetto tramite il costruttore.
4. Creare una classe Libro con attributi titolo e autore, fornendo sia un costruttore completo sia un costruttore vuoto (default). Nel main verificare il funzionamento di entrambe le versioni.
5. Nella classe Studente aggiungere un metodo stampaInfo() per visualizzare tutte le informazioni dello studente. Utilizzare il metodo nel main.
6. Aggiungere un metodo aggiornaVoto(int nuovoVoto) per aggiornare il voto di uno studente. Testare il metodo con un oggetto.
7. Creare un array di 5 oggetti Studente, inizializzarli con valori diversi e stampare le loro informazioni utilizzando un ciclo for.
8. Creare una classe Studente con costruttore vuoto e attributi privati nome, matricola e voto e relativi getter e setter pubblici. Nel main creare due oggetti Studente e stampare i rispettivi attributi pubblici.
9. Creare una classe Libro con attributi privati titolo e autore, fornendo un costruttore completo, e solo getter pubblici . Nel main verificare il funzionamento di entrambe le versioni.
10. Aggiungere alla classe Studente una variabile static int numeroStudenti per contare il numero di oggetti creati. Nel main far inserire un numero di studenti a piacimento fino a quando l’utente non ne vuole inserire di nuovi. Al termine stampare la lista degli studenti e il loro numero.
11. Definire una classe MathUtils con un metodo statico calcolaMedia(int a, int b) che restituisca la media dei due valori. Utilizzare il metodo nel main.
12. Nel metodo setter del voto verificare che il valore sia compreso tra 0 e 30; se il valore non è valido, non modificarlo e visualizzare un messaggio di errore.
13. Creare una classe Corso con attributi nomeCorso e una lista di Studente iscritti. Implementare i metodi aggiungiStudente(Studente s) e stampaStudenti(). Le due classi devono appartenere a due package differenti.
14. Modificare la classe Studente in modo che contenga anche il riferimento al corso frequentato. Verificare il funzionamento creando istanze di Studente e Corso. Usare sempre package differenti.
15. Realizzare un semplice sistema di gestione di una biblioteca mediante le classi Libro, Utente e Prestito. Nel main simulare il prestito di libri e stampare l’elenco dei prestiti effettuati. Inserire un insieme significativo di almeno 10 libri e 5 utenti, con almeno 5 prestiti. Utente deve avere un package diverso da Libro e Prestito.
16. Modificare l’esercizio precedente: aggiungere a Libro un attributo statico privato contatore, che viene incrementato ogni volta che viene creato un libro. E’ presente poi un attributo privato non statico id, con getter pubblico che prende il valore del contatore ad ogni creazione di un nuovo libro. Nel main creare poi un duplicato dei libri da 1 a 5, usando la deep copy. I nuovi libri dovranno avere titolo ed autore identici agli originali, ma id differente.

Classi libreria Java

1. Creare un programma che mostri il testo “Java Library Demo” usando System.out.println().
2. Utilizzare la classe String per concatenare due stringhe e stampare il risultato (es. nome e cognome).
3. Creare una stringa e stampare la lunghezza della stessa usando un metodo della classe String.
4. Utilizzare il metodo toUpperCase() di String per convertire una frase in maiuscolo e visualizzarla.
5. Usare Math.abs() per calcolare il valore assoluto di un numero negativo e stamparlo.
6. Usare Math.max() e Math.min() per trovare e stampare il massimo e il minimo tra due numeri.
7. Calcolare la potenza di un numero usando Math.pow() e stampare il risultato.
8. Generare un numero casuale tra 0 e 100 utilizzando Math.random() e stamparlo.
9. Importare la classe Scanner, leggere un intero da console e visualizzare il numero inserito.
10. Utilizzare Scanner per leggere due numeri interi e stampare la loro somma.
11. Usare Scanner per leggere una riga di testo e poi visualizzarla con un messaggio personalizzato.
12. Leggere da tastiera due numeri reali (double) con Scanner e stampare il risultato della loro moltiplicazione.
13. Creare una stringa tramite String e usare charAt() per estrarre e stampare il primo carattere.
14. Dato un numero double, usare Math.round() per arrotondarlo all’intero più vicino e stampare il risultato.
15. Leggere un intero positivo con Scanner e stampare tutti i numeri da 1 a quel valore usando un ciclo (ad es. for)
16. Creare un programma che provi a leggere il contenuto di un file di testo chiamato input.txt e lo stampi a schermo. Gestire l’eventuale errore di file non trovato usando try e catch.
17. Scrivere un programma che chieda all’utente una frase e la salvi in un file output.txt. Gestire eventuali errori di scrittura mediante try–catch.
18. Creare un programma che legga un numero intero da un file numero.txt e ne stampi il doppio. Gestire le possibili eccezioni dovute all’assenza del file o al formato non valido del contenuto.
19. Scrivere un programma che copi il contenuto del file origine.txt nel file destinazione.txt, gestendo tutte le possibili eccezioni con try–catch.
20. Creare un programma che legga tutte le righe di un file nomi.txt e conti quante righe sono presenti nel file. Gestire eventuali errori di apertura del file con try–catch.

Ereditarietà

1. Definire una classe Animale con un metodo emettiSuono() che stampa un messaggio generico. Creare una sottoclasse Cane che estende Animale e che sovrascrive emettiSuono() stampando un verso specifico.
2. Creare una classe Veicolo con attributo velocita e un metodo stampaVelocita(). Definire una classe Auto che estende Veicolo aggiungendo un attributo marca. Testare la creazione di un oggetto Auto e la stampa dei suoi valori.
3. Realizzare una classe Persona con attributi nome e cognome e un metodo datiPersona(). Creare una sottoclasse Studente che aggiunge un attributo matricola e sovrascrive datiPersona() per includere anche la matricola.
4. Definire una classe Shape con un metodo area() che ritorna 0. Creare classi derivate Rettangolo e Cerchio che estendono Shape e implementano area() calcolando l’area corretta.
5. Creare una classe Impiegato con attributo stipendio e un metodo calcolaBonus() che ritorna il 10% dello stipendio. Definire una sottoclasse Manager che estende Impiegato e sovrascrive calcolaBonus() per restituire il 20% dello stipendio.
6. Realizzare una classe Libro con attributi titolo e autore. Creare una sottoclasse LibroIllustrato che aggiunge un attributo numeroPagineIllustrazioni. Implementare un metodo descrizione() che mostri tutte le informazioni.
7. Definire una classe Computer con attributo ram e un costruttore per inizializzarlo. Creare una sottoclasse Laptop che aggiunge un attributo peso e utilizza super per richiamare il costruttore della classe base.
8. Creare una classe Shape3D con un metodo volume() che ritorna 0. Creare una sottoclasse Cubo con un attributo lato e implementare il metodo volume() per calcolare il volume.
9. Realizzare una classe Persona con un costruttore che inizializza nome e cognome. Creare una sottoclasse Dipendente che chiama il costruttore della superclasse con super e aggiunge un attributo ruolo.
10. Definire una classe Elettronico con un metodo accendi(). Creare due classi derivate Televisore e Radio che estendono Elettronico sovrascrivendo accendi() con messaggi differenti.
11. Scrivere una classe Frutto con attributo colore e metodo getDescrizione(). Creare classi Mela e Banana che estendono Frutto e aggiungono un metodo gusto() specifico per ciascun frutto.
12. Creare una classe Quadrilatero con metodi per impostare e ottenere la lunghezza dei lati. Estendere questa classe con Quadrato che imposta automaticamente tutti i lati uguali e aggiunge un metodo perimetro().
13. Realizzare una classe Dipendente con metodo calcolaPaga(). Creare una sottoclasse PartTime che estende Dipendente e aggiunge attributi oreLavorate e tariffaOraria, implementando calcolaPaga() specificamente.
14. Definire una classe Persona con metodo saluta(). Creare una sottoclasse Amico che estende Persona e aggiunge un attributo soprannome. Nel main, creare un oggetto Amico e chiamare saluta().
15. Creare una classe Dispositivo con attributo nome. Estendere questa classe con Smartphone e Tablet, aggiungendo un metodo tipoDispositivo() che ritorna una descrizione specifica per ogni sottoclasse.
16. Definire una classe Veicolo con metodo final avvia() e verificare che non possa essere sovrascritto.
17. Creare una classe Animale con attributo final specie e inizializzarlo nel costruttore.
18. Definire una classe Persona con attributo protected nome e creare la sottoclasse Studente che accede direttamente all’attributo.
19. Creare una classe Veicolo con metodo protected descrizione() e una sottoclasse Moto che lo utilizza.
20. Realizzare una classe ContoBancario con attributo protected saldo e una sottoclasse ContoRisparmio che lo modifica.
21. Definire una classe astratta Figura con metodo astratto area() e creare le sottoclassi Rettangolo e Cerchio.
22. Creare una classe astratta Dipendente con metodo astratto calcolaStipendio() e le sottoclassi DipendenteFisso e DipendenteOrario.
23. Definire una classe astratta Animale con metodo astratto verso() e le sottoclassi Cane e Gatto.
24. Creare una classe astratta Veicolo con metodo astratto consumo() e la sottoclasse Auto.
25. Definire una classe astratta StrumentoMusicale con metodo astratto suona() e creare due sottoclassi.

Polimorfismo

1. Definire una classe Animale con metodo verso() e creare le sottoclassi Cane e Gatto che sovrascrivono il metodo.
2. Definire una classe Figura con metodo disegna() e creare le sottoclassi Cerchio, Rettangolo e Triangolo. Inserire gli oggetti in un array di Figura e chiamare disegna() per ciascuno.
3. Creare una classe Veicolo con metodo muovi() e le sottoclassi Bicicletta, Auto e Moto. Usare riferimenti Veicolo per ciascuna sottoclasse.
4. Definire una classe Dipendente con metodo calcolaPaga() e le sottoclassi DipendenteFisso e DipendenteOrario che lo sovrascrivono.
5. Definire una classe StrumentoMusicale con metodo suona() e le sottoclassi Pianoforte, Chitarra e Batteria. Scrivere un metodo che accetta StrumentoMusicale e richiama suona().
6. Creare una classe ContoBancario con metodo getDescrizione() e le sottoclassi ContoCorrente e ContoDeposito che lo sovrascrivono.
7. Definire una classe astratta AnimaleAstratto con metodo astratto nutriti() e le sottoclassi Orso e Cervo che lo implementano.
8. Creare una classe astratta Forma con metodo astratto area() e le sottoclassi Cerchio e Quadrato.
9. Definire una classe Messaggio con metodo stampa() e le sottoclassi MessaggioHTML e MessaggioPlain.
10. Creare una classe Prodotto con metodo prezzoFinale() e le sottoclassi ProdottoScontato e ProdottoNormale.
11. Definire una classe Forma3D con metodo volume() e le sottoclassi Cubo e Sfera.
12. Definire una classe Pagamento con metodo effettua() e le sottoclassi PagamentoCarta, PagamentoContanti e PagamentoBonifico. Scrivere un metodo processaPagamento(Pagamento p).
13. Creare una classe Uccello con metodo vola() e le sottoclassi Aquila e Pinguino che lo sovrascrivono.
14. Definire una classe Logger con metodo log(String msg) e le sottoclassi ConsoleLogger e FileLogger. Inserire gli oggetti in un array di Logger.
15. Definire una classe astratta Giocatore con metodo astratto gioca() e le sottoclassi GiocatoreCalcio e GiocatoreBasket.
16. Definire un’interfaccia Volante con metodo vola() e creare le classi Aereo e Uccello che la implementano.
17. Definire un’interfaccia Stampabile con metodo stampa() e implementarla nelle classi Documento e Immagine.
18. Definire un’interfaccia Pagabile con metodo paga() e implementarla nelle classi Dipendente e Fornitore.
19. Definire un’interfaccia Strumento con metodo suona() e implementarla nelle classi Chitarra e Pianoforte. Inserire gli oggetti in un array di Strumento.
20. Definire un’interfaccia Connettibile con metodo connetti() e implementarla nelle classi Stampante, Mouse e Tastiera.
21. Definire un’interfaccia VeicoloElettrico con metodo ricarica() e implementarla nelle classi AutoElettrica e MonopattinoElettrico.
22. Definire un’interfaccia Notificabile con metodo notifica(String messaggio) e implementarla nelle classi Email e SMS.
23. Definire un’interfaccia Salvabile con metodo salva() e implementarla nelle classi FileTesto e ImmagineDigitale.

Progettazione

1. Implementare un sistema per gestire una flotta aziendale di veicoli.L’obiettivo è quello di gestire diversi tipi di mezzi di trasporto con logiche di costo differenti.

• Interfaccia Assicurabile: definisce il metodo calcolaPremio().
• Classe Astratta Veicolo: contiene campi come targa e modello. Definisce il metodo astratto calcolaCostoManutenzione().
• Classe Auto: estende Veicolo e implementa Assicurabile. Il calcolo del premio dipende dalla cilindrata.
• Classe Camion: estende Veicolo e implementa Assicurabile. Il costo di manutenzione dipende dal tonnellaggio.
• Classe GestoreFlotta: contiene un array di Veicolo[] e un metodo per stampare i dettagli di ogni mezzo.

Disegnare UML di progetto.

2. A partire dall’esempio delle figure geometriche di questa lezione (https://cipiaceinfo.it/docs/programmazione/java/polimorfismo/) nello specifico la versione con più interfacce, estenderlo in questo modo:

• introdurre una gerarchia di classi per gestire i triangoli (Scaleno, Isoscele, Rettangolo, Equilatero), con eventuali classi astratte;
• introdurre inoltre il Quadrilatero, il Quadrato ed il Rombo ed inserirli insieme al Rettangolo in una opportuna gerarchia di classi facendo uso, se necessario, di classi astratte.

Disegnare UML e scrivere il codice.

3. Un albergo dispone di un certo numero di stanze, dove ogni stanza è definita da:

• numero di stanza (stringa)
• numero di locali
• numero di posti letto
• piano

Le stanze sono caricate a sistema da un CSV.

E’ possibile prenotare le stanze tramite una prenotazione, a sua volta definita da:

• id prenotazione
• stanza (Stanza)
• data inizio
• data fine
• nome prenotazione (Utente)

Un utente è una anagrafica caricata a sistema da CSV (id, nome, cognome, impiego, età).

Vanno realizzate anche delle classi che gestiscono stanze e prenotazioni.

L’applicazione, con la sua UI, deve permettere di:

• vedere le prenotazioni attive a partire dalla data odierna;
• vedere le stanze libere;
• creare una prenotazione: prima di creare una prenotazione vengono mostrate le stanze libere;

Disegnare l’UML.

4. Implementare in Java l’esercizio precedente, con questi CSV:

Utenti:

id,nome,cognome,impiego,età
1,Mario,Rossi,Impiegato,45
2,Luigi,Bianchi,Ingegnere,38
3,Anna,Verdi,Insegnante,42
4,Giulia,Neri,Avvocato,35
5,Paolo,Conti,Medico,50
6,Francesca,Gallo,Architetto,33
7,Marco,Ferrari,Programmatore,29
8,Elena,Russo,Designer,31
9,Andrea,Romano,Commercialista,48
10,Sara,Greco,Psicologa,37
11,Davide,Colombo,Analista,41
12,Laura,Ricci,Giornalista,39
13,Stefano,Marini,Manager,46
14,Chiara,De Luca,HR Specialist,34
15,Alessandro,Costa,Consulente,44
16,Martina,Barbieri,Ricercatrice,28
17,Simone,Moretti,Tecnico IT,36
18,Valentina,Fontana,Marketing Manager,40
19,Giorgio,Rinaldi,Imprenditore,52
20,Ilaria,Santoro,Assistente amministrativa,32
21,Fabio,Caruso,Geometra,47
22,Marta,Longo,Social Media Manager,27
23,Nicola,Serra,Data Scientist,35
24,Roberta,Pellegrini,Copywriter,30
25,Matteo,Fabbri,Sistemista,43
26,Claudia,Villa,UX Designer,29
27,Emanuele,Orlando,Project Manager,41
28,Silvia,Testa,Educatrice,38
29,Riccardo,Parisi,Economista,49
30,Beatrice,Mancini,Traduttrice,34

Stanze:

NumeroStanza,NumeroLocali,PostiLetto,Piano
S101,1,2,1
S102,2,3,1
S103,1,1,1
S104,3,4,1
S105,2,2,1
S201,1,2,2
S202,4,6,2
S203,2,2,2
S204,1,1,2
S205,3,5,2
S301,2,2,3
S302,1,2,3
S303,5,8,3
S304,2,3,3
S305,1,1,3
S401,3,4,4
S402,2,2,4
S403,1,2,4
S404,4,6,4
S405,2,3,4
S501,1,1,5
S502,3,4,5
S503,2,2,5
S504,1,2,5
S505,2,4,5
A101,1,2,1
A102,2,3,1
A103,1,1,1
A104,3,5,1
A105,2,2,1
A201,2,2,2
A202,1,2,2
A203,4,6,2
A204,2,3,2
A205,1,1,2
B101,3,4,1
B102,2,2,1
B103,1,2,1
B104,5,10,1
B105,2,3,1
B201,1,1,2
B202,3,4,2
B203,2,2,2
B204,1,2,2
B205,2,4,2
C101,1,2,1
C102,2,3,1
C103,1,1,1
C104,3,5,1
C105,2,2,1

Generics

1. Definire una classe generica Contenitore<T> che contenga un singolo oggetto di tipo T con i metodi set(T x) e get(). Creare un qualsiasi oggetto T (ad esempio utilizzare gli esempi Acqua, Latte, ecc.) ed istanziare un nuovo Contenitore del tipo specifico.
2. Modificare Contenitore<T> aggiungendo un metodo swap(Contenitore<T> altro) per scambiare il contenuto, ed applicarlo con un esempio specifico.
3. Creare una classe generica Coppia<T, U> che memorizzi due valori di tipi differenti. Istanziare una coppia di Integer, String valorizzandole.
4. Dato il seguente UML creare tutte le classi. Va implementato in particolare il metodo versa nella classe Bottiglia, che a sua volta esegue il metodo riempi nell’oggetto Bicchiere passato come argomento.
   Nel main :
   – creare una bottiglia di vino da 750
   – creare un bicchiere da 70
   – versare 50 nel bicchiere

5. L’azienda di corrieri CHL ha bisogno di gestire diversi tipi di pacchi. Per questo utilizza una classe astratta Pacco<T> dove T estende una classe astratta che implementa una interfaccia di tipo Contenuto, che con due metodi getTipologia() e getValore() che restituisce un Enum con questi possibili valori: Alimento, Liquido, Infiammabile, Solido, Fragile. Pacco invece ha una proprietà peso (Double) e un metodo pubblico void spedisci(). Creare delle classi concrete che implementano almeno una tipologia di Contenuto, come Smartphone, Acqua, Pizza, OlioMotore, Libro, con attributi specifici scelti a piacere. Creare classi concrete che estendono Pacco (col tipo specifico) (l’implementazione di spedisci è lasciata a piacere). Nel main creare un numero significativo di istanze per ciascun tipo creato.

6. Musicfy è un gestore di contenuti multimediale che gestisce un insieme di contenuti che implementano l’interfaccia MediaInterface i cui metodi sono getTitolo(), getAutore(), getTipologia() dove la tipologia è un Enum di tipo Canzone, Audiolibro o Podcast. Creare la classe astratta corrispondente Media (che implementa l’interfaccia MediaInterface) e le relative sottoclassi concrete di Media per ciascun tipo di contenuto.
Creare poi una classe Playlist<T extends Media> che contiene una proprietà List<T> list (con getter pubblico) e un metodo stampaDettagli() che per ogni elemento della lista ne stampa le caratteristiche (cioè gli attributi sopra definiti). Nel main creare un certo numero di media per ogni tipo a piacere.
Istanziare una playlist generica con la classe Media, ed una specifica per ciascun tipo di Tipologia, riempirle coi media e stamparne le caratteristica di ciascuna.

7. Creare un ArrayList di 10 Bicchieri (vedi es. 4 del gruppo precedente) di dimensione scelta casualmente e riempirli a metà.

8. Creare una HashMap<String, String> ed inserire 4 tipi di Birra (con nomi diversi) usando come chiavi i nomi stessi.

Stream

1. Data una lista di nomi come ad esempio: ["Anna", "Marco", "Antonio", "Paolo", "Alice", "Giuseppe"] creare una nuova lista che contiene tutti i nomi che iniziano per A, scritti in maiuscolo. Usare gli stream. Il primo carattere di una stringa si ottiene con charAt(0). Per trasformare una stringa in maiuscolo si usare toUpperCase().
2. Data una lista di numeri interi come: [10, 15, 20, 25, 30, 35, 40]. 
   • Filtrare numeri che sono maggiori di 20. 2.
   • Eleva al quadrato i numeri restanti.
   • Calcola la somma totale di questi quadrati utilizzando reduce()
3. Creare una lista di studenti (classe/record Studente con attributi nome (String), media (Double) ). Creare una lista di nomi di studenti che hanno la media >= 6.
4. Data una lista come la seguente [5, 3, 8, 5, 2, 10, 8, 1] restituire una lista senza duplicati ordinata in modo decrescente.
5. Da una lista di parole ["Lezioni", "di", "Java", "Stream"] stampare una stringa unica separata da spazi usando reduce().