[JAVA] Uso delle istanze

[Nikopol]

Ciao a tutti,
sono uno studedente alle prime armi. Sto studiando java da poco e ho il seguente problema da porvi:
Mi è stato dato il main di un programmino e io dovrei seguirlo per scrivere le classi per farlo funzionare. Il punto che non ho mai usato un oggetto direttamente, solitamente trattavo solo i loro metodi separatamente.

Ho riscritto il programmino in modo da semplificarlo il più possibile, così da lasciare solo i passaggi a me non molto chiari.

Il problema è che il metodo "compareTo" mi restituisce come secondo oggetto sempre 0.
E ancora, è necessario usare un altro attributo come quello che ho aggiunto, cioè "nuovoM"?Si potrebbe riscrivere il tutto usando solamente l'attributo "m"?

Un grazie in anticipo.
Ecco a voi il codice:

                        package numerioggetti;

import javax.swing.JOptionPane;

public class Main {

    public static void main(String[] args) {
      Numero n1=null;
      Numero n2=null;
     
      double m=Double.parseDouble(JOptionPane.showInputDialog("inserisci un "
              +"numero: "));
      n1=new Numero (m);
      m=Double.parseDouble(JOptionPane.showInputDialog("inserisci un numero:"));
      n2=new Numero (m);
      n1.somma(n2);
      System.out.print("Somma: "+n1);
      n1.sottrai(n2);
      System.out.print("Sottrazione: "+n1);

      if (n1.compareTo(n2)>0){
          System.out.print("Il numero "+n1+" è maggiore di "+n2);
      }
      else if (n1.compareTo(n2)==0){
          System.out.print("Il numero "+n1+" è uguale a "+n2);
      }
      else{
          System.out.print("Il numero "+n1+" è minore di "+n2);
      }
    System.exit(0);
    }

}
class Numero {
    public Numero (double m){
        this.m=m;
    }
    private double m;
    private double nuovoM;
    public double getM (){
        return m;
    }
    public double somma (Numero unM){
        nuovoM=m+unM.getM();
        return nuovoM;
    }
    public double sottrai (Numero unM){
        nuovoM=m-unM.getM();
        return nuovoM;
    }
    public int compareTo (Numero unM){
        int x=0;
        nuovoM=m;
        if (nuovoM<unM.getM()){
            x=-1;
        }
        else if (nuovoM==unM.getM()){
             x=0;
        }
        else if (nuovoM>unM.getM()){
            x=1;
        }

        return x;

    }
    @Override
    public String toString(){
        return nuovoM+"\n";
    }
}

[andbin]

Originariamente inviato da Nikopol

class Numero {
    public Numero (double m){
        this.m=m;
    }
    private double m;
    private double nuovoM;
    public double getM (){
        return m;
    }
    public double somma (Numero unM){
        nuovoM=m+unM.getM();
        return nuovoM;
    }
    public double sottrai (Numero unM){
        nuovoM=m-unM.getM();
        return nuovoM;
    }
    public int compareTo (Numero unM){
        int x=0;
        nuovoM=m;
        if (nuovoM<unM.getM()){
            x=-1;
        }
        else if (nuovoM==unM.getM()){
             x=0;
        }
        else if (nuovoM>unM.getM()){
            x=1;
        }

        return x;

    }
    @Override
    public String toString(){
        return nuovoM+"\n";
    }
}

Tralasciamo per un momento la classe Main e concentriamoci sulla classe Numero che ha alcune cose che non vanno.

Innanzitutto la classe Numero ha lo scopo di "modellare" 1 numero ... non 2. Quindi non devi avere 2 campi di istanza ma 1 solo.

Poi quando si devono compiere delle "operazioni" come somma/sottrai, a livello concettuale ci sono (tipicamente) due modi per gestire la modifica lavorando a livello di oggetti:

Modo 1)
I metodi somma/sottrai modificano lo "stato" dell'oggetto su cui sono invocati. Quindi ad esempio:

public void somma(Numero unM) { ..... }

e invocando: num1.somma(num2);

Lo stato di num1 si aggiorna con il risultato di num1+num2

Modo 2)
I metodi somma/sottrai restituiscono un nuovo oggetto Numero senza alterare né lo stato dell'oggetto su cui sono invocati, né quello passato come argomento. Ad esempio:

public Numero somma(Numero unM) { ..... }

e invocando: Numero numSomma = num1.somma(num2);

si ottiene un nuovo oggetto Numero con la somma senza alterare num1 e num2.

Tieni bene a mente queste questioni concettuali.


Il compareTo come forma del metodo può anche andare bene. Tieni però presente che esiste la interfaccia Comparable che ha proprio il compareTo. Questo però è per generalizzare la comparazione degli oggetti. Non sei certo obbligato a sfruttare tutto questo. Insomma, il tuo compareTo è solo un metodo come gli altri.

Tecnicamente mi pare corretto il compareTo, salvo il fatto che si potrebbe compattare di più.

I punti più importanti che dovresti sistemare sono i due iniziali: il fatto che deve avere solo 1 campo e la questione delle operazioni somma/sottrai.

