I codici dei test QuestBase da svolgere come preparazione alle interrogazioni sono i seguenti
Test su JAVA
26 mercoledì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
in26 mercoledì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inI codici dei test QuestBase da svolgere come preparazione alle interrogazioni sono i seguenti
19 mercoledì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe Centralino
per la gestione di un centralino telefonico. Un centralino è caratterizzata dal nome (ad esempio INFOTEL), dal numero di chiamate ricevute, dalla durata totale delle chiamate ricevute, dal numero di chiamate effettuate, dalla durata totale delle chiamate effettuate.
Si prevedano le opportune variabili di istanza della classe Centralino
in base alla descrizione fornita, ponendo attenzione al loro tipo.
Prevedere un costruttore che crea un centralino; il costruttore deve ricevere in ingresso il nome del centralino e inizializzare in modo opportuno le altre variabili di istanza.
1) Definire un metodo riceviChiamata
che riceve in ingresso la durata della chiamata ricevuta. Il metodo visualizzerà le righe
“Ricevuta chiamata.”
“Durata della chiamata = ????”
“Totale chiamate ricevute = ????”
2) Definire un metodo effettuaChiamata
che riceve in ingresso la durata della chiamata effettuata. Il metodo visualizzerà le righe
“Effettuata chiamata.”
“Durata della chiamata = ????”
“Totale chiamate effettuate = ????”
3) Definire un metodo visualizzaCentralino
che visualizza lo stato corrente del centralino nella seguente forma:
*******************************************
Nome centralino: ??????
Totale chiamate ricevute: ?????
Durata chiamate ricevute: ?????
Totale chiamate effettuate: ?????
Durata chiamate effettuate: ?????
*******************************************
Definire una classe CentralinoPrincipale
per verificare il funzionamento dei metodi definiti. In particolare le istruzioni da codificare all’interno del metodo main
sono le seguenti:
12 mercoledì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe ChiavettaUSB
per la gestione di una chiavetta USB. Una chiavetta USB è caratterizzata dal nome (ad esempio LEXAR), dalla memoria totale in GB, dal numero di file memorizzati, dallo spazio occupato.
Si prevedano le opportune variabili di istanza della classe ChiavettaUSB
in base alla descrizione fornita, ponendo attenzione al loro tipo.
Prevedere un costruttore che crea una chiavetta USB; il costruttore deve ricevere in ingresso il nome della chiavetta e la memoria in GB e inizializzare in modo opportuno le altre variabili di istanza.
1) Definire un metodo aggiungiFiles
che riceve in ingresso due valori corrispondenti rispettivamente al numero di file da inserire nella chiavetta e alla dimensione in MB da essi occupata. Il metodo visualizzerà le righe
“Caricati ???? files.”
“Totale file presenti nella chiavetta = ????”
“Spazio residuo disponibile = ????”
Il metodo dovrà controllare che la dimensione dei file da inserire sia inferiore o uguale allo spazio attualmente disponibile nella chiavetta; in caso contrario visualizzerà il messaggio “Parametri errati!”.
2) Definire un metodo rimuoviFiles
che riceve in ingresso due valori corrispondenti rispettivamente al numero di file da rimuovere dal lettore e alla dimensione in MB da essi occupata. Il metodo visualizzerà le righe
“Rimossi ???? files.”
“Totale file presenti nella chiavetta = ????”
“Spazio residuo disponibile = ????”
Opzionale: Il metodo dovrà controllare che il numero di file da rimuovere sia inferiore o uguale a quello dei file presenti nel lettore e che la dimensione da essi occupata sia inferiore allo spazio attualmente occupato; in caso contrario visualizzerà il messaggio “Parametri errati!”.
3) Definire un metodo visualizzaChiavettaUSB
che visualizza lo stato corrente della chiavetta USB nella seguente forma:
*******************************************
Nome supporto: ??????
Dimensione memoria in GB: ?????
Numero file presenti nella chiavetta: ?????
Spazio attualmente occupato: ?????
Spazio disponibile: ?????
*******************************************
Definire una classe ChiavettaPrincipale
per verificare il funzionamento dei metodi definiti. In particolare le istruzioni da codificare all’interno del metodo main
sono le seguenti:
E’ possibile scaricare il codice completo dai seguenti due collegamenti:
10 lunedì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe LettoreMP3
per la gestione di un lettore MP3. Un lettore MP3 è caratterizzato dalla memoria totale in GB, dalla potenza della batteria espressa da un numero massimo di ore ascoltabili, dal numero di brani caricati, dal livello residuo della batteria espresso in ore di ascolto, dal tempo totale di ascolto.
Si prevedano le opportune variabili di istanza della classe LettoreMP3
in base alla descrizione fornita, ponendo attenzione al loro tipo.
Prevedere un costruttore che crea un lettore MP3; il costruttore deve ricevere in ingresso la memoria in GB, la potenza della batteria e inizializzare in modo opportuno le altre variabili di istanza.
1) Definire un metodo caricaBrani
che riceve in ingresso un intero corrispondente al numero di brani da inserire nel lettore. Il metodo visualizzerà le righe
“Caricati ???? brani.”
“Totale brani presenti nel lettore = ????”
2) Definire un metodo rimuoviBrani
che riceve in ingresso un intero corrispondente al numero di brani da rimuovere dal lettore. Il metodo visualizzerà le righe
“Rimossi ???? brani.”
“Totale brani presenti nel lettore = ????”
Il metodo dovrà controllare che il numero di brani da rimuovere sia inferiore o uguala a quello dei brani presenti nel lettore; in caso contrario visualizzerà il messaggio “Parametri errati!”.
3) Definire un metodo ascoltaBrani
che riceve in ingresso un numero di ore corrispondente al tempo di ascolto (opzionalmente si controlli che tale numero sia inferiore al livello corrente della batteria), decrementa in modo opportuno il livello della batteria e registra le ore ascoltate.
4) Definire un metodo caricaBatteria
che riporta il livello della batteria al massimo valore e visualizza il messaggio:
“Ricarica completata!”
5) Definire un metodo visualizzaLettore
che visualizza lo stato corrente del lettore MP3 nella seguente forma:
****************************************
Dimensione memoria in GB: ?????
Potenza batteria in ore: ?????
Numero brani presenti nel lettore: ?????
Livello residuo batteria: ?????
Tempo totale di ascolto: ?????
****************************************
Definire una classe LettorePrincipale
per verificare il funzionamento dei metodi definiti. In particolare le istruzioni da codificare all’interno del metodo main
sono le seguenti:
E’ possibile scaricare il codice completo dai seguenti due collegamenti:
08 sabato Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe LineaProduzione
per la gestione di una linea di produzione di una fabbrica. Una linea di produzione viene definita da un codice di identificazione (ad esempio “LN001”), dalla produttività oraria espressa in pezzi all’ora (ad esempio 30 pezzi/ora), dal numero di pezzi prodotti, dal numero di pezzi controllati e dal numero di pezzi scartati.
Si prevedano le opportune variabili di istanza della classe LineaProduzione
in base alla descrizione fornita, ponendo attenzione al loro tipo.
Prevedere un costruttore che crea una linea di produzione; il costruttore deve ricevere in ingresso il codice di identificazione della linea, la produttività oraria in pezzi/ora e inizializzare in modo opportuno le altre variabili di istanza.
1) Definire un metodo attivaLinea
che riceve in ingresso un numero intero di ore. Il metodo visualizzerà le righe
“Linea xxx attivata.”
“Tempo esecuzione = ????”
“…….. Produzione terminata.”
“Pezzi Prodotti = ????”
“Pezzi Totali = ????”
e registrerà i pezzi prodotti in base alla produttività oraria. (Ad esempio, se la produttività oraria è di 40 pezzi/ora e la linea lavora per 3 ore verranno registrati 120 pezzi).
2) Definire un metodo controllaProduzione
che riceve in ingresso il numero di pezzi che sono stati controllati dagli addetti al controllo della qualità e il numero di pezzi che sono stati scartati per difetti di produzione. Il metodo dovrà naturalmente controllare che il numero di pezzi controllati passato come parametro sia superiore a quello dei pezzi scartati e stampare l’avviso “Parametri errati” in caso contrario. Opzionalmente si può controllare che il numero di pezzi controllati sia inferiore o uguale al numero di pezzi totali meno quelli già controllati.
3) Definire un metodo visualizzaLinea
che presenta le informazioni sullo stato della linea di produzione nella seguente forma:
**********************************
Identificativo linea: ?????
Produttività in pezzi/ora: ?????
Pezzi totali prodotti: ?????
Pezzi controllati: ?????
Pezzi scartati: ?????
**********************************
Definire una classe LineaPrincipale
per verificare il funzionamento dei metodi definiti. In particolare le istruzioni da codificare all’interno del metodo main
sono (almeno) le seguenti:
07 venerdì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe Autovettura
per la gestione di una autovettura. Una autovettura viene definita da una marca (ad esempio “Fiat”), dal numero di kilometri percorsi, dalla quantità di benzina presente nel serbatoio in un dato istante, dal consumo di benzina (espresso in km/litro), dalla capacità di benzina nel serbatoio (ad esempio 42 litri).
Si prevedano le opportune variabili di istanza della classe Autovettura
in base alla descrizione fornita, ponendo attenzione al loro tipo.
Prevedere un costruttore che crea una autovettura; il costruttore deve ricevere in ingresso la marca dell’autovettura, il consumo di benzina in km/litro e la capacità del serbatoio e inizializzare in modo opportuno le altre variabili di istanza.
1) Definire un metodo faiBenzina
che riceve in ingresso la quantità di carburante da inserire nel serbatoio. Sarà possibile riempire il serbatoio solo fino alla sua capacità massima. Il metodo visualizzerà le righe
“Rifornimento effettuato.”
“Litri di carburante caricati = ????”
“Litri presenti nel serbatoio = ????”
2) Definire un metodo muoviAutovettura
che riceve in ingresso il valore corrispondente ai kilometri che si vuole far percorrere all’autovettura. Il metodo dovrà naturalmente calcolare la nuova quantità di benzina presente nel serbatoio in base al consumo previsto dall’autovettura (ad esempio, se il consumo è di 15 km/litro e la macchina si muove per 45 kilometri allora la quantità di benzina deve diminuire di 3 litri). Dovrebbero essere gestiti i controlli relativi ai km massimi percorribili in base alla quantità di benzina presente nel serbatoio; se volete potete ignorarli e consentire che la quantità di benzina presente nel serbatoio possa anche diventare negativa!
3) Definire un metodo visualizzaAutovettura
che presenta le informazioni sullo stato dell’autovettura nella seguente forma:
**********************************
Marca Autovettura: ?????
Consumo in km/litro: ?????
Capacità Serbatoio: ?????
Carburante Presente: ?????
Kilometri Percorsi: ?????
**********************************
Definire una classe AutoPrincipale
per verificare il funzionamento dei metodi definiti. In particolare le istruzioni da codificare all’interno del metodo main
sono (almeno) le seguenti:
05 mercoledì Feb 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe Distributore
per la gestione di un distributore di bevande. Il distributore consente di scegliere solo tra due bevande (ad esempio Acqua e Aranciata). Ogni bevanda è caratterizzata da un prezzo unitario e dalla quantità di bottiglie presenti in un dato momento nel distributore. Dovrà essere possibile inserire monete nel distributore e scegliere uno dei due tipi di bevande. Il distributore potrà erogare la bevanda solo se l’importo inserito è uguale o superiore al costo unitario della bevanda. In caso contrario inviterà l’utente a inserire ulteriori monete.
Si prevedano le variabili per i costi unitari delle due bevande, per il numero delle bottiglie di entrambe le bevande presenti nel distributore e per l’importo presente nel distributore (le monete inserite da un utente che vuole comperare una bevanda).
Prevedere un costruttore che crea un distributore; il costruttore deve ricevere in ingresso i costi unitari delle due bevande e inizializzare a 20 la quantità di bottiglie disponibili per ciascuna bevanda. Il costruttore provvede inoltre a inizializzare opportunamente le altre variabili di istanza.
1) Definire un metodo ricaricaDistributore
che riceve in ingresso due interi corrispondenti alla quantità di bottiglie per ciascuna bevanda rispettivamente che devono essere caricate nel distributore. Il metodo visualizzerà le righe
“Ricarica effettuata.”
“N. bottiglie bevanda 1 = ????”
“N. bottiglie bevanda 2 = ????”
(Si supponga che il distributore abbia la capacità di contenere infinite bottiglie di ciascuna bevanda. Chi vuole gestire una versione più complicata del metodo può fare l’ipotesi che la capacità massima del distributore sia di 20 bottiglie per bevanda).
2) Definire un metodo inserisciMonete
che riceve in ingresso il valore corrispondente alla moneta che si vuole inserire (le monete possibili sono quelle da 0,05 – 0,10 – 0,20 – 0,50 – 1,00 euro). Il metodo dovrà visualizzare la stringa
“Il credito ammonta a = ?????”
3) Definire un metodo scegliBevanda
che riceve in ingresso il numero della bevanda che si vuole scegliere (i valori possibili sono quindi 1 o 2). Se l’ammontare inserito è sufficiente per l’acquisto della bevanda il metodo dovrà visualizzare le stringhe
“Erogazione in corso….”
“Preleva la bevanda.”
“Ritira il resto = ?????”
In caso contrario il metodo visualizzerà le righe
“Credito insufficiente per l’acquisto.”
“Inserisci ulteriori monete.”
4) Definire un metodo ritiraResto
senza parametri che semplicemente ritira il resto.
5) Definire un metodo visualizzaStato
che presenta le informazioni sullo stato del distributore nella seguente forma:
**********************************
Numero Bottiglie Bevanda 1: ?????
Costo Bevanda 1: ????
Numero Bottiglie Bevanda 2: ?????
Costo Bevanda 2: ????
Credito Presente: ?????
**********************************
Definire una classe DistributorePrincipale
per verificare il funzionamento dei metodi definiti.
In particolare le istruzioni da codificare all’interno del metodo main
sono (almeno) le seguenti:
E’ possibile scaricare il codice completo dai seguenti due collegamenti:
30 giovedì Gen 2014
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inProgettare la classe CartaCredito
per la gestione di una carta di credito prepagata.
Si prevedano le variabili per l’intestatario della carta, il codice della carta (stringa nel formato AAAA-BBBB-CCCC-DDDD), il saldo corrente della carta, l’importo massimo prelevabile, il numero di ricariche effettuate, il numero di prelievi effettuati.
Prevedere un costruttore che riceve in ingresso il nome dell’intestatario, il codice della carta, l’importo massimo prelevabile e inizializza in modo opportuno l’oggetto creato.
1) Definire un metodo ricaricaCarta
che riceve in ingresso un intero corrispondente all’importo della ricarica da effettuare. Il metodo visualizzerà la stringa
“Ricarica effettuata. Credito Disponibile = ????”
2) Definire un metodo prelevaImporto
che riceve in ingresso un intero corrispondente all’importo del prelievo o della spesa da effettuare. Il metodo dovrà visualizzare la stringa
“Importo superiore al massimo prelevabile”
nel caso in cui l’importo specificato sia superiore all’importo massimo prelevabile previsto per la carta; inoltre, se l’importo specificato è superiore alla disponibilità residua della carta dovrà essere visualizzata la stringa
“Credito insufficiente. Effettuare una ricarica”
Quando il prelievo è possibile si deve visualizzare la stringa
“Prelievo effettuato correttamente. Credito residuo = ???? ”
3) Definire un metodo visualizzaCarta
che presenta le informazioni sullo stato della carta di credito nella seguente forma:
**********************************
Intestatario: ?????
Numero Carta : ****-****-****-????
Massimale: ??????
Credito Residuo: ?????
Numero Prelievi Effettuati: ?????
Numero Ricariche Effettuate: ?????
**********************************
Per il numero della carta di credito devono essere stampate solo le ultime quattro cifre.
Definire una classe CartaPrincipale
per verificare il funzionamento dei metodi definiti.
E’ possibile scaricare il codice completo dai seguenti due collegamenti:
11 sabato Gen 2014
Posted Eserc. 2E, 2F, 2I, Esercitazioni
inEcco i link al questionario utile per la preparazione alla verifica/interrogazione sul linguaggio JAVA e il link al compito in classe.
06 venerdì Dic 2013
Posted Eserc. 2E, 2F, 2I, Eserc. 3E, Eserc. 4F, Esercitazioni
inIn questo articolo ancora qualche esercizio di programmazione in JAVA da svolgere per casa in vista della prossima verifica.
Scrivere un programma JAVA EquazioniPrimoGrado che legge da tastiera due numeri, non necessariamente interi, che rappresentano i coefficienti a, b
di una equazione di primo grado nella forma ax=b
e visualizza in uscita la soluzione dell’equazione, se questa esiste, altrimenti visualizza la scritta “Equazione Impossibile” oppure “Equazione Indeterminata” a seconda del caso.
Suggerimento: Ricordo che l’equazione ax = b
ha soluzione (quale?) se e solo se a
è diverso da 0. Se a
e b
sono entrambi 0 l’equazione è indeterminata mentre se a
è 0 e b
è diverso da 0 l’equazione è impossibile. Usare istruzioni if
per gestire i diversi casi.
Scrivere un programma JAVA Ipotenusa che legge da tastiera tre numeri, non necessariamente interi, e verifica se corrispondono alle misure dei tre lati di un triangolo rettangolo; in caso affermativo visualizza in uscita il valore dell’ipotenusa e altrimenti visualizza il messaggio “Misure dei lati non corrette”.
Suggerimento: Attenzione che i numeri possono essere inseriti non in ordine di grandezza.
Scrivere un programma JAVA PuntoMedio che legge da tastiera quattro numeri, non necessariamente interi, corrispondenti alle coordinate dei punti e , e visualizza in uscita le coordinate del punto medio nella forma “Punto medio M=(m_1,m_2)”.
Suggerimento: Ricordo che, dati i punti e , le coordinate del punto medio sono date da .
Scrivere un programma JAVA TestDivisione che legge da tastiera un numero intero e visualizza in uscita tutti i numeri compresi tra 1 e 100 che sono divisibili per il numero inserito.
Suggerimento: Utilizzare un ciclo for
e l’operatore %
.
Scrivere un programma JAVA TestDivisioneCasuale che legge da tastiera un numero intero, genera 30 numeri casuali compresi tra 1 e 100 e visualizza in uscita il numero di essi che risultano divisibili per il numero inserito.
Suggerimento: Come per l’esercizio precedente utilizzare un ciclo for
e l’operatore %
; definire anche una variabile che “conta” il numero cercato.