AgendaGiornaliera.java
Created with JBuilder
class AgendaGiornaliera {
// Assumo che gli appuntamenti non possano avere durata inferiore
// alla mezz'ora e che la giornata lavorativa vada dalle 9 alle 17,
// quindi posso avere 16 appuntamenti al massimo
public static final Tempo DURATA_MIN = new Tempo(0,30);
public static final Tempo INIZIO_GIORNATA = new Tempo(9,0);
public static final Tempo FINE_GIORNATA = new Tempo(17,0);
public static final int NUMERO_MAX_APPUNTAMENTI = 16;
// Attributi dell'agenda
private Appuntamento[] elencoAppuntamenti;
private int numeroAppuntamenti;
// Costruttore
public AgendaGiornaliera( ) {
elencoAppuntamenti = new Appuntamento[NUMERO_MAX_APPUNTAMENTI];
numeroAppuntamenti = 0;
}
// Per essere inserito l'appuntamento deve:
// 1 - avere durata maggiore o uguale alla mezz'ora
// 3 - non iniziare prima delle 9.00 o finire dopo le 17.00
// 2 - non sovrapporsi con altri appuntamenti inseriti
public boolean inserisciAppuntamento(Appuntamento a) {
Tempo durata = a.restituisciDurata();
// Controllo sulla durata
if (durata.minoreDi(DURATA_MIN)) {
return false;
} else {
Tempo fine = a.resituisciOrarioFine();
Tempo inizio = a.resituisciOrario();
// Controllo sull'orario di lavoro
if (inizio.minoreDi(INIZIO_GIORNATA) ||
fine.maggioreDi(FINE_GIORNATA)) {
return false;
} else {
// Controllo sulle sovrapposizioni
for (int i = 0; i < numeroAppuntamenti; i++) {
Tempo fine2 = elencoAppuntamenti[i].resituisciOrarioFine();
Tempo inizio2 = elencoAppuntamenti[i].resituisciOrario();
if ((fine.maggioreDi(inizio2) && fine.minoreDi(fine2)) ||
(inizio.maggioreDi(inizio2) && inizio.minoreDi(fine2))) {
return false;
}
}
// Non vi sono sovrapposizioni, l'appuntamento è inserito
elencoAppuntamenti[numeroAppuntamenti] = a;
++numeroAppuntamenti;
return true;
}
}
}
// Ricerca di un appuntamento
public Persona cercaAppuntamentoPerNome(String nome) {
for (int i = 0; i < numeroAppuntamenti; i++) {
String nomeTrovato =
elencoAppuntamenti[i].restituisciPersona().restituisciNome();
if (nomeTrovato.equals(nome)) {
return elencoAppuntamenti[i].restituisciPersona();
}
}
return null;
}
// Cancellazione di un appuntamento
public boolean cancellaAppuntamentoPerNome(String nome) {
for (int i = 0; i < numeroAppuntamenti; i++) {
String nomeTrovato =
elencoAppuntamenti[i].restituisciPersona().restituisciNome();
if (nomeTrovato.equals(nome)) {
elencoAppuntamenti[i] = elencoAppuntamenti[numeroAppuntamenti - 1];
--numeroAppuntamenti;
return true;
}
}
return false;
}
// Ricerca appuntamenti dopo una certa ora
public AgendaGiornaliera cercaAppuntamentiPerOrario(Tempo orario) {
AgendaGiornaliera estratto = new AgendaGiornaliera( );
for (int i = 0; i < numeroAppuntamenti; i++) {
Tempo orarioTrovato = elencoAppuntamenti[i].resituisciOrario();
if (orarioTrovato.maggioreDi(orario)) {
estratto.inserisciAppuntamento(elencoAppuntamenti[i]);
}
}
return estratto;
}
}
ApplicazioneRubrica.java
Created with JBuilder
class ApplicazioneRubrica {
public static final int NUMERO_MAX_INIZIALE = 100;
public static void main(String[] args) {
Rubrica rubrica = new Rubrica(NUMERO_MAX_INIZIALE);
InterfacciaRubrica interfaccia = new InterfacciaRubrica(rubrica);
interfaccia.esegui();
}
}
Appuntamento.java
Created with JBuilder
class Appuntamento {
private Tempo orario;
private Tempo durata;
private Persona persona;
private String descrizione;
public Appuntamento(Tempo orario, Tempo durata,
Persona persona, String descrizione) {
this.orario = orario;
this.durata = durata;
this.persona = persona;
this.descrizione = descrizione;
}
public Tempo resituisciOrario() {
return orario;
}
public Tempo restituisciDurata() {
return durata;
}
public Tempo resituisciOrarioFine() {
Tempo t = new Tempo(orario);
t.somma(durata);
return t;
}
public Persona restituisciPersona() {
return persona;
}
public String restituisciDescrizione() {
return descrizione;
}
}
AreaRettangolo.java
Created with JBuilder
import javabook.*;
class AreaRettangolo {
public static void main(String[] args) {
// Dichiaro base, altezza e area
int base, altezza, area;
// Creo gli oggetti per IO
MainWindow finestra = new MainWindow();
InputBox inDati = new InputBox(finestra);
OutputBox uDati = new OutputBox(finestra);
finestra.show();
// Chiedere base e altezza
base = inDati.getInteger("Inserisci la base");
altezza = inDati.getInteger("Inserisci l'altezza");
// Calcolo l'area del rettangolo
area = base * altezza;
// Visualizzare il risultato
uDati.print("L'area del rettangolo è ");
uDati.print(area);
uDati.show();
}
}
CalcolatoreBinario.java
Created with JBuilder
class CalcolatoreBinario {
// Attributi per la gestione della memoria
private long memoria;
private long ultimoRisultato;
// Attributo per la segnalazione di errori in fase di conversione
private boolean erroreConversione;
// Costruttore
public CalcolatoreBinario() {
memoria = 0;
erroreConversione = false;
}
///////////////////////////////////////////////////////////////////////////
// Metodi per le operazioni aritmetiche
///////////////////////////////////////////////////////////////////////////
public String somma(String a, String b) {
long x = daBinario(a);
long y = daBinario(b);
return risultato(x + y);
}
public String sottrai(String a, String b) {
long x = daBinario(a);
long y = daBinario(b);
return risultato(x - y);
}
public String moltiplica(String a, String b) {
long x = daBinario(a);
long y = daBinario(b);
return risultato(x * y);
}
public String dividi(String a, String b) {
long x = daBinario(a);
long y = daBinario(b);
// Nota: divisione tra interi!
return risultato(x / y);
}
///////////////////////////////////////////////////////////////////////////
// Metodi per la gestione della memoria
///////////////////////////////////////////////////////////////////////////
public void mettiInMemoria() {
memoria = ultimoRisultato;
}
public void sommaInMemoria() {
memoria += ultimoRisultato;
}
public String richiamaMemoria() {
return aBinario(memoria);
}
public void cancellaMemoria() {
memoria = 0;
}
///////////////////////////////////////////////////////////////////////////
// Metodi private
///////////////////////////////////////////////////////////////////////////
// Questo metodo gestisce il risultato in presenza di eventuali errori
private String risultato(long z) {
if (erroreConversione) {
erroreConversione = false;
return null;
} else {
ultimoRisultato = z;
return aBinario(ultimoRisultato);
}
}
// Conversione da binario a decimale
private long daBinario(String bin) {
// Priva bin di tutti gli eventuali spazi in cima e in fondo
String binEsatto = bin.trim();
// La lunghezza di binEsatto è ora pari al numero di cifre significative
int cifreSignificative = binEsatto.length();
long dec = 0;
// Scorre binEsatto da sinistra (bit più significativo) a destra
// (bit meno significativo), cioè dall'inizio alla fine della stringa
for (int i = 0; i < cifreSignificative; i++) {
if (binEsatto.charAt(i) != '1' && binEsatto.charAt(i) != '0') {
// Se il carattere non è 1 oppure 0, segnala un errore di conversione
erroreConversione = true;
return dec;
} else if (binEsatto.charAt(i) == '1') {
// Un '1' in posizione p a partire da sinistra vale
// 2^(cifresignificative - i)
dec += Math.round(Math.pow(2,(cifreSignificative - i - 1)));
}
}
return dec;
}
// Conversione da decimale a binario
private String aBinario(long dec) {
StringBuffer bin = new StringBuffer("");
while (dec > 0) {
if ((dec % 2) == 1) {
bin.append(1);
} else {
bin.append(0);
}
dec /= 2;
}
if (bin.length() == 0) {
bin.append(0);
} else {
// Nota: bin contiene il numero binario con le cifre meno significative
// a sinistra (sono le prime ad essere inserite): è necessario rovesciarlo
bin.reverse();
}
return bin.toString();
}
}
CalcoloInteressi.java
Created with JBuilder
import javabook.*;
class CalcoloInteressi {
public static void main(String[] args) {
// Dichiaro le variabili necessarie: capitale, tasso, ecc.
float capitale, tasso, durata, interessi, montante;
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Calcolo di interessi");
InputBox richiestaDati = new InputBox(finestra, "Inserimento Dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Richiedo i dati necessari a risolvere il problema
capitale = richiestaDati.getFloat("Inserisci il capitale ");
tasso = richiestaDati.getFloat("Inserisci il tasso di interesse ");
durata = richiestaDati.getFloat("Inserisci la durata ");
// Calcolo interessi e montante
interessi = capitale * tasso * durata / 100;
montante = capitale + interessi;
// Visualizzo i risultati
uscitaDati.print("Gli interessi maturati sono: ");
uscitaDati.printLine(interessi);
uscitaDati.print("Il montante è: ");
uscitaDati.printLine(montante);
uscitaDati.show();
}
}
ConteggioParole.java
Created with JBuilder
// Questa classe contiene diversi metodi per il conteggio di parole
// in una frase contenuta in un oggetto String
// - contaParole: la procedura per il conteggio delle parole mostrata
//
nell'unità didattica 4 (ha il problema che il conteggio parole è
//
sbagliato se la frase contiene spazi in fondo)
// - contaParoleTrim: una soluzione corretta al conteggio delle parole
//
in una frase che utilizza il metodo trim della classe String
// - contaParoleNoTrim: una soluzione corretta al conteggio
//
delle parole in una frase che *non* utilizza il metodo trim di String
// - contaParoleECaratteri: conteggio di parole e caratteri alfabetici
// - cercaNumeroDi: ricerca del numero di occorrenze di un dato carattere
// - cercaNumeroDiIndexOf: come sopra, con l'utilizzo del metodo indexOf
//
della classe String
import javabook.*;
class ConteggioParole {
// Oggetti per l'IO
private static MainWindow finestra;
private static InputBox richiestaDati;
private static OutputBox uscitaDati;
// La frase richiesta in ingresso su cui eseguire i metodi
private static String frase;
public static void main(String[] args) {
// Inizializzo gli oggetti per l'IO e la frase da manipolare
inizializzaIO();
inizializzaFrase();
// Creo uno StringBuffer per contenere i risultati dell'analisi
StringBuffer risultati = new StringBuffer("");
risultati.append("Hai inserito la frase: " + frase + "\n");
risultati.append("che consta di " + frase.length() + " caratteri.\n");
// Ogni metodo restituisce un messaggio
risultati.append(contaParole());
risultati.append(contaParoleTrim());
risultati.append(contaParoleNoTrim());
risultati.append(contaParoleECaratteri());
// Non c'è un metodo di InputBox per richiedere un carattere
// Chiedo una String e poi prendo solo il primo carattere
String temp = richiestaDati.getString("Inserisci un carattere: ");
char c = temp.charAt(0);
// Invoco gli ultimi due metodi (che necessitano di c)
risultati.append(contaNumeroDi(c));
risultati.append(contaNumeroDiIndexOf(c));
// Mostro i risultati (il metodo print accetta uno StringBuffer)
uscitaDati.print(risultati);
uscitaDati.show();
}
// Metodo di conteggio delle parole (base)
private static String contaParole() {
int nc = frase.length();
int indice = 0, numeroParole = 0;
while (indice < nc) {
// ignora gli spazi bianchi
while ((indice < nc) && (frase.charAt(indice) == ' ')) {
indice++;
}
// trova la fine della parola
while ((indice < nc) && (frase.charAt(indice) != ' ')) {
indice++;
}
// un'altra parola trovata, incremento del contatore
numeroParole++;
}
return ("(contaParole) Numero di parole: " + numeroParole + "\n");
}
// Conteggio parole corretto con l'uso di trim
private static String contaParoleTrim() {
String temp = frase.trim();
int nc = temp.length();
int indice = 0, numeroParole = 0;
while (indice < nc) {
// ignora gli spazi bianchi
while ((indice < nc) && (temp.charAt(indice) == ' ')) {
indice++;
}
// trova la fine della parola
while ((indice < nc) && (temp.charAt(indice) != ' ')) {
indice++;
}
// un'altra parola trovata, incremento del contatore
numeroParole++;
}
return ("(contaParoleTrim) Numero di parole: " + numeroParole + "\n");
}
// Conteggio parole corretto senza l'uso di trim
private static String contaParoleNoTrim() {
int nc = frase.length();
int indice = 0, numeroParole = 0;
while (indice < nc) {
// ignora gli spazi bianchi
while ((indice < nc) && (frase.charAt(indice) == ' ')) {
indice++;
}
// Controllo aggiuntivo per evitare l'incremento del
// numero di parole in presenza di spazi a fine frase
if (indice < nc) {
// trova la fine della parola
while ((indice < nc) && (frase.charAt(indice) != ' ')) {
indice++;
}
// un'altra parola trovata, incremento del contatore
numeroParole++;
}
}
return ("(contaParoleNoTrim) Numero di parole: " +
numeroParole + "\n");
}
// Conteggio di parole e caratteri
private static String contaParoleECaratteri() {
String temp = frase.trim();
int nc = temp.length();
int indice = 0, numeroParole = 0, numeroCaratteri = 0;
while (indice < nc) {
// ignora gli spazi bianchi
while ((indice < nc) && (temp.charAt(indice) == ' ')) {
indice++;
}
// trova la fine della parola
while ((indice < nc) && (temp.charAt(indice) != ' ')) {
char c = temp.charAt(indice);
if ((c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z')) {
// un'altro carattere trovato, incremento del contatore
numeroCaratteri++;
}
indice++;
}
// un'altra parola trovata, incremento del contatore
numeroParole++;
}
return ("(contaParoleECaratteri) Numero di parole: " + numeroParole +
" Numero di caratteri: " + numeroCaratteri + "\n");
}
// Questo metodo cerca il numero di occorrenze di un dato carattere
private static String contaNumeroDi(char c) {
int numeroOccorrenze = 0;
for(int i = 0; i < frase.length(); ++i) {
if (frase.charAt(i) == c) {
++numeroOccorrenze;
}
}
return ("(contaNumeroDi) Il numero di occorrenze del carattere " + c +
" è pari a: " + numeroOccorrenze + "\n");
}
// Questo metodo cerca il numero di occorrenze di un dato carattere
// usando il metodo indexOf della classe String
private static String contaNumeroDiIndexOf(char c) {
int numeroOccorrenze = 0;
int posizione = frase.indexOf(c);
while (posizione >= 0) {
++numeroOccorrenze;
posizione = frase.indexOf(c,posizione + 1);
}
return ("(contaNumeroDiIndexOf) Il numero di occorrenze del carattere "
+ c + " è pari a: " + numeroOccorrenze + "\n");
}
// Questo metodo crea gli oggetti necessari per gli IO
// e li memorizza nei relativi attributi. Rende inoltre visibile
// la finestra dell'applicazione
private static void inizializzaIO() {
// Dichiaro e creo gli oggetti necessari per l'IO
finestra = new MainWindow("Elaborazione testi");
richiestaDati = new InputBox(finestra, "Inserimento dati");
uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
}
// Questo metodo richiede i coefficienti e crea il polinomio
private static void inizializzaFrase() {
// Richiedo la frase su cui eseguire le elaborazioni
frase = richiestaDati.getString("Inserisci una frase: ");
}
}
ContoCorrente.java
Created with JBuilder
// Questa è la realizzazione di base della classe ContoCorrente
// Rispetto alla classe definita nelle dispense ha in più
// un costruttore che garantisce l'inizializzazione corretta del saldo
class ContoCorrente {
// Lo stato è rappresentato solo dal saldo
private double saldo;
// Costruttore elementare
public ContoCorrente() {
saldo = 0;
}
// Metodo per depositare somme
public void deposita( double somma ) {
saldo = saldo + somma;
}
// Metodo per prelevare somme
public double preleva( double somma ) {
saldo = saldo - somma;
return somma;
}
// Metodo per ottenere il saldo
public double ottieniSaldo() {
return saldo;
}
}
ContoCorrente2.java
Created with JBuilder
// Questa versione di ContoCorrente consente la gestione
// di una commissione percentuale sulle operazioni
// L'ammontare della commissione è soggetto a negoziazione
class ContoCorrente2 {
// Lo stato è rappresentato dal saldo e dal valore della commissione
private double saldo;
private double commissione;
// Costruttore
// Consente la corretta inizializzazione della commissione
public ContoCorrente2( double tasso ) {
saldo = 0;
commissione = tasso;
}
// Metodo per depositare somme (tiene conto della commissione)
public void deposita( double somma ) {
saldo = saldo + somma;
saldo = saldo - (somma * commissione);
}
// Metodo per prelevare somme (tiene conto della commissione)
public double preleva( double somma ) {
saldo = saldo - (somma + somma * commissione);
return somma;
}
// Metodo per ottenere il saldo
public double ottieniSaldo() {
return saldo;
}
// Metodi per impostare e ottenere la commissione
public void impostaCommissione( double tasso ) {
commissione = tasso;
}
public double restituisciCommissione() {
return commissione;
}
}
ContoCorrente3.java
Created with JBuilder
// Questa versione di ContoCorrente è identica per funzionalità
// a ContoCorrente2, ma supporta costruttori multipli
class ContoCorrente3 {
// Lo stato è rappresentato dal saldo e dal valore della commissione
private double saldo;
private double commissione;
// Costruttori
public ContoCorrente3() {
saldo = 0;
commissione = 0;
}
public ContoCorrente3( double tasso ) {
saldo = 0;
commissione = tasso;
}
public ContoCorrente3( double somma, double tasso ) {
saldo = somma;
commissione = tasso;
}
// Metodo per depositare somme (tiene conto della commissione)
public void deposita( double somma ) {
saldo = saldo + somma;
saldo = saldo - (somma * commissione);
}
// Metodo per prelevare somme (tiene conto della commissione)
public double preleva( double somma ) {
saldo = saldo - (somma + somma * commissione);
return somma;
}
// Metodo per ottenere il saldo
public double ottieniSaldo() {
return saldo;
}
// Metodi per impostare e ottenere la commissione
public void impostaCommissione( double tasso ) {
commissione = tasso;
}
public double restituisciCommissione() {
return commissione;
}
}
ContoCorrente4.java
Created with JBuilder
// In questa versione di ContoCorrente viene utilizzato un
// attributo static (numeroConti) per tenere traccia del numero
// di conti correnti aperti
class ContoCorrente4 {
// Attributo condiviso fra tutti gli oggetti
private static int numeroConti = 0;
private double saldo;
private double commissione;
// numeroConti deve essere incrementato di 1
// ogni volta che si crea un nuovo oggetto ContoCorrente
public ContoCorrente4( double tasso ) {
saldo = 0;
commissione = tasso;
numeroConti = numeroConti + 1;
}
// Metodo static per l'interrogazione sul numero di conti aperti
public static int ottieniContiAperti( ) {
return numeroConti;
}
// Gli altri metodi sono realizzati come in ContoCorrente2 e ContoCorrente3
public void deposita( double somma ) {
saldo = saldo + somma;
saldo = saldo - (somma * commissione);
}
public double preleva( double somma ) {
saldo = saldo - (somma + somma * commissione);
return somma;
}
public double ottieniSaldo() {
return saldo;
}
public void impostaCommissione( double tasso ) {
commissione = tasso;
}
public double restituisciCommissione() {
return commissione;
}
}
ContoCorrente5.java
Created with JBuilder
// Questa versione di ContoCorrente supporta una commissione
// fissa e non negoziabile dello 0.6% per tutti i conti correnti
class ContoCorrente5 {
public static final double commissione = 0.006;
// Lo stato è rappresentato dal saldo e dal valore della commissione
private double saldo;
// Costruttori
public ContoCorrente5() {
saldo = 0;
}
public ContoCorrente5( double somma ) {
saldo = somma;
}
// Metodo per depositare somme (tiene conto della commissione)
public void deposita( double somma ) {
saldo = saldo + somma;
saldo = saldo - (somma * commissione);
}
// Metodo per prelevare somme (tiene conto della commissione)
public double preleva( double somma ) {
saldo = saldo - (somma + somma * commissione);
return somma;
}
// Metodo per ottenere il saldo
public double ottieniSaldo() {
return saldo;
}
// Metodi per ottenere la commissione (non è possibile
// impostare il valore di una costante!)
public double restituisciCommissione() {
return commissione;
}
}
ContoCorrente6.java
Created with JBuilder
//
//
//
//
//
Questa versione di conto corrente prevede l'utilizzo
di due attributi di tipo long per rappresentare il
saldo del conto distinto in euro e in centesimi di euro
L'interfaccia della classe, ossia l'insieme dei metodi
public, è la stessa di ContoCorrente (versione base)
class ContoCorrente6 {
// Lo stato è rappresentato solo dal saldo
// diviso nelle componenti euro e centesimi
private long saldoEuro;
private long saldoCentesimi;
// Costruttore elementare
public ContoCorrente6() {
saldoEuro = 0;
saldoCentesimi = 0;
}
// Costruttore aggiuntivo: consente di inizialiazzare
// separatamente euro e centesimi di euro
public ContoCorrente6( long euro, long centesimi ) {
saldoEuro = euro;
saldoCentesimi = centesimi;
}
// Metodo per depositare somme
public void deposita( double somma ) {
// Separare parte intera e parte decimale
// Math.floor tronca la parte decimale di somma
// Math.round arrotonda un double in un long
long sommaEuro = Math.round(Math.floor(somma));
long sommaCentesimi =
Math.round((somma - (double)sommaEuro) * 100);
// Sommare le due parti al saldo
saldoEuro += sommaEuro;
saldoCentesimi += sommaCentesimi;
// Gestire il riporto: se la somma in centesimi
// è maggiore di 100, allora sottraiamo 100,
// lasciamo la differenza nei centesimi e aggiungiamo un euro
if (saldoCentesimi > 100) {
saldoCentesimi -= 100;
++saldoEuro;
}
}
// Metodo per prelevare somme
public double preleva( double somma ) {
// Separare parte intera e parte decimale
long sommaEuro = Math.round(Math.floor(somma));
long sommaCentesimi =
Math.round((somma - (double)sommaEuro) * 100);
// Sottrarre le due parti al saldo
saldoCentesimi -= sommaCentesimi;
saldoEuro -= sommaEuro;
// Gestire il riporto: se la somma in centesimi
// è minore di 0, allora aggiungiamo 100,
// lasciamo la somma nei centesimi e togliamo un euro
if (saldoCentesimi < 0) {
saldoCentesimi += 100;
--saldoEuro;
}
return somma;
}
// Metodo per ottenere il saldo
public double ottieniSaldo() {
return (double)saldoEuro +
(double)saldoCentesimi / (double)100;
}
}
DistributoreAutomatico.java
Created with JBuilder
class DistributoreAutomatico {
//////////////////////////////////////////////////////////////////////////
// Attributi costanti
//////////////////////////////////////////////////////////////////////////
// Le bevande disponibili
public static final int CHINOTTO
= 0;
public static final int ARANCIATA = 1;
public static final int THE_FREDDO = 2;
// Le monete inseribili
public static final int CINQUE
= 5;
public static final int DIECI
= 10;
public static final int CINQUANTA = 50;
// Il costo di una bevanda
public static final int COSTO_BEVANDA = 55;
// Segnalazione di errata chiave elettronica
public static final int ERRORE = -1;
//////////////////////////////////////////////////////////////////////////
// Attributi variabili comuni a tutte le istanze
//////////////////////////////////////////////////////////////////////////
// La somma totale contenuta nelle casse
// di tutti i distributori (euro e centesimi di euro)
private static int introitoEuro = 0;
private static int introitoCentesimi = 0;
//////////////////////////////////////////////////////////////////////////
// Attributi dell'oggetto distributore
//////////////////////////////////////////////////////////////////////////
// Le quantità disponibili per le varie bibite
private int numeroChinotti;
private int numeroAranciate;
private int numeroThe;
// Il credito utilizzabile dall'utente (in centesimi)
private int creditoUtente;
// La somma totale contenuta nel distributore (in centesimi)
private int introitoDistributore;
// Chiave elettronica di accesso al distributore (per la
// ricarica delle bevande e l'interrogazione dell'introito)
private int chiaveElettronica;
//////////////////////////////////////////////////////////////////////////
// Costruttori
//////////////////////////////////////////////////////////////////////////
// Questo costruttore consente di impostare una chiave elettronica
// per l'autorizzazione alle operazioni di ricarica e interrogazione
// del saldo del distributore
public DistributoreAutomatico(int chiaveElettronica) {
numeroChinotti = numeroAranciate = numeroThe = 0;
creditoUtente = 0;
introitoDistributore = 0;
this.chiaveElettronica = chiaveElettronica;
}
//////////////////////////////////////////////////////////////////////////
// Interfaccia per l'utente
//////////////////////////////////////////////////////////////////////////
// Metodo per inserire monete
// Restituisce false se la moneta inserita non è accettata
public boolean inserisciMonete(int moneta, int quantità) {
switch (moneta) {
case CINQUE :
case DIECI :
case CINQUANTA :
creditoUtente += moneta * quantità;
return true;
default : return false;
}
}
// Restituzione delle monete inserite: il credito viene azzerato
public void restituisciMonete() {
creditoUtente = 0;
}
// Metodo per ottenere una bevanda
// Restituisce false se il credito non è sufficiente, se la
// selezione della bevanda è errata, oppure se la bevanda
// selezionata è esaurita; true altrimenti
public boolean richiediBevanda(int bevanda) {
if (creditoUtente < COSTO_BEVANDA) {
// Le monete inserite non sono sufficienti a coprire il costo
return false;
} else {
// Le monete inserite coprono il costo, quindi la
// quantità della bevanda selezionata diminuisce di 1
switch (bevanda) {
case CHINOTTO :
if (numeroChinotti > 0) {
--numeroChinotti; break;
} else {
// I chinotti sono esauriti
return false;
}
case ARANCIATA :
if (numeroAranciate > 0) {
--numeroAranciate; break;
} else {
// Le aranciate sono esaurite
return false;
}
case THE_FREDDO :
if (numeroThe > 0) {
--numeroThe; break;
} else {
// I the sono esauriti
return false;
}
default : return false;
}
// La bevanda è stata selezionata correttamente
// quindi è necessario aggiornare il credito e l'introito
creditoUtente -= COSTO_BEVANDA;
aggiornaIncasso();
return true;
}
}
//////////////////////////////////////////////////////////////////////////
// Interfaccia per la ditta di servizio (protetta con chiave di accesso)
//////////////////////////////////////////////////////////////////////////
// Metodo per ricaricare il distributore
// Restituisce true se la ricarica è stata eseguita correttamente
// e false nel caso in cui (i) la bevanda non sia stata specificata
// correttamente o (ii) la chiaveElettronica non sia corretta
public boolean ricarica(int chiaveElettronica, int bevanda, int quantità) {
if (chiaveElettronica == this.chiaveElettronica) {
switch (bevanda) {
case CHINOTTO : numeroChinotti += quantità; return true;
case ARANCIATA : numeroAranciate += quantità; return true;
case THE_FREDDO : numeroThe += quantità; return true;
default : return false;
}
} else {
return false;
}
}
// Metodo per interrogare l'incasso del distributore (in centesimi)
// Restituisce ERRORE se la chiave elettronica inserita è scorretta
public int richiediIntroito(int chiaveElettronica) {
if (chiaveElettronica == this.chiaveElettronica) {
return introitoDistributore;
} else {
return ERRORE;
}
}
// Metodo per prelevare l'introito del distributore
// Restituisce ERRORE se la chiave elettronica inserita è scorretta
public int prelevaIntroito(int chiaveElettronica) {
if (chiaveElettronica == this.chiaveElettronica) {
int somma = introitoDistributore + creditoUtente;
introitoDistributore = creditoUtente = 0;
return somma;
} else {
return ERRORE;
}
}
// Metodo per interrogare l'introito totale dei distributori
// Per avere tale importo è sufficiente conoscere la chiave
// elettronica di un solo distributore
// Restituisce ERRORE se la chiave di accesso è scorretta
public double richiediIntroitoTotale() {
if (chiaveElettronica == this.chiaveElettronica) {
return ((double)introitoEuro +
(double)introitoCentesimi / (double)100);
} else {
return ERRORE;
}
}
//////////////////////////////////////////////////////////////////////////
// Metodi private
//////////////////////////////////////////////////////////////////////////
private void aggiornaIncasso() {
// Aggiorna la cassa del distributore (in centesimi)
introitoDistributore += COSTO_BEVANDA;
// Aggiorna l'introito complessivo dei distributori
introitoCentesimi += COSTO_BEVANDA;
if (introitoCentesimi > 100) {
introitoCentesimi -= 100;
++introitoEuro;
}
}
}
Eq2GrRipeti.java
Created with JBuilder
import javabook.*;
class Eq2GrRipeti {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Equazioni di secondo grado");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Ripeto la richiesta coefficienti e il calcolo fino a che
// l'utente desidera calcolare nuove solutioni
int risposta = 1;
while (risposta != 0) {
// Richiedo i coefficienti dell'equazione
double a = richiestaDati.getFloat("Inserisci il valore di a: ");
double b = richiestaDati.getFloat("Inserisci il valore di b: ");
double c = richiestaDati.getFloat("Inserisci il valore di c: ");
if ((a != 0) && (b != 0)) {
// a e b sono diversi da 0, l'equazione è non degenere
// Procedo con il calcolo del discriminante
double delta = Math.pow(b,2) - 4 * a * c;
if (delta > 0) {
// Le soluzioni sono reali e distinte
double x1 = (-b + Math.sqrt(delta)) / (2 * a);
double x2 = (-b - Math.sqrt(delta)) / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(x1);
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(x2);
} else if (delta < 0) {
// Le soluzioni sono complesse coniugate
uscitaDati.printLine("Le soluzioni sono complesse coniugate. ");
} else {
// Le soluzioni sono reali e coincidenti
double x = -b / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(x);
}
} else {
// L'equazione è degenere
uscitaDati.printLine("L'equazione è degenere.");
}
// Visualizza i messaggi
uscitaDati.show();
// Chiedo all'utente se desidera continuare
risposta = richiestaDati.getInteger("0 - Fine, n - Continuo");
} // Fine di while (risposta != 0)
}
// Fine di main
Eq2GrRipetiFissato.java
Created with JBuilder
import javabook.*;
class Eq2GrRipetiFissato {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Equazioni di secondo grado");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Chiedo quante equazioni si desidera risolvere
int ripetizioni = richiestaDati.getInteger("Quante equazioni? ");
for (int i = 0; i < ripetizioni; i++) {
// Richiedo i coefficienti dell'equazione
double a = richiestaDati.getFloat("Inserisci il valore di a: ");
double b = richiestaDati.getFloat("Inserisci il valore di b: ");
double c = richiestaDati.getFloat("Inserisci il valore di c: ");
if ((a != 0) && (b != 0)) {
// a e b sono diversi da 0, l'equazione è non degenere
// Procedo con il calcolo del discriminante
double delta = Math.pow(b,2) - 4 * a * c;
if (delta > 0) {
// Le soluzioni sono reali e distinte
double x1 = (-b + Math.sqrt(delta)) / (2 * a);
double x2 = (-b - Math.sqrt(delta)) / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(x1);
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(x2);
} else if (delta < 0) {
// Le soluzioni sono complesse coniugate
uscitaDati.printLine("Le soluzioni sono complesse coniugate. ");
} else {
// Le soluzioni sono reali e coincidenti
double x = -b / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(x);
}
} else {
// L'equazione è degenere
uscitaDati.printLine("L'equazione è degenere.");
}
// Visualizza i messaggi
uscitaDati.show();
} // Fine di for (int i = 0; i < ripetizioni; i++)
}
// Fine di main
}
Eq2GrSentinella.java
Created with JBuilder
import javabook.*;
class Eq2GrSentinella {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Equazioni di secondo grado");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Richiedo i coefficienti dell'equazione
// NOTA: le variabili sono inizializzate a 0. Questo fa si
//
che il ciclo while di controllo inizi e richieda i dati
double a = 0, b = 0, c = 0;
while (a == 0) {
a = richiestaDati.getFloat("Inserisci il valore di a: ");
}
while (b == 0) {
b = richiestaDati.getFloat("Inserisci il valore di b: ");
}
c = richiestaDati.getFloat("Inserisci il valore di c: ");
// a e b sono diversi da 0, l'equazione è non degenere
// Procedo con il calcolo del discriminante
double delta = Math.pow(b,2) - 4 * a * c;
if (delta > 0) {
// Le soluzioni sono reali e distinte
double x1 = (-b + Math.sqrt(delta)) / (2 * a);
double x2 = (-b - Math.sqrt(delta)) / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(x1);
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(x2);
} else if (delta < 0) {
// Le soluzioni sono complesse coniugate
uscitaDati.printLine("Le soluzioni sono complesse coniugate. ");
} else {
// Le soluzioni sono reali e coincidenti
double x = -b / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(x);
}
// Visualizza i messaggi
uscitaDati.show();
}
// Fine di main
}
Equazione2Grado.java
Created with JBuilder
import javabook.*;
// NOTA: i metodi "sqrt" e "pow" della classe Math, non sono
//
richiamati a partire da un oggetto Math, ma sono
//
richiamati utilizzando la classe stessa. Si tratta
//
di metodi particolari (anche i "main" hanno la stessa
//
proprietà) che sono definiti per un'intera classe
//
e non per il singolo oggetto (si veda l'unità didattica
//
3 per ulteriori approfondimenti).
class Equazione2Grado {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Equazioni di secondo grado");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Richiedo i coefficienti dell'equazione
// NOTA: le variabili sono dichiarate quando servono e inizializzate
//
con il risultato dei metodi "getFloat"
double a = richiestaDati.getFloat("Inserisci il
double b = richiestaDati.getFloat("Inserisci il
double c = richiestaDati.getFloat("Inserisci il
di richiestaDati
valore di a: ");
valore di b: ");
valore di c: ");
if ((a != 0) && (b != 0)) {
// a e b sono diversi da 0, l'equazione è non degenere
// Procedo con il calcolo del discriminante
double delta = Math.pow(b,2) - 4 * a * c;
if (delta > 0) {
// Le soluzioni sono reali e distinte
double x1 = (-b + Math.sqrt(delta)) / (2 * a);
double x2 = (-b - Math.sqrt(delta)) / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(x1);
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(x2);
} else if (delta < 0) {
// Le soluzioni sono complesse coniugate
uscitaDati.printLine("Le soluzioni sono complesse coniugate. ");
} else {
// Le soluzioni sono reali e coincidenti
double x = -b / (2 * a);
// Visualizza le soluzioni
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(x);
}
} else {
// L'equazione è degenere
uscitaDati.printLine("L'equazione è degenere.");
}
// Visualizza i messaggi
uscitaDati.show();
}
// Fine di main
Fattoriale.java
Created with JBuilder
import javabook.*;
class Fattoriale {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("N fattoriale");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Chiedo all'utente il numero di cui desidera calcolare il fattoriale
int numero = richiestaDati.getInteger("Fattoriale del numero? ");
// Inizializzo il fattoriale a 1
int fattoriale = 1;
// Calcolo il fattoriale
for (int i = 1; i <= numero; i++) {
fattoriale *= i;
}
// Visualizzo il risultato
uscitaDati.print("Il fattoriale di ");
uscitaDati.print(numero);
uscitaDati.print(" è ");
uscitaDati.printLine(fattoriale);
uscitaDati.show();
}
}
GestioneCalcolatore.java
Created with JBuilder
import javabook.*;
class GestioneCalcolatore {
// Oggetti per l'IO
private static MainWindow finestra;
private static InputBox richiestaDati;
private static OutputBox uscitaDati;
// Calcolatore binario
private static CalcolatoreBinario calcolatore;
public static void main(String[] args) {
inizializzaIO();
calcolatore = new CalcolatoreBinario();
String espressione = "";
while (!espressione.equalsIgnoreCase("STOP")) {
espressione = richiestaDati.getString("Operazione: ");
espressione = espressione.trim();
if (espressione.equalsIgnoreCase("REGISTRA")) {
calcolatore.mettiInMemoria();
uscitaDati.printLine("Risultato memorizzato.");
} else if (espressione.equalsIgnoreCase("RICHIAMA")) {
uscitaDati.printLine("Memoria: " + calcolatore.richiamaMemoria());
} else if (espressione.equalsIgnoreCase("CANCELLA")) {
calcolatore.cancellaMemoria();
uscitaDati.printLine("Memoria cancellata.");
} else if (espressione.equalsIgnoreCase("SOMMA")) {
calcolatore.sommaInMemoria();
uscitaDati.printLine("Risultato sommato alla memoria.");
} else if (!espressione.equalsIgnoreCase("STOP")) {
// Verifichiamo che si tratti di un'operazione valida e, nel caso,
// eseguiamo l'operazione utilizzando il calcolatore
uscitaDati.printLine(verificaECalcola(espressione));
}
}
// Termina il programma e ritorna il controllo al sistema operativo
System.exit(0);
}
private static String verificaECalcola(String espressione) {
// Cerca il simbolo corrispondente all'operazione aritmetica
int lunghezzaEspressione = espressione.length();
for (int i = 0; i < lunghezzaEspressione; i++) {
char c = espressione.charAt(i);
if (c == '+' || c == '-' || c == '*' || c == '/') {
// Estraggo gli operandi
String op1 = espressione.substring(0, i);
String op2 = espressione.substring(i + 1);
return eseguiOperazione(op1, op2, c);
}
}
// Non è stato trovato alcun operatore, quindi c'è un errore
return ("Errore di sintassi nell'espressione: " + espressione);
}
private static String eseguiOperazione(String op1, String op2, char c) {
String risultato;
switch (c) {
case '+' : risultato = calcolatore.somma(op1, op2); break;
case '-' : risultato = calcolatore.sottrai(op1, op2); break;
case '*' : risultato = calcolatore.moltiplica(op1, op2); break;
case '/' : risultato = calcolatore.dividi(op1, op2); break;
default : risultato = null;
}
if (risultato != null) {
return ("Il risultato dell'operazione è: " + risultato);
} else {
return ("Errore nel calcolo di: " + op1 + c + op2);
}
}
// Questo metodo crea gli oggetti necessari per gli IO
// e li memorizza nei relativi attributi. Rende inoltre visibile
// la finestra dell'applicazione e la finestra dei risultati
private static void inizializzaIO() {
// Dichiaro e creo gli oggetti necessari per l'IO
finestra = new MainWindow("Elaborazione testi");
richiestaDati = new InputBox(finestra, "Inserimento dati");
uscitaDati = new OutputBox(finestra, "Risultati");
// Imposta la visualizzazione di uscitaDati in modo da non
// creare sovrapposizione con richiestaDati
uscitaDati.setLocation(0,0);
// Visualizza un messaggio di aiuto nella finestra dei risultati
uscitaDati.printLine("--- Calcolatore Binario ---");
uscitaDati.printLine("Il calcolatore accetta i seguenti ingressi:");
uscitaDati.printLine("- <num1> <op> <num2> per eseguire <op> tra\n" +
" <num1> e <num2> (<op> a scelta tra +,-,*,/)");
uscitaDati.printLine("- REGISTRA per memorizzare l'ultimo risultato");
uscitaDati.printLine("- RICHIAMA per richiamare la memoria");
uscitaDati.printLine("- CANCELLA per cancellare la memoria");
uscitaDati.printLine("- SOMMA per sommare l'ultimo risultato in memoria");
uscitaDati.printLine("- STOP per terminare il programma\n");
uscitaDati.show();
}
}
GestioneConti.java
Created with JBuilder
import javabook.*;
class GestioneConti {
public static void main(String[] args) {
ContoCorrente4 mioConto = new ContoCorrente4( 0.005 );
ContoCorrente4 tuoConto = new ContoCorrente4( 0.003 );
MainWindow finestra = new MainWindow("Gestione conti correnti");
finestra.show();
OutputBox uscitaDati = new OutputBox(finestra);
uscitaDati.print("Numero conti aperti");
uscitaDati.printLine(tuoConto.ottieniContiAperti());
uscitaDati.show();
}
}
GestionePoli2GrStrutturata.java
Created with JBuilder
// Questa versione della classe GestionePolinomio2Grado
// è identica per funzionalità a quella originale, ma realizza
// una strutturazione del main in sottoprocedure
//
//
//
//
NOTA: tutti gli attributi e i metodi eccetto il main sono
dichiarati private. Nel caso dei metodi questo è necessario perché
eseguono operazioni che hanno senso solo in una specifica sequenza.
Esporli significherebbe perdere la robustezza dell'interfaccia
//
//
//
//
NOTA2: tutti gli attributi e i metodi sono static in quanto
devono poter essere utilizzati a partire da main che è per
definizione un metodo static. In conseguenza di ciò, la classe
GestionePoli2GrStrutturata non è istanziabile.
//
//
//
//
NOTA3: finestra, richiestaDati e uscitaDati sono diventati attributi
in quanto devono essere utilizzati non più solo dentro main
ma anche da inizializzaIO e dai metodi per la visualizzazione.
Stessa considerazione per il polinomio.
//
//
//
//
NOTA4: constatare come, utilizzando la classe Polinomio2Grado per
incapsulare i conti relativi al calcolo delle soluzioni, e la
strutturazione del main in procedure, il metodo main sia diventato
molto più compatto e leggibile
import javabook.*;
class GestionePoli2GrStrutturata {
// Oggetti per
private static
private static
private static
l'IO
MainWindow finestra;
InputBox richiestaDati;
OutputBox uscitaDati;
// Polinomio
private static Polinomio2Grado polinomio;
public static void main(String[] args) {
// Inizializzo IO e il polinomio
inizializzaIO();
inizializzaPolinomio();
// Verifico il tipo di soluzione
int risultato = polinomio.calcolaSoluzioni();
// Seleziono il messaggio da visualizzare
switch (risultato) {
case Polinomio2Grado.SOLUZIONI_REALI :
visualizzaDistinte( polinomio.restituisciSoluzione1(),
polinomio.restituisciSoluzione2());
break;
case Polinomio2Grado.SOLUZIONI_IMMAGINARIE :
visualizzaMessaggio("Le soluzioni sono complesse coniugate. ");
break;
case Polinomio2Grado.SOLUZIONE_UNICA :
visualizzaUnica(polinomio.restituisciSoluzione1());
break;
case Polinomio2Grado.POLINOMIO_DEGENERE :
visualizzaMessaggio("Il polinomio è degenere!");
}
}
// Questo metodo crea gli oggetti necessari per gli IO
// e li memorizza nei relativi attributi. Rende inoltre visibile
// la finestra dell'applicazione
private static void inizializzaIO() {
// Dichiaro e creo gli oggetti necessari per l'IO
finestra = new MainWindow("Equazioni di secondo grado");
richiestaDati = new InputBox(finestra, "Inserimento dati");
uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
}
// Questo metodo richiede i coefficienti e crea il polinomio
private static void inizializzaPolinomio() {
// Richiedo i coefficienti dell'equazione
double a = richiestaDati.getDouble("Inserisci il valore di a: ");
double b = richiestaDati.getDouble("Inserisci il valore di b: ");
double c = richiestaDati.getDouble("Inserisci il valore di c: ");
// Creo un oggetto Poliniomio2Grado
Polinomio2Grado polinomio = new Polinomio2Grado(a, b, c);
}
// Questo metodo serve per visualizzare due soluzioni reali e distinte
private static void visualizzaDistinte( double x1, double x2 ) {
// Soluzioni reali e distinte
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(x1);
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(x2);
uscitaDati.show();
}
// Questo metodo serve per visualizzare una soluzione unica
private static void visualizzaUnica( double x1 ) {
// Soluzioni reali e coincidenti
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(x1);
uscitaDati.show();
}
// NOTA: String è la classe predefinita Java per la gestione
// dei testi (vedi Unità Didattica 4)
private static void visualizzaMessaggio( String messaggio ) {
uscitaDati.printLine(messaggio);
uscitaDati.show();
}
}
GestionePolinomio2Grado.java
Created with JBuilder
import javabook.*;
class GestionePolinomio2Grado {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Equazioni di secondo grado");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Richiedo i coefficienti dell'equazione
double a = richiestaDati.getDouble("Inserisci il valore di a: ");
double b = richiestaDati.getDouble("Inserisci il valore di b: ");
double c = richiestaDati.getDouble("Inserisci il valore di c: ");
// Creo un oggetto Poliniomio2Grado
Polinomio2Grado polinomio = new Polinomio2Grado(a, b, c);
// Verifico il tipo di soluzione
int risultato = polinomio.calcolaSoluzioni();
switch (risultato) {
case Polinomio2Grado.SOLUZIONI_REALI :
// Soluzioni reali e distinte
uscitaDati.printLine("Le soluzioni sono reali e distinte. ");
uscitaDati.print("Il valore di x1 è ");
uscitaDati.printLine(polinomio.restituisciSoluzione1());
uscitaDati.print("Il valore di x2 è ");
uscitaDati.printLine(polinomio.restituisciSoluzione2());
break;
case Polinomio2Grado.SOLUZIONI_IMMAGINARIE :
// Le soluzioni sono complesse coniugate
uscitaDati.printLine("Le soluzioni sono complesse coniugate. ");
break;
case Polinomio2Grado.SOLUZIONE_UNICA :
// Soluzioni reali e coincidenti
uscitaDati.printLine("Le soluzioni sono reali e coincidenti. ");
uscitaDati.print("Il valore di x1,x2 è ");
uscitaDati.printLine(polinomio.restituisciSoluzione1());
break;
case Polinomio2Grado.POLINOMIO_DEGENERE :
// L'equazione è degenere
uscitaDati.printLine("L'equazione è degenere.");
}
// Visualizza i messaggi
uscitaDati.show();
}
}
InterfacciaRubrica.java
Created with JBuilder
import javabook.*;
class InterfacciaRubrica {
// Attributi relativi all'interfaccia grafica
private MainWindow
finestra;
private ListBox
menu;
private MultiInputBox scheda;
private InputBox
richiesta;
private OutputBox
uscita;
private MessageBox
messaggio;
// Attributo relativo alla rubrica da gestire
private Rubrica rubrica;
// Costruttore dell'interfaccia grafica. L'oggetto rubrica è
// già stato creato all'esterno
public InterfacciaRubrica(Rubrica rubrica) {
this.rubrica = rubrica;
// Imposta la finestra principale, un InputBox e un OutputBox
finestra = new MainWindow("Gestione rubrica");
finestra.show();
richiesta = new InputBox(finestra, "Richiesta Dati");
uscita = new OutputBox(finestra, "Visualizzazione Risultati");
messaggio = new MessageBox(finestra);
// Crea la scheda per l'inserimento di un nominativo
String[] etichette = {"Nome", "Indirizzo", "Civico", "Telefono"};
scheda = new MultiInputBox(finestra, etichette);
scheda.setTitle("Scheda persona");
// Crea il menu principale
String[] vociMenu = {"Inserisci nominativo", "Cerca per nome",
"Cerca per indirizzo", "Cancella nominativo",
"Termine operazioni"};
menu = new ListBox(finestra, "Menu Principale", false);
for (int i = 0; i < vociMenu.length; i++) {
menu.addItem(vociMenu[i]);
}
}
public void esegui() {
// Presenta all'utente il menu principale in un ciclo continuo
while (true) {
int selection = menu.getSelectedIndex();
switch (selection) {
case 0 : inserisciPersona(); break;
case 1 : cercaPersona(); break;
case 2 : cercaIndirizzi(); break;
case 3 : cancellaPersona(); break;
case 4 : System.exit(0);
default : break;
}
}
}
private void inserisciPersona() {
String[] campi = scheda.getInputs();
if (campi != null) {
for (int i = 0; i < campi.length; i++) {
if (campi[i].length() == 0){
messaggio.show("Non hai inserito correttamente un campo ");
return;
}
}
Persona p = new Persona(campi[0], campi[1],
Integer.parseInt(campi[2]), campi[3]);
rubrica.aggiungi(p);
messaggio.show("Inserimento effettuato ");
}
}
private void cercaPersona() {
String nome = richiesta.getString("Inserisci il nome da cercare: ");
Persona p = rubrica.cercaPersonaPerNome(nome);
if (p == null) {
// La persona non è stata trovata
messaggio.show("La persona di nome " + nome + " non è nell'elenco. ");
} else {
// La persona è nella rubrica, visualizziamo i dati
uscita.clear();
uscita.printLine("La seguente persona è stata trovata nella rubrica.");
visualizzaPersona(uscita, p);
uscita.show();
}
}
private void cercaIndirizzi() {
String indirizzo =
richiesta.getString("Inserisci l'indirizzo da cercare: ");
Persona[] elenco = rubrica.cercaPersonePerIndirizzo(indirizzo);
// La persona è nella rubrica, visualizziamo i dati
uscita.clear();
int i = 0;
while (i < elenco.length && elenco[i] != null) {
uscita.printLine("Nominativo " + (i+1));
visualizzaPersona(uscita, elenco[i]);
++i;
}
uscita.show();
}
private void cancellaPersona() {
String nome = richiesta.getString("Inserisci il nome da cancellare: ");
Persona p = rubrica.cercaPersonaPerNome(nome);
if (p == null) {
// La persona non è stata trovata
messaggio.show("La persona di nome " + nome + " non è nell'elenco. ");
} else {
uscita.clear();
uscita.printLine("La seguente persona è stata rimossa dalla rubrica.");
visualizzaPersona(uscita, p);
uscita.show();
}
}
private void visualizzaPersona(OutputBox ob, Persona p) {
// La persona è nella rubrica, visualizziamo i dati
ob.printLine("Nome: " + p.restituisciNome());
ob.printLine("Indirizzo e numero: " +
p.restituisciIndirizzo() + " " + p.restituisciCivico());
ob.printLine("Telefono: " + p.restituisciTelefono());
}
}
Persona.java
Created with JBuilder
class Persona {
// Attributi
private String
private String
private int
private String
nome;
indirizzo;
civico;
telefono;
// Costruttore
public Persona(String nome,
String indirizzo,
int
civico,
String telefono)
{
this.nome = nome;
this.indirizzo = indirizzo;
this.civico = civico;
this.telefono = telefono;
}
// Metodi di impostazione della classe Persona
public void impostaNome(String nome)
{
this.nome = nome;
}
public void impostaDomicilio(String indirizzo, int civico)
{
this.indirizzo = indirizzo;
this.civico = civico;
}
public void impostaTelefono(String telefono)
{
this.telefono = telefono;
}
// Metodi di interrogazione della classe Persona
public String restituisciNome()
{
return this.nome;
}
public String restituisciIndirizzo()
{
return this.indirizzo;
}
public int restituisciCivico()
{
return this.civico;
}
public String restituisciTelefono()
{
return this.telefono;
}
}
Polinomio2Grado.java
Created with JBuilder
class Polinomio2Grado {
// Costanti che identificano il tipo di soluzione
public static final int SOLUZIONI_REALI = 0;
public static final int SOLUZIONI_IMMAGINARIE = 1;
public static final int SOLUZIONE_UNICA = 3;
public static final int POLINOMIO_DEGENERE = 4;
// Coefficienti del polinomio
private double coefficienteX2;
private double coefficienteX;
private double coefficiente;
// Soluzioni
private double soluzione1;
private double soluzione2;
// Costruttore: è necessario specificare il valore
// dei coefficienti per creare oggetti della classe
public Polinomio2Grado( double x2, double x, double c ) {
coefficienteX2 = x2;
coefficienteX = x;
coefficiente = c;
soluzione1 = soluzione2 = 0;
}
// Metodi per l'impostazione dei coefficienti
public void impostaCoefficienteX2( double x2 ) {
coefficienteX2 = x2;
}
public void impostaCoefficienteX( double x ) {
coefficienteX = x;
}
public void impostaCoefficiente( double c ) {
coefficiente = c;
}
// Restituisce:
// - SOLUZIONI_REALI se il polinomio ammette due soluzioni reali distinte
// - SOLUZIONI_IMMAGINARIE se il polinomio ha soluzioni complesse coniugate
// - SOLUZIONE_UNICA se le soluzioni sono reali e coincidenti
// - POLINOMIO_DEGENERE se coefficienteX2 o coefficienteX sono uguali a 0
public int calcolaSoluzioni( ) {
// Sinonimi locali per gli attributi
double a = coefficienteX2;
double b = coefficienteX;
double c = coefficiente;
// Assumiamo che il polinomio sia degenere
int risultato = POLINOMIO_DEGENERE;
// Calcolo delle soluzioni
if ((a != 0) && (b != 0)) {
double delta = Math.pow(b,2) - 4 * a * c;
if (delta > 0) {
// Le soluzioni sono reali e distinte
soluzione1 = (-b + Math.sqrt(delta)) / (2 * a);
soluzione2 = (-b - Math.sqrt(delta)) / (2 * a);
risultato = SOLUZIONI_REALI;
} else if (delta < 0) {
// Le soluzioni sono complesse coniugate
risultato = SOLUZIONI_IMMAGINARIE;
} else {
// Le soluzioni sono reali e coincidenti
soluzione1 = soluzione2 = -b / (2 * a);
risultato = SOLUZIONE_UNICA;
}
}
return risultato;
}
// Metodi per la restituzione delle soluzioni e dei coefficienti
public double restituisciSoluzione1() {
return soluzione1;
}
public double restituisciSoluzione2() {
return soluzione2;
}
public double restituisciCoefficienteX2() {
return coefficienteX2;
}
public double restituisciCoefficienteX() {
return coefficienteX;
}
public double restituisciCoefficiente() {
return coefficiente;
}
}
PrimoProgramma.java
Created with JBuilder
import javabook.*;
class PrimoProgramma {
public static void main(String[] args) {
MainWindow finestra;
finestra = new MainWindow();
finestra.show();
}
}
Rubrica.java
Created with JBuilder
class Rubrica {
// Attributi
private Persona[] elencoPersone;
private int
numeroPersone;
// Costruttore
public Rubrica( int numeroMaxPersone ) {
elencoPersone = new Persona[numeroMaxPersone];
numeroPersone = 0;
}
// Aggiungi una persona
public void aggiungi( Persona p ) {
// Se l'elenco è pieno allora è necessario espanderlo
if (numeroPersone == elencoPersone.length) {
espandiElenco(2);
}
elencoPersone[numeroPersone] = p;
++numeroPersone;
}
// Cerca una persone per nome
public Persona cercaPersonaPerNome( String nomeCercato ) {
for (int i = 0; i < numeroPersone; i++) {
String nomeTrovato = elencoPersone[i].restituisciNome();
if (nomeTrovato.equals(nomeCercato)) {
return elencoPersone[i];
}
}
return null;
}
// Cerca tutte le persone che abitano ad un dato indirizzo
public Persona[] cercaPersonePerIndirizzo( String indirizzoCercato ) {
Persona[] personeCercate = new Persona[numeroPersone];
int elementiCercati = 0;
for (int i = 0; i < numeroPersone; i++) {
String indirizzoTrovato =
elencoPersone[i].restituisciIndirizzo();
if (indirizzoTrovato.equals(indirizzoCercato)) {
personeCercate[elementiCercati] = elencoPersone[i];
++elementiCercati;
// elementiCercati++;
// elementiCercati += 1;
// elementiCercati = elementiCercati + 1;
}
}
return personeCercate;
}
// Cancellare una persona (dato il nome)
public Persona cancellaPersonaPerNome( String nomeCercato ) {
Persona risultato = null;
for (int i = 0; i < numeroPersone; i++) {
String nomeTrovato = elencoPersone[i].restituisciNome();
if (nomeTrovato.equals(nomeCercato)) {
risultato = elencoPersone[i];
elencoPersone[i] = elencoPersone[numeroPersone - 1];
elencoPersone[numeroPersone - 1] = null;
--numeroPersone;
break;
}
}
return risultato;
}
// Altra versione del metodo di cancellazione (più elegante)
public Persona cancellaPersonaPerNome2( String nomeCercato ) {
Persona risultato = null;
int i = 0;
while ((i < numeroPersone) && (risultato == null)) {
String nomeTrovato = elencoPersone[i].restituisciNome();
if (nomeTrovato.equals(nomeCercato)) {
risultato = elencoPersone[i];
elencoPersone[i] = elencoPersone[numeroPersone - 1];
elencoPersone[numeroPersone - 1] = null;
--numeroPersone;
}
}
return risultato;
}
// Metodo per espandere l'elenco di un fattore dato
private void espandiElenco(int fattore) {
int nuovaDimensione = elencoPersone.length * fattore;
Persona[] elencoEspanso = new Persona[nuovaDimensione];
for (int i = 0; i < elencoPersone.length; i++) {
elencoEspanso[i] = elencoPersone[i];
}
elencoPersone = elencoEspanso;
}
}
SommaMedia.java
Created with JBuilder
import javabook.*;
class SommaMedia {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Somma e media di N numeri");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Chiedo all'utente quanti numeri desidera inserire
int numeroDati = richiestaDati.getInteger("Quanti numeri? ");
// Inizializzo la somma a 0
int somma = 0;
// Richiedo numeroDati interi
for (int i = 0; i < numeroDati; i++) {
int dato = richiestaDati.getInteger("Inserisci il dato: ");
somma += dato;
}
// Calcolo la media
// NOTA: desidero ottenere la media come un numero in virgola
// mobile, pertanto devo convertire somma e numeroDati
float media = (float)somma / (float)numeroDati;
// Visualizzo i risultati
uscitaDati.print("Hai richiesto la media di ");
uscitaDati.print(numeroDati);
uscitaDati.printLine(" dati");
uscitaDati.print("La somma dei dati è: ");
uscitaDati.printLine(somma);
uscitaDati.print("La media dei dati è: ");
uscitaDati.printLine(media);
uscitaDati.show();
}
}
Tempo.java
Created with JBuilder
// Classe accessoria per la gestione degli orari
// degli appuntamenti e della durata degli stessi
class Tempo {
public static final int ORE = 0;
public static final int MINUTI = 1;
// Attributi della classe Tempo
private int ore;
private int minuti;
// Costruttori
public Tempo() {
ore = minuti = 0;
}
public Tempo(int hh, int mm) {
ore = hh;
minuti = mm;
}
public Tempo(int[] oreMinuti) {
ore = oreMinuti[ORE];
minuti = oreMinuti[MINUTI];
}
public Tempo(Tempo t) {
ore = t.ore();
minuti = t.minuti();
}
// Metodi di impostazione
public void impostaOre(int hh) {
ore = hh;
}
public void impostaMinuti(int mm) {
minuti = mm;
}
public void imposta(int[] oreMinuti) {
ore = oreMinuti[ORE];
minuti = oreMinuti[MINUTI];
}
public void imposta(Tempo t) {
ore = t.ore();
minuti = t.minuti();
}
// Metodi di interrogazione
public int ore() {
return ore;
}
public int minuti() {
return minuti;
}
public int[] minutiEsecondi() {
int[] v = new int[2];
v[ORE] = ore;
v[MINUTI] = minuti;
return v;
}
// Metodi di conversione (ore:min -> min e min -> ore:min)
public int inMinuti() {
return (ore * 60 + minuti);
}
public void daMinuti(int mm) {
ore = mm / 60;
minuti = mm % 60;
}
// Somma un tempo
public void somma(Tempo t)
{
int min = inMinuti() + t.inMinuti();
daMinuti(min);
}
// Sottrae un tempo
public Tempo sottrai(Tempo t)
{
int sec = this.inMinuti() - t.inMinuti();
this.daMinuti(sec);
return this;
}
// Confronto fra tempi
public boolean maggioreDi(Tempo t) {
return (this.inMinuti() > t.inMinuti());
}
public boolean minoreDi(Tempo t) {
return (this.inMinuti() < t.inMinuti());
}
}
TriangoloIsoscele.java
Created with JBuilder
import javabook.*;
class TriangoloIsoscele {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Triangolo Isoscele");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Chiedo all'utente l'altezza del triangolo
int altezza = richiestaDati.getInteger("Altezza del triangolo? ");
// Disegno il triangolo
for (int i = 0; i < altezza; i++) {
// Srivo il numero necessario di spazi
for (int s = 0; s < altezza - i; s++) {
uscitaDati.print(" ");
}
for (int j = 0; j <= i * 2; j++) {
uscitaDati.print("*");
}
uscitaDati.printLine("");
}
// Visualizzo il risultato
uscitaDati.show();
}
}
TriangoloRettangolo.java
Created with JBuilder
import javabook.*;
class TriangoloRettangolo {
public static void main(String[] args) {
// Dichiaro e creo gli oggetti necessari per l'IO
MainWindow finestra = new MainWindow("Triangolo Rettangolo");
InputBox richiestaDati = new InputBox(finestra, "Inserimento dati");
OutputBox uscitaDati = new OutputBox(finestra, "Risultati");
// Rendo visibile la finestra principale
finestra.show();
// Chiedo all'utente l'altezza del triangolo
int altezza = richiestaDati.getInteger("Altezza del triangolo? ");
// Disegno il triangolo
for (int i = 0; i < altezza; i++) {
for (int j = 0; j <= i; j++) {
uscitaDati.print("*");
}
// NOTA: questa istruzione serve per andare a capo
uscitaDati.printLine("");
}
// Visualizzo il risultato
uscitaDati.show();
}
}
VettoreDiCaratteri.java
Created with JBuilder
class VettoreDiCaratteri {
// Vettore e numero di elementi inseriti
private char[] vettore;
// Costruttore (standard)
public VettoreDiCaratteri( int numeroMaxElementi ) {
// Il vettore ha una data lunghezza (massima)
vettore = new char[numeroMaxElementi];
}
// Costruttore con conversione da VettoreDiInteri
public VettoreDiCaratteri( VettoreDiInteri v) {
vettore = new char[v.restituisciNumeroMassimoElementi()];
for (int i = 0; i < vettore.length; i++) {
vettore[i] = (char) v.restituisciElemento(i);
}
}
// Metodi base
public int restituisciNumeroMassimoElementi( ) {
return vettore.length;
}
public char restituisciElemento( int posizione ) {
return vettore[posizione];
}
public void impostaElemento( char elemento, int posizione ) {
vettore[posizione] = elemento;
}
// Metodo per la rilevazione di palindromi
public boolean palindromo( ) {
int s = 0;
int t = vettore.length - 1;
while (s < t) {
if (vettore[s] != vettore[t]) {
return false;
}
++s;
--t;
}
return true;
}
// Metodo per la conversione a VettoreDiInteri
VettoreDiInteri convertiInInteri( ) {
VettoreDiInteri v = new VettoreDiInteri(vettore.length);
for (int i = 0; i < vettore.length; i++) {
v.impostaElemento((int) vettore[i], i);
}
return v;
}
}
VettoreDiInteri.java
Created with JBuilder
class VettoreDiInteri {
// Vettore e numero di elementi inseriti
private int[] vettore;
private int
numeroElementi;
// Costruttore
public VettoreDiInteri( int numeroMaxElementi ) {
// Il vettore ha una data lunghezza (massima)
vettore = new int[numeroMaxElementi];
// Inizialmente il vettore è vuoto
numeroElementi = 0;
}
// Metodi per ottenere il numero di elementi del vettore
public int restituisciNumeroElementi( ) {
return numeroElementi;
}
public int restituisciNumeroMassimoElementi( ) {
return vettore.length;
}
// Metodo per ottenere il valore di una posizione
public int restituisciElemento( int posizione ) {
return vettore[posizione];
}
// Metodo per impostare il valore di una posizione
public void impostaElemento( int elemento, int posizione ) {
vettore[posizione] = elemento;
}
// Metodo per aggiungere un elemento
public boolean inserisci( int x ) {
if (numeroElementi < vettore.length) {
vettore[numeroElementi] = x;
++numeroElementi;
return true;
} else {
return false;
}
}
// Metodo per la ricerca di un elemento
public int cerca( int x ) {
for (int i = 0; i < vettore.length; i++) {
if (vettore[i] == x) {
return i;
}
}
return -1;
}
// Metodo per la cancellazione di un elemento
public boolean cancella( int x ) {
int posizione = cerca(x);
if (posizione >= 0) {
vettore[posizione] = vettore[numeroElementi - 1];
--numeroElementi;
return true;
} else {
return false;
}
}
// Metodo per il confronto con un vettore
public boolean confronta(VettoreDiInteri u) {
if (vettore.length != u.restituisciNumeroMassimoElementi()) {
return false;
}
for (int i = 0; i < vettore.length; i++) {
if (u.restituisciElemento(i) != vettore[i]) {
return false;
}
}
return true;
}
// Metodo per l'ordinamento di un vettore
public void ordina() {
for (int i = 0; i < vettore.length - 1; i++) {
// Ricerca del minimo
int posizioneMin = i;
for (int j = i + 1; i < vettore.length; j++) {
if (vettore[j] < vettore[posizioneMin]) {
posizioneMin = j;
}
}
// Scambio del minimo con il primo
int t = vettore[i];
vettore[i] = vettore[posizioneMin];
vettore[posizioneMin] = t;
}
}
// Metodo per la somma di due vettori
public void somma(VettoreDiInteri u) {
// I vettori devono essere della stessa lunghezza
if (u.restituisciNumeroMassimoElementi() == vettore.length) {
for (int i = 0; i < vettore.length; i++) {
vettore[i] += u.restituisciElemento(i);
}
}
}
// Metodo per la moltiplicazione con una costante
public void moltiplicaCostante(int k) {
for (int i = 0; i < vettore.length; i++) {
vettore[i] *= k;
}
}
// Prodotto scalare
public int moltiplicaScalare(VettoreDiInteri u) {
int prodottoScalare = 0;
if (vettore.length == u.restituisciNumeroMassimoElementi()) {
for (int i = 0; i < vettore.length; i++) {
prodottoScalare += vettore[i] * u.restituisciElemento(i);
}
}
return prodottoScalare;
}
// Sommatoria di tutti gli elementi
public int sommaElementi( ) {
int somma = 0;
for (int i = 0; i < vettore.length; i++) {
somma += vettore[i];
}
return somma;
}
// Media di tutti gli elementi
public float mediaElementi( ) {
float media = (float) sommaElementi();
return (media / vettore.length);
}
// Indice dell'elemento più piccolo
public int indiceElementoMinimo( ) {
int posMin = 0;
for (int i = 1; i < vettore.length; i++) {
if (vettore[i] < vettore[posMin]) {
posMin = i;
}
}
return posMin;
}
// Indice dell'elemento più grande
public int indiceElementoMassimo( ) {
int posMax = 0;
for (int i = 1; i < vettore.length; i++) {
if (vettore[i] > vettore[posMax]) {
posMax = i;
}
}
return posMax;
}
}