[Nikopol]

Ti ringrazio dei consigli ma il problema rimane.
Anche se ho semplificato il main, rimane sempre quello scritto dal mio professore e quindi non posso modificarlo.
E' questo il punto: se cambio lo stato dell'oggetto posso fare la somma ma la sottrazzione e tutto il resto ne risulteranno innfluenzati; invece assegnare ad un nuovo oggetto il risultato della somma e della sottrazionemodo sarebbe il modo più semplice, però come già detto non posso assolutamente modificare il main. Proprio per questo motivo ho provato ad usare un attributo in più, anche se con scarsi risultati.
Sono giorni che sto impazzendo dietro a questo problema; non riesco proprio a capire dove sto sbagliando.

[satifal]

Originariamente inviato da Nikopol
Ti ringrazio dei consigli ma il problema rimane.
Anche se ho semplificato il main, rimane sempre quello scritto dal mio professore e quindi non posso modificarlo.
E' questo il punto: se cambio lo stato dell'oggetto posso fare la somma ma la sottrazzione e tutto il resto ne risulteranno innfluenzati; invece assegnare ad un nuovo oggetto il risultato della somma e della sottrazionemodo sarebbe il modo più semplice, però come già detto non posso assolutamente modificare il main. Proprio per questo motivo ho provato ad usare un attributo in più, anche se con scarsi risultati.
Sono giorni che sto impazzendo dietro a questo problema; non riesco proprio a capire dove sto sbagliando.

Non capisco qual'è il problema. Se il main è quello e non può essere modificato allora vuol dire semplicemente che effettui prima la somma e poi la sottrazione per cui alla fine il primo numero conterrà il valore iniziale.
L'istanza della classe Numero contiene un unico valore che può essere incrementato o diminuito.
Un codice compatibile con il main che ti è stato dato è il seguente:

package numerioggetti;

import javax.swing.JOptionPane;

public class Main {

	public static void main(String[] args) {
		Numero n1 = null;
		Numero n2 = null;

		double m = Double.parseDouble(JOptionPane.showInputDialog("inserisci un " + "numero: "));
		n1 = new Numero(m);
		m = Double.parseDouble(JOptionPane.showInputDialog("inserisci un numero:"));
		n2 = new Numero(m);
		n1.somma(n2);
		System.out.print("Somma: " + n1);
		n1.sottrai(n2);
		System.out.print("Sottrazione: " + n1);

		if (n1.compareTo(n2) > 0) {
			System.out.print("Il numero " + n1 + " è maggiore di " + n2);
		} else if (n1.compareTo(n2) == 0) {
			System.out.print("Il numero " + n1 + " è uguale a " + n2);
		} else {
			System.out.print("Il numero " + n1 + " è minore di " + n2);
		}

		System.exit(0);
	}
	
	static class Numero {
		
		private double value;
		
		public Numero(double n) {
			value = n;
		}
		
		public void somma(Numero n) {
			value += n.getValue();
		}
		
		public void sottrai(Numero n) {
			value -= n.getValue();
		}
		
		public int compareTo(Numero n) {
			if (value < n.getValue()) {
				return -1;
			} else if (value > n.getValue()) {
				return 1;
			} 
			return 0;
		}

		public double getValue() {
			return value;
		}
		
		@Override
		public String toString() {
			return String.valueOf(value) + "\n";
		}
		
	}

}

[Patrick Jane]

@Nikopol: mi sembrava di aver già visto il tuo codice in rete. Guarda qui: http://hackerforum.globalfreeforum.c...p?f=47&t=14232 (lol)

[Nikopol]

@ Patrik Jane: Avevo postato anche su quel forum ma dopo diversi giorni senza nessuna risposta, ho deciso di iscrivermi quà da voi. Fra l'altro ora è offline.

@ satifal: Scusa ma non riesco a capire: il problema è che nella tua classe, la sottrazzione non sottrae m dell'oggetto n1 alla m dell' oggetto n2, bensì sottrae la somma delle m alla m dell'oggetto n2.
Es. m vale 2 e 1. La somma sarà 3 cioè 2+1, però la sottrazione sarà 2 cioè 2+1-1 invece che
1 cioè 2-1.

Scusate se ho la testa dura ma sto studiando java solo da un paio di mesi.
Garzie dell'aiuto.

[VincenzoTheBest]

Originariamente inviato da Nikopol
non sottrae m dell'oggetto n1 alla m dell' oggetto n2, bensì sottrae la somma delle m alla m dell'oggetto n2.

Se intendi che una volta istanziati n1 e n2, vuoi poter fare
n1 + n2
n1 - n2
senza che n1 venga modificato dalla prima somma,
hai due strade:
1) la seconda implementazione suggerita da andbin.
2) oppure continui ad utilizzare l'implementazione nel post precedente, ma in quel caso devi clonare n1 in modo da salvare la sua prima configurazione:

...
Numero clone_n1 = n1.clone();
n1.somma( n2 );
clone_n1.sottrai( n2 );
...

