D4rkAng3l
24-11-2008, 20:58
Ciao,
stavo rivedendo un'esercitazione presente sulle dispense della proff...
Ci sono due classi da compilare: OperazioniUtili.java che per ora contiene solo 3 metodi (uno che dati due numeri calcola MCD, uno che calcola il segno di un valore ed uno che calcola il valore assoluto di un numero) ed un'altra classe chiamata Frazioni.java che descrive il tipo di dato frazionario (cioè oggetti che contengono frazioni come: 3/2, 7/8, etcetc) tramite due variabili di istanza (num e den che rappresentano appunto il numeratore ed il denominatore diuna frazione) ed una lunga lista di metodi per operare sulle frazioni come somma di frazioni, prodotti di frazioni,..., operatori relazionali, etcetc....
La classe OperazioniUtili.java si compila tranquillamente generando il relativo file .class ma quando provo a compilare la classe Frazioni.java mi dà qualche errore che non capisco da cosa possa dipendere, gli errori sono i seguenti:
C:\Programmi\Crimson Editor\template\esercizi\Frazioni>javac Frazione.java
Frazione.java:85: cannot find symbol
symbol : method calcolaMinimoComuneMultiplo(int,int)
location: class OperazioniUtili
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
^
Frazione.java:106: cannot find symbol
symbol : variable OperzioniUtili
location: class Frazione
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
^
Frazione.java:130: cannot find symbol
symbol : method calcolaMinimoComuneMultiplo(int,int)
location: class OperazioniUtili
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
^
Frazione.java:151: cannot find symbol
symbol : variable OperzioniUtili
location: class Frazione
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
^
4 errors
C:\Programmi\Crimson Editor\template\esercizi\Frazioni>
I codici delle due classi sono:
Frazioni.java
/** Classe che rappresenta l'insieme dei numeri razionali in forma di frazioni */
public class Frazione{
int num, den; // Le variabili di istanza che rappresentano il numeratore ed il denominatore
/** Il costruttore: costruisce un oggetto di tipo Frazione ed ha 2 variabili di istanza: num e den; Se il valore
corrispondente al denominatore è nullo allora costruisce un oggeto privo di significato altrimenti costruisce
una frazione standardizzata dal metodo semplificati.
@param num di tipo int: il numeratore della frazione
@param den di tipo int: il denominatore della frazione */
public Frazione(int num, int den){
if (den != 0){ // Se il denominatore è valido
this.num = num;
this.den = den;
semplificati(); // Invoca il metodo funzionale semplificati per standardizzare la frazione appena creata
}
else{ // Se il denominatore non è valido, stampa un messaggio di errore e crea l'oggetto privo di significato
System.err.println("Errore si stà tentando di creare una frazione a denominatore nullo!");
num = 0;
den = 0;
}
}
/* I metodi di accesso alle variabili di istanza */
/** Se l'oggetto ricevente è non valido, visualizza un messaggio di errore
@return il valore di tipo int che corrisponde al numeratore dell'oggetto frazione ricevente; se l'oggetto ricevente
è non valido allora restituisce 0 */
public int getNumeratore(){ // Restituisce un intero pari al valore del numeratore dell'oggetto
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
}
return den;
}
/** Se l'oggetto ricevente è non valido, visualizza un messaggio di errore
@return il valore di tipo int che corrisponde al denominatore dell'oggetto frazione ricevente; se l'oggetto ricevente
è non valido allora restituisce 0 */
public int getDenominatore(){ // Restituisce un intero pari al valore del denominatore dell'oggetto
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
}
return den;
}
/** Se l'oggetto è non valido, visualizza un messaggio di errore
@return il valore di tipo double che corrisponde al valore della frazione rappresentata dall'oggetto ricevente;
se l'oggetto ricevente è non valido, allora restituisce 0 */
public double getValore(){ // Restituisce il valore decimale di una frazione
double valore; // Il valore della frazione
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
valore = 0;
}
else{
valore = (double) num/den;
}
return valore;
}
/* I metodi operatore */
/** @param F di tipo frazione
@return il riferimento all'oggetto di tipo Frazione che corrisponde alla somma di F con la frazione rappresentata
dall'oggetto ricevente se sia l'oggetto ricevente che il parametro F sono frazioni validi, altrimenti restituisce
il riferimento all'oggetto Frazione non valido */
public Frazione somma(Frazione F){ // Somma la frazione parametro all'oggetto ricevente e alloca un nuovo oggetto
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola la loro somma
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
nuovoNum = num*(nuovoDen/den) + F.num*(nuovoDen/F.den);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // Altrimenti restituisci un messaggio di errore, crea e restituisci una frazione non valida
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua somma con il parametro se l'oggetto ricevente o il parametro
sono validi, altrimenti l'oggetto ricevente diventa la frazione non valida */
public void sommati(Frazione F){ // Somma la frazione parametro all'oggetto ricevente che va a modificare
int nuovoDen; // è la variabile per memorizzare temporaneamente il denominatore della frazione somma
if(den != 0 && F.den !=0){ // Se entrambe le frazioni sono valide allora calcoliamo la somma
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
num = num*(nuovoDen/den) + F.num*(nuovoDen/F.den);
den = nuovoDen;
semplificati();
}
else{ // altrimenti visualizza un messaggio di errore e modifica l'oggetto ricevente affinchè rappresenti l'oggetto non valido
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di tipo Frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde alla differenza di F con la frazione rappresentata
dall'oggetto ricevente se entrambe sono frazioni valide, altrimenti restituisci il riferimento all'oggetto Frazione
non valida */
public Frazione sottrai(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola la loro differenza
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
nuovoNum = num*(nuovoDen/den) - F.num*(nuovoDen/F.den);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // altrimenti crea l'oggetto frazione non valida e visualizza un messaggio di errore
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua differenza con il parametro se sono entrambi validi,
altrimenti l'oggetto ricevente diventa non valido
@param F di tipo Frazione */
public void sottraiti(Frazione F){
int nuovoDen;
if(den != 0 && F.den !=0){ // Se entrambe le frazioni sono valide allora calcoliamo la differenza
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
num = num*(nuovoDen/den) - F.num*(nuovoDen/F.den);
den = nuovoDen;
semplificati();
}
else{ // altrimenti visualizza un messaggio di errore e modifica l'oggetto ricevente affinchè rappresenti l'oggetto non valido
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di ripo Frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde al prodotto di F con la frazione rappresentata
dall'oggetto ricevente se entrambe valide, se una delle due non è valida restituisce il riferimento all'oggetto
frazione non valida */
public Frazione moltiplica(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den !=0){ // se entrambe le frazioni sono valide calcola il loro prodotto
nuovoDen = den*F.den;
nuovoNum = num*F.num;
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // Altrimenti stampa un messaggio di errore e restituisci la frazione non valida
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari al suo prodotto con il parametro se entrambi sono validi, altrimenti
restituisci l'oggetto frazione non valida.
@param F di tipo Frazione */
public void moltiplicati(Frazione F){
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola il loro prodotto
den = den*F.den;
num = num*F.num;
semplificati();
}
else{ // altrimenti stampa un messaggio di errore e modifica l'oggetto ricevente alla frazione nulla
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di tipo frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde alla divisione di F con la frazione rappresentata
dall'oggetto ricevente se entrambe valide, se una delle due non è valida restituisce il riferimento all'oggetto
frazione non valida */
public Frazione dividi(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0 && F.num != 0){
nuovoDen = den*F.num;
nuovoNum = num*F.den;
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua divisione con il parametro se entrambi sono validi, altrimenti
restituisci l'oggetto frazione non valida.
@param F di tipo Frazione */
public void dividiti(Frazione F){
if(den != 0 && F.den != 0 && F.num != 0){
den = den*F.num;
num = num*F.den;
semplificati();
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @return il riferimento ad un oggetto di tipo Frazione che corrisponde alla frazione inversa della frazione
rappresentata dall'oggetto ricevente se entrambi sono validi, altrimenti restituisce il riferimento all'oggetto
di tipo Frazione non valido */
public Frazione inverti(){
Frazione nuovaFrazione; // è il risultato
if(den != 0 && num != 0){
nuovaFrazione = new Frazione(den, num);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari al suo inverso, se il numeratore dell'oggetto ricevente è nullo
l'oggetto ricevente diventa nullo, se l'oggetto ricevente non è valido allora non sarà modificato */
public void invertiti(){
int nuovoDen;
if(den != 0 && num != 0){
nuovoDen = num;
num = den;
den = nuovoDen;
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** Eleva alla k-esima potenza l'oggetto ricevente e crea un nuovo oggetto */
public Frazione elevaAPotenza(int k){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione;
if(den != 0){
nuovoNum = (int) Math.pow(num, k);
nuovoDen = (int) Math.pow(den, k);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo la sua k-esima potenza se valido */
public void elevatiAPotenza(int k){
if(den != 0){
num = (int) Math.pow(num, k);
den = (int) Math.pow(den, k);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/* I metodi corrispondenti agli operatori relazionali */
public boolean equals(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num == F.num && den == F.den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean maggiore(Frazione F){
boolean esito;
double r1, r2; // Per memorizzare i valori razionali delle frazioni
if(den != 0 && F.den != 0){
r1 = getValore(); // Ora r1 contiene il valore razionale dell'ogetto ricevente
r2 = F.getValore(); // Ora r2 contiene il valore razionale del parametro F
esito = r1 > r2;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean maggioreOUguale(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den >= F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean minore(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den < F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean minoreOUguale(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den <= F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public String toString(){ // Trasforma in stringa l'oggetto ricevente e restituisce il riferimento ad un oggetto String
String risposta = ""; // è la stringa da restituire
if(den != 0){
risposta += num + "/" + den;
}
return risposta;
}
/* Il metodo di classe
@param d di tipo float
@return il riferimento ad un oggeto Frazione corrispondente alla rappresentazione di d in forma frazionaria
public static Frazione convertiAFrazione(float d){
String s; // La rappresentazione di d in forma di stringa
int postPunto; // La posizione della virgola decimale in d
int contaDecimali; // Conta il numero di cifre a destra della virgola
int nuovoNum, nuovoDen; // Numeratore e denominatore della frazione
Frazione F; // L'oggetto da restituire
s = String.valueOf(d); // Trasforma d in stringa
if(s.IndexOf(E){
System.err.println("Errore: numero non ammesso);
F = null;
}
else{
if(postPunto >= 0) nDecimali = s.length()-1-postPunto;
else nDecimali = 0;
}
*/
/* Il metodo funzionale */
private void semplificati(){ // Lo dichiaro come private in quanto modifica l'oggetto ricevente e non deve poter essere usato nel main
int segno; // Il segno della frazione
int divisore; // Il fattore di semplificazione
if(den != 0){
segno = OperazioniUtili.calcolaSegno(num*den);
if(num <= 0) num = -num;
if(den <= 0) den = -den;
divisore = OperazioniUtili.calcolaMassimoComuneDivisore(num, den);
num = num/divisore*segno;
den = den/divisore;
}
}
}
OperazioniUtili.java
public class OperazioniUtili{
public static double calcolaValoreAssoluto(double x){
return Math.sqrt(Math.pow(x,2));
}
public static byte calcolaSegno(double x){
byte sign; // è il valore da restituire
if(x != 0) sign = (byte)(x/calcolaValoreAssoluto(x));
else sign = 1;
return sign;
}
public static int calcolaMassimoComuneDivisore(int x, int y){
int r;
int MCD = 0;
if(x<=0 || y<=0){
System.err.println("Input errato: sono richiesti valori positivi");
}
else{
r = x%y;
MCD = y;
while(r>0){
y = MCD;
MCD = r;
r = y%MCD;
}
}
return MCD;
}
}
Grazie
Andrea
stavo rivedendo un'esercitazione presente sulle dispense della proff...
Ci sono due classi da compilare: OperazioniUtili.java che per ora contiene solo 3 metodi (uno che dati due numeri calcola MCD, uno che calcola il segno di un valore ed uno che calcola il valore assoluto di un numero) ed un'altra classe chiamata Frazioni.java che descrive il tipo di dato frazionario (cioè oggetti che contengono frazioni come: 3/2, 7/8, etcetc) tramite due variabili di istanza (num e den che rappresentano appunto il numeratore ed il denominatore diuna frazione) ed una lunga lista di metodi per operare sulle frazioni come somma di frazioni, prodotti di frazioni,..., operatori relazionali, etcetc....
La classe OperazioniUtili.java si compila tranquillamente generando il relativo file .class ma quando provo a compilare la classe Frazioni.java mi dà qualche errore che non capisco da cosa possa dipendere, gli errori sono i seguenti:
C:\Programmi\Crimson Editor\template\esercizi\Frazioni>javac Frazione.java
Frazione.java:85: cannot find symbol
symbol : method calcolaMinimoComuneMultiplo(int,int)
location: class OperazioniUtili
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
^
Frazione.java:106: cannot find symbol
symbol : variable OperzioniUtili
location: class Frazione
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
^
Frazione.java:130: cannot find symbol
symbol : method calcolaMinimoComuneMultiplo(int,int)
location: class OperazioniUtili
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
^
Frazione.java:151: cannot find symbol
symbol : variable OperzioniUtili
location: class Frazione
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
^
4 errors
C:\Programmi\Crimson Editor\template\esercizi\Frazioni>
I codici delle due classi sono:
Frazioni.java
/** Classe che rappresenta l'insieme dei numeri razionali in forma di frazioni */
public class Frazione{
int num, den; // Le variabili di istanza che rappresentano il numeratore ed il denominatore
/** Il costruttore: costruisce un oggetto di tipo Frazione ed ha 2 variabili di istanza: num e den; Se il valore
corrispondente al denominatore è nullo allora costruisce un oggeto privo di significato altrimenti costruisce
una frazione standardizzata dal metodo semplificati.
@param num di tipo int: il numeratore della frazione
@param den di tipo int: il denominatore della frazione */
public Frazione(int num, int den){
if (den != 0){ // Se il denominatore è valido
this.num = num;
this.den = den;
semplificati(); // Invoca il metodo funzionale semplificati per standardizzare la frazione appena creata
}
else{ // Se il denominatore non è valido, stampa un messaggio di errore e crea l'oggetto privo di significato
System.err.println("Errore si stà tentando di creare una frazione a denominatore nullo!");
num = 0;
den = 0;
}
}
/* I metodi di accesso alle variabili di istanza */
/** Se l'oggetto ricevente è non valido, visualizza un messaggio di errore
@return il valore di tipo int che corrisponde al numeratore dell'oggetto frazione ricevente; se l'oggetto ricevente
è non valido allora restituisce 0 */
public int getNumeratore(){ // Restituisce un intero pari al valore del numeratore dell'oggetto
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
}
return den;
}
/** Se l'oggetto ricevente è non valido, visualizza un messaggio di errore
@return il valore di tipo int che corrisponde al denominatore dell'oggetto frazione ricevente; se l'oggetto ricevente
è non valido allora restituisce 0 */
public int getDenominatore(){ // Restituisce un intero pari al valore del denominatore dell'oggetto
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
}
return den;
}
/** Se l'oggetto è non valido, visualizza un messaggio di errore
@return il valore di tipo double che corrisponde al valore della frazione rappresentata dall'oggetto ricevente;
se l'oggetto ricevente è non valido, allora restituisce 0 */
public double getValore(){ // Restituisce il valore decimale di una frazione
double valore; // Il valore della frazione
if(den == 0){
System.err.println("Frazione non valida: denominatore nullo");
valore = 0;
}
else{
valore = (double) num/den;
}
return valore;
}
/* I metodi operatore */
/** @param F di tipo frazione
@return il riferimento all'oggetto di tipo Frazione che corrisponde alla somma di F con la frazione rappresentata
dall'oggetto ricevente se sia l'oggetto ricevente che il parametro F sono frazioni validi, altrimenti restituisce
il riferimento all'oggetto Frazione non valido */
public Frazione somma(Frazione F){ // Somma la frazione parametro all'oggetto ricevente e alloca un nuovo oggetto
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola la loro somma
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
nuovoNum = num*(nuovoDen/den) + F.num*(nuovoDen/F.den);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // Altrimenti restituisci un messaggio di errore, crea e restituisci una frazione non valida
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua somma con il parametro se l'oggetto ricevente o il parametro
sono validi, altrimenti l'oggetto ricevente diventa la frazione non valida */
public void sommati(Frazione F){ // Somma la frazione parametro all'oggetto ricevente che va a modificare
int nuovoDen; // è la variabile per memorizzare temporaneamente il denominatore della frazione somma
if(den != 0 && F.den !=0){ // Se entrambe le frazioni sono valide allora calcoliamo la somma
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
num = num*(nuovoDen/den) + F.num*(nuovoDen/F.den);
den = nuovoDen;
semplificati();
}
else{ // altrimenti visualizza un messaggio di errore e modifica l'oggetto ricevente affinchè rappresenti l'oggetto non valido
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di tipo Frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde alla differenza di F con la frazione rappresentata
dall'oggetto ricevente se entrambe sono frazioni valide, altrimenti restituisci il riferimento all'oggetto Frazione
non valida */
public Frazione sottrai(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola la loro differenza
nuovoDen = OperazioniUtili.calcolaMinimoComuneMultiplo(den, F.den);
nuovoNum = num*(nuovoDen/den) - F.num*(nuovoDen/F.den);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // altrimenti crea l'oggetto frazione non valida e visualizza un messaggio di errore
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua differenza con il parametro se sono entrambi validi,
altrimenti l'oggetto ricevente diventa non valido
@param F di tipo Frazione */
public void sottraiti(Frazione F){
int nuovoDen;
if(den != 0 && F.den !=0){ // Se entrambe le frazioni sono valide allora calcoliamo la differenza
nuovoDen = OperzioniUtili.calcolaMinimoComuneMultiplo(F.den, den);
num = num*(nuovoDen/den) - F.num*(nuovoDen/F.den);
den = nuovoDen;
semplificati();
}
else{ // altrimenti visualizza un messaggio di errore e modifica l'oggetto ricevente affinchè rappresenti l'oggetto non valido
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di ripo Frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde al prodotto di F con la frazione rappresentata
dall'oggetto ricevente se entrambe valide, se una delle due non è valida restituisce il riferimento all'oggetto
frazione non valida */
public Frazione moltiplica(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den !=0){ // se entrambe le frazioni sono valide calcola il loro prodotto
nuovoDen = den*F.den;
nuovoNum = num*F.num;
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{ // Altrimenti stampa un messaggio di errore e restituisci la frazione non valida
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari al suo prodotto con il parametro se entrambi sono validi, altrimenti
restituisci l'oggetto frazione non valida.
@param F di tipo Frazione */
public void moltiplicati(Frazione F){
if(den != 0 && F.den != 0){ // Se entrambe le frazioni sono valide calcola il loro prodotto
den = den*F.den;
num = num*F.num;
semplificati();
}
else{ // altrimenti stampa un messaggio di errore e modifica l'oggetto ricevente alla frazione nulla
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @param F di tipo frazione
@return il riferimento ad un oggetto di tipo Frazione che corrisponde alla divisione di F con la frazione rappresentata
dall'oggetto ricevente se entrambe valide, se una delle due non è valida restituisce il riferimento all'oggetto
frazione non valida */
public Frazione dividi(Frazione F){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione; // è il risultato
if(den != 0 && F.den != 0 && F.num != 0){
nuovoDen = den*F.num;
nuovoNum = num*F.den;
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
}
/** Modifica l'oggetto ricevente rendendolo pari alla sua divisione con il parametro se entrambi sono validi, altrimenti
restituisci l'oggetto frazione non valida.
@param F di tipo Frazione */
public void dividiti(Frazione F){
if(den != 0 && F.den != 0 && F.num != 0){
den = den*F.num;
num = num*F.den;
semplificati();
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** @return il riferimento ad un oggetto di tipo Frazione che corrisponde alla frazione inversa della frazione
rappresentata dall'oggetto ricevente se entrambi sono validi, altrimenti restituisce il riferimento all'oggetto
di tipo Frazione non valido */
public Frazione inverti(){
Frazione nuovaFrazione; // è il risultato
if(den != 0 && num != 0){
nuovaFrazione = new Frazione(den, num);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo pari al suo inverso, se il numeratore dell'oggetto ricevente è nullo
l'oggetto ricevente diventa nullo, se l'oggetto ricevente non è valido allora non sarà modificato */
public void invertiti(){
int nuovoDen;
if(den != 0 && num != 0){
nuovoDen = num;
num = den;
den = nuovoDen;
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/** Eleva alla k-esima potenza l'oggetto ricevente e crea un nuovo oggetto */
public Frazione elevaAPotenza(int k){
int nuovoNum, nuovoDen;
Frazione nuovaFrazione;
if(den != 0){
nuovoNum = (int) Math.pow(num, k);
nuovoDen = (int) Math.pow(den, k);
nuovaFrazione = new Frazione(nuovoNum, nuovoDen);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
nuovaFrazione = new Frazione(0,0);
}
return nuovaFrazione;
}
/** Modifica l'oggetto ricevente rendendolo la sua k-esima potenza se valido */
public void elevatiAPotenza(int k){
if(den != 0){
num = (int) Math.pow(num, k);
den = (int) Math.pow(den, k);
}
else{
System.err.println("Operazione impossibile: frazione non valida");
num = 0;
den = 0;
}
}
/* I metodi corrispondenti agli operatori relazionali */
public boolean equals(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num == F.num && den == F.den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean maggiore(Frazione F){
boolean esito;
double r1, r2; // Per memorizzare i valori razionali delle frazioni
if(den != 0 && F.den != 0){
r1 = getValore(); // Ora r1 contiene il valore razionale dell'ogetto ricevente
r2 = F.getValore(); // Ora r2 contiene il valore razionale del parametro F
esito = r1 > r2;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean maggioreOUguale(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den >= F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean minore(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den < F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public boolean minoreOUguale(Frazione F){
boolean esito;
if(den != 0 && F.den != 0){
esito = num*F.den <= F.num*den;
}
else{
System.err.println("Confronto impossibile: frazione non valida");
esito = false;
}
return esito;
}
public String toString(){ // Trasforma in stringa l'oggetto ricevente e restituisce il riferimento ad un oggetto String
String risposta = ""; // è la stringa da restituire
if(den != 0){
risposta += num + "/" + den;
}
return risposta;
}
/* Il metodo di classe
@param d di tipo float
@return il riferimento ad un oggeto Frazione corrispondente alla rappresentazione di d in forma frazionaria
public static Frazione convertiAFrazione(float d){
String s; // La rappresentazione di d in forma di stringa
int postPunto; // La posizione della virgola decimale in d
int contaDecimali; // Conta il numero di cifre a destra della virgola
int nuovoNum, nuovoDen; // Numeratore e denominatore della frazione
Frazione F; // L'oggetto da restituire
s = String.valueOf(d); // Trasforma d in stringa
if(s.IndexOf(E){
System.err.println("Errore: numero non ammesso);
F = null;
}
else{
if(postPunto >= 0) nDecimali = s.length()-1-postPunto;
else nDecimali = 0;
}
*/
/* Il metodo funzionale */
private void semplificati(){ // Lo dichiaro come private in quanto modifica l'oggetto ricevente e non deve poter essere usato nel main
int segno; // Il segno della frazione
int divisore; // Il fattore di semplificazione
if(den != 0){
segno = OperazioniUtili.calcolaSegno(num*den);
if(num <= 0) num = -num;
if(den <= 0) den = -den;
divisore = OperazioniUtili.calcolaMassimoComuneDivisore(num, den);
num = num/divisore*segno;
den = den/divisore;
}
}
}
OperazioniUtili.java
public class OperazioniUtili{
public static double calcolaValoreAssoluto(double x){
return Math.sqrt(Math.pow(x,2));
}
public static byte calcolaSegno(double x){
byte sign; // è il valore da restituire
if(x != 0) sign = (byte)(x/calcolaValoreAssoluto(x));
else sign = 1;
return sign;
}
public static int calcolaMassimoComuneDivisore(int x, int y){
int r;
int MCD = 0;
if(x<=0 || y<=0){
System.err.println("Input errato: sono richiesti valori positivi");
}
else{
r = x%y;
MCD = y;
while(r>0){
y = MCD;
MCD = r;
r = y%MCD;
}
}
return MCD;
}
}
Grazie
Andrea