per poter fare ciò la classe Numero deve implementare l'interfaccia Cloneable e fare l'override del metodo clone ereditato dalla superclasse Object.
In questo caso l'override consiste semplicemente nel richiamare all'interno del corpo del metodo quello "originale" della superclasse Object.

[satifal]

Originariamente inviato da Nikopol
...
@ satifal: Scusa ma non riesco a capire: il problema è che nella tua classe, la sottrazzione non sottrae m dell'oggetto n1 alla m dell' oggetto n2, bensì sottrae la somma delle m alla m dell'oggetto n2.
Es. m vale 2 e 1. La somma sarà 3 cioè 2+1, però la sottrazione sarà 2 cioè 2+1-1 invece che
1 cioè 2-1.
...

Forse non hai ben chiara la OOP o comunque l'utilizzo degli oggetti. Innanzitutto il tuo professore ti ha dato un main dicendoti di implementare gli oggetti utilizzati in esso.
Il codice che ti ho postato fa proprio questo. Non mi sembra che nessuno ti abbia chiesto di salvare il valore originale dell'istanza n1 della classe Numero.
La classe Numero è, come il nome stesso suggerisce, la rappresentazione di un numero double che ti fornisce delle operazioni elementari su tale numero come la somma, la sottrazione ed il confronto. Ora, se tu istanzi un oggetto di questo tipo (vedi ad esempio n1) gli assegnerai un valore iniziale m, per cui esso rappresenterà il numero m. Se a questo punto tu applichi l'operazione di addizione mediante l'utilizzo del metodo somma() aggiungerai al numero n1 il valore rappresentato dal numero n2 e lo stesso vale per la sottrazione applicata mediante l'invocazione del metodo sottrai() il quale sottrarrà al numero n1 il valore del numero n2.
Per concludere, in base al main che ti è stato dato, prima viene effettuata un'addizione e poi una sottrazione della stessa quantità.

[Nikopol]

Ciao.

Non mi sembra che nessuno ti abbia chiesto di salvare il valore originale dell'istanza n1 della classe Numero.

Ora che me lo fai notare hai ragione. Ho frainteso completamente il senso del main. Ero convinto di dover fare la somma e la sottrazione senza savrascrivere m.
Sono impazzito su un problema che neanche esisteva.
In definitiva ho scritto questa per la scuola:

package numerioggetti;

public class Numero {
    public Numero (double m){
        this.m=m;
    }
    private double m;
    public double getM (){
        return m;
    }
    public void somma (Numero unM){
        m+=unM.getM();
    }
    public void sottrai (Numero unM){
        m-=unM.getM();
        
    }
    public int compareTo (Numero unM){
        return m<unM.getM() ? -1 : m==unM.getM() ? 0 : 1;

    }
    @Override
    public String toString(){
        return m+"\n";
    }
}

mentre per togliermi la pulce dall'orecchio, ho cambiato il main per fargli fare quello che volevo all' inizio.
Ecco il codice:

package numerioggetti;

import javax.swing.JOptionPane;

public class Main {

    public static void main(String[] args) {
    Numero n1=null;
    Numero n2=null;
    Numero nX=null;
    double m=Double.parseDouble(JOptionPane.showInputDialog("inserisci un "
            +"numero:"));
    n1=new Numero (m);
    m=Double.parseDouble(JOptionPane.showInputDialog("inserisci un numero:"));
    n2=new Numero (m);
    nX= n1.somma(n2);
    System.out.print("Somma "+nX);
    nX=n1.sottrai(n2);
    System.out.print("Sottrazione "+nX);

    if (n1.compareTo(n2)>0){
        System.out.print("Il numero "+n1+" è maggiore di "+n2);
    }
    else if (n1.compareTo(n2)==0){
        System.out.print("Il numero "+n1+" è uguale a "+n2);
    }
    else{
        System.out.print("Il numero "+n1+" è minore di "+n2);
    }
    System.exit(0);
    }

}
class Numero {
    public Numero (double m){
        this.m=m;
    }
    private double m;
    public double getM (){
        return m;
    }
    public Numero somma (Numero unM){
        Numero nX= new Numero (m+unM.getM());
        return nX;
    }
    public Numero sottrai (Numero unM){
        Numero nX= new Numero(m-unM.getM());
        return nX;
        
    }
    public int compareTo (Numero unM){
        return m<unM.getM() ? -1: m==unM.getM() ? 0 : 1;

    }
    @Override
    public String toString(){
        return m+"\n";
    }
}

Grazie a tutti dell'aiuto dato.
Ciao

[satifal]

Solamente un appunto, io modificherei il nome del metodo getM(). Come detto in oprecedenza, L'oggetto numero è la rappresentazione di un numero di tipo double con le operazioni elementari somma(), sottrai() e compare() il cui nome dei metodi che le implementano indicano in maniera chiara l'operazione da effettuare. Premesso ciò, una persona che un domani dovrà utilizzare la classe numero come farebbe ad intuire che per ottenere il valore rappresentato dall'istanza deve invocare il metoto getM()? Sarebbe più logico e naturale chiamarlo getValue() oppure getValore() che è moltop più intuitivo.