Calcolo e restituzione del punto centrale di un rettangolo

di il
9 risposte

Calcolo e restituzione del punto centrale di un rettangolo

Salve a tutti gli utenti.
Vorrei possibilmente aprire questo piccolo topic per avere qualche opinione in merito a questo pezzo di codice postato adesso qui sotto;

/* metodo d'istanza che calcola e restituisce il punto centrale
di un rettangolo */
import java.awt.Rectangle;
import java.awt.Point;
import fiji.io.*;
class RectPoint {
//variabili d'istanza
int x; //ascissa punto di definizione rettangolo
int y; //ordinata punto di definizione rettangolo
int height; //lunghezza
int width; //larghezza
double centro; //punto centrale
//costruttore rettangolo
public RectPoint() {
Rectangle rettangolo;
rettangolo=new Rectangle(int x, int y, int width, int height);
System.out.println("scrivi le due coordinate x e y del punto");
this.x=Lettore.in.leggiInt();
this.y=Lettore.in.leggiInt();
System.out.println("quanto vuoi farlo largo?");
this.width=Lettore.in.leggiInt();
System.out.println("quanto vuoi farlo lungo?");
this.height=Lettore.in.leggiInt();
System.out.println("il punto centrale del rettangolo è" +rettangolo.centro);
}
//metodi d'istanza
public double centro() {
x=this.x+width/2;
y=this.y+height/2;
return (x) && (y);
}
}


La richiesta è il calcolo e la restituzione del punto centrale di un rettangolo attraverso un metodo d'istanza punto centro() .
Quando compilo mi da errore.
Penso possa essere legato ai parametri formali dell'oggetto istanza ma non ne sono per niente sicuro e probabilmente potrebbe esserci più di un singolo errore. C è bisogno che posti anche i risultati del compilatore? In caso basta chiedere;
Spero possiate fornirmi delucidazioni così da schiarirmi un poco le idee. Non sia mai che riesca a venirne a capo.

Grazie Molte
Cordiali Saluti

9 Risposte

  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Ciao, diversi problemi sono qui:
    
    public double centro() {
       x=this.x+width/2;
       y=this.y+height/2;
       return (x) && (y);
    }
    
    Innanzitutto c'è proprio un problema concettuale: quello che immagino tu voglia fare è restituire due valori (ovvero la x e la y) attraverso un metodo, ma ciò non è possibile. Ogni metodo, infatti, può e deve restituire solamente un solo valore (a parte i metodi void, che non restituiscono nulla).
    Nello specifico per come è definito il metodo "centro()", esso deve restituire solamente un valore di tipo double.
    Quello che specifichi col return, invece, è di restituire l'and logico fra i valori contenuti nelle due variabili x ed y.

    Il compilatore giustamente ti segnala che l'operatore && (che significa "and logico") non è applicabile fra double.

    In secondo luogo, se anche quell'operazione fosse valida, il suo risultato sarebbe un boolean, cosa in contraddizione con la signature del metodo.

    In terzo luogo non hai definito delle variabili locali chiamate x ed y (e questo non è un errore in sé) per cui il metodo va a cercare (e sovrascrivere) le varibili d'istanza (e neanche questo in sé è un errore). L'errore sta nel fatto che, dopo aver invocato il metodo centro(), avrai perso per sempre l'ascissa e l'ordinata del "punto di definizione rettangolo".

    Come fare quindi per restituire due valori con un solo metodo?
    A questa domanda esistono numerose risposte:
    • potresti dividere il calcolo del centro in due metodi, che calcolano rispettivamente l'ascissa e l'ordinata del punto centrale
    • potresti restituire un array di valori, in cui ad esempio il primo è l'ascissa e il secondo l'ordinata
      
      public double[] calcolaCentro(){
         double result[] = new double[2];
         result[0] = this.x + width/2;
         result[1] = this.y + height/2;
         return result;
      }
      
    • creare un tipo di dato per rappresentare il concetto di "punto"
      
      public class Punto {
         private double x,y;
      
         public Punto(double x, double y) {
            this.x = x;
            this.y = y;
         }
      
         // qua sotto bisogna creare i getters e setters
         ...
      }
      
    Infine avrei un consiglio: cerca di separare le entità. Infatti hai creato una classe RectPoint per definire un punto di un rettangolo immagino, ma poi hai messo dentro ad essa anche i concetti di larghezza e centro, che sono relativi al concetto di rettangolo.
    Quello che ti suggerisco, quindi, è di creare due classe distinte, una per rappresentare i punti ed una per rappresentare i rettangoli. Un prototipo per quella del punto è mostrato sopra, mentre per un rettangolo potrebbe essere qualcosa di simile
    
    public class Rect {
       private double width, height;
       private Punto centro;
       private Punto inizio; //Punto di definizione del rettangolo
    
       public Rect(double width, double height, Punto x, Punto y) {
          // logica di creazione del rettangolo
          ....
          //calcolo il centro
          calcolaCentro();
       }
    
       private void calcolaCentro() {
          private double x,y;
          x = this.x + width/2;
          y = this.y + height/2;
          centro = new Punto(x,y);
       }
    }
    
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Ciao Della; Vorrei cominciare col ringraziati per il tempo da te concessomi.

    Il tuo aiuto e i tuoi consigli sono stati molto esaustivi; nonostante mi abbia sollevato da molti dubbi e mi abbia aiutato a capire che ero veramente molto lontanto dalla soluzione del problema, ci sono ancora alcune cose che non sono chiare:

    1)
    private void calcolaCentro() {
    private double x,y;
    x = this.x + width/2;
    y = this.y + height/2;
    centro = new Punto(x,y);
    }
    I primi membri delle somme relative all'assegnazione dei valori alle due variabili x e y (rispettivamente this.x e this.y) si riferiscono alle variabili d'istanza ( da specificare quindi eventualmente) o alle coordinate della classe punto?
    1.a) Come mai viene scelto "void"? Non dovrebbe essere double il tipo di valore di ritorno, ovvero il centro del rettangolo, con annesso comando di return?

    2) Essendo esplicitamente la richiesta dell'esercizio SOLO il calcolo e la restituzione (e non la stampa) del punto , c è la possibilità che l'operazione di lettura dati di input e stampa dei valori di ritorno possa interferire con l'esecuzione del programma? e se no, è sempre possibile in un metodo poter leggere i dati di input che vengono richiesti per le operazioni da noi definite e, una volta restituiti i valori(se il metodo li restituisce) poterli stampare su schermo o dipende solo dalla richiesta realizzativa?

    3)Dovendo il programma partire da un metodo statico, pubblico, main, c è bisogno di creare un metodo di classe? (sicuramente può sembrare un'osservazione abbastanza banale, ma essendo una delle prime volte che programmo con più Classi al contempo vorrei cercare di capire al meglio)

    4)Relativamente alla conclusione del terzo punto vorrei chiederti inoltre se una volta definite le due classi, ho bisogno di salvarle nella stessa directory per far si che "cooperino"

    Infine ti posto ora qui sotto il codice modificato e mi appello nuovamente alla tua disponibilità e gentilezza

    /* metodo d'istanza che calcola e restituisce il punto centrale
    di un rettangolo */
    import java.awt.Rectangle;
    import fiji.io.*;
    public class Rect {
    //variabili d'istanza
    private double width, height;
    private Punto centro;
    private Punto inizio; //Punto di definizione del rettangolo
    //costruttore rettangolo
    public Rect(double width, double height, Punto x, Punto y) {
    System.out.println("scrivi le due coordinate x e y del punto");
    inizio= new Punto(x,y); //punto iniziale
    System.out.println("quanto vuoi farlo largo?");
    this.width=Lettore.in.leggiDouble();
    System.out.println("quanto vuoi farlo lungo?");
    this.height=Lettore.in.leggiDouble();
    //calcolo il centro
    calcolaCentro();
    }

    private void calcolaCentro() {
    private double x,y;
    x = this.x + width/2;
    y = this.y + height/2;
    centro = new Punto(x,y);
    }
    public string toString() {
    return "il centro del rettangolo è: " +centro;
    }
    }


    /*rappresentazione di un punto su un piano bidimensionale*/
    import java.awt.Point;
    public class Punto {
    //variabili d'istanza
    private double x,y;
    //costruttore punto
    public Punto(double x, double y) {
    this.x = x; //ascissa del punto
    this.y = y; //ordinata del punto
    }
    //metodi d'istanza

    //restituzione x di questo punto:
    public double getX() {
    return this.x;
    }
    //restituzione y di questo punto
    public double getY() {
    return this.y;
    }


    }

    P.S: compilate le due classi ottengo ancora un'errore per rect.java
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Ciao, provo a risponderti per punti:
    1) si tratta di un errore di copia&incolla, ovviamente la classe Rect non ha variabili d'istanza x e y, per cui bisognerebbe utilizzare l'oggetto "inizio".
    
    private void calcolaCentro() {
    private double x,y;
    x = inizio.getX() + width/2; 
    y = inizio.getY()+ height/2;
    centro = new Punto(x,y);
    }
    
    1.a) se l'obiettivo dell'esercizio è di creare un metodo che calcoli il centro allora serve un metodo non void, come dici tu. Il metodo che ho utilizzato io è utilizzato solo per non appesantire troppo il costruttore. Attenzione però: ogni metodo può restituire al massimo un valore, per cui restituendo un double il problema non sarebbe risolto: infatti, come è possibile restituire due punti attraverso una singola variabile double? E qui si possono usare le tecniche che ho elencato prima, oppure altre se te ne vengono in mente

    2) in generale l'acquisizione o stampa di dati non dovrebbe interferire con il programma, a patto che l'acquisizione avvenga nel modo corretto. In questo esercizio i dati sono dei numeri, che puoi specificare direttamente nel codice oppure prendere da tastiera. In quest'ultimo caso ci sono diverse cose da tenere in considerazione, ad esempio cosa succede se l'utente inserisce delle lettere? Oppure se il numero è troppo grande per essere contenuto in un double? In generale l'acquisizione dei dati è più delicata, mentre l'output è meno problematico.

    3) non ho capito la domanda! In generale, comunque, la classe principale (quella che contiene il main) conterrà anche la logica di creazione dei vari oggetti, come ad esempio i punti e i rettangoli

    4) non devono necessariamente essere nello stesso package/directory, ma se sono in posti diversi è necessario specificarlo durante la compilazione ed esecuzione attraverso il parametro -cp dei comandi javac e java (se compili da un IDE dovrebbe essere automatico)

    5) al momento non dispongo di un PC quindi non posso testare il codice, ma sicuramente un errore di compilazione deriva dalla svista del punto 1!

    Ultima cosa: quando incolli del codice qua nei post assicurati di usare il tag "code" per migliorarne la leggibilità
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Per i primi 2 punti e il quarto non potevi essere più chiara di quanto non lo abbia fatto rispondendomi.
    La mia terza domanda rimane un incognita, ma è giusto che lo sia, sicuramente per merito, o per sfortuna, del mio scarso esercizio.. Come ti ho detto, ragiono ancora abbastanza meccanicamente riguardo la definizione del metodo "main".
    Dopo avere ulteriormente modificato il codice però, rimane ancora sconosciuta la natura dell'errore nella classe Rect.java; Suppongo che dovrei evitare di fossilizzarmi su quest'esercizio e ritornarci, una volta in grado di riconoscere l'errore a vista d'occhio. Grazie MIlle ancora
    /* metodo d'istanza che calcola e restituisce il punto centrale
    di un rettangolo */
    import java.awt.Rectangle;
    import fiji.io.*;
    public class Rect {
       //variabili d'istanza
       private double width, height;
       private Punto centro;
       private Punto inizio; //Punto di definizione del rettangolo
       //costruttore rettangolo
       public Rect(double width, double height, Punto x, Punto y) {
    	  System.out.println("scrivi le due coordinate x e y del punto");
    	  calcolaInizio();
    	  System.out.println("quanto vuoi farlo largo?");
    	  this.width=Lettore.in.leggiDouble();
    	  System.out.println("quanto vuoi farlo lungo?");
          this.height=Lettore.in.leggiDouble();
          //calcolo il centro
          calcolaCentro();
       }
    
       private void calcolaInizio() {
    	  private double x,y;
    	  x = Lettore.in.leggiInt;
    	  y = Lettore.in.leggiInt;
    	  inizio = new Punto(x,y);
      }
       private void calcolaCentro() {
          private double x,y;
          x = inizio.getX()+ width/2;
          y = inizio.getY()+ height/2;
          centro = new Punto(x,y);
       }
       public string toString() {
    	   return "il centro del rettangolo è: " +centro;
    }
       public static void main (String[] args) {
    	   System.out.println("descrivi il rettangolo");
       }
    }
    
    Per esattezza penso che al compilatore non vada a genio le dichiarazioni dello stato del metodo
    C:\Users\Luca\Documents\Esercizi Java\Punto centro\Rect.java:23: illegal start of expression
    	  private double x,y;
              ^
    C:\Users\Luca\Documents\Esercizi Java\Punto centro\Rect.java:29: illegal start of expression
          private double x,y;
          ^
    2 errors
    
    Tool completed with exit code 1
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Ora che ho un pc sotto mano posso risponderti in modo più adeguato
    In effetti l'errore è quello che dici tu! C'è un errore nella definizione delle variabili locali al metodo: in particolare si tenta di definire come "private" delle variabili locali al metodo, cosa evidentemente insensata. Infatti, le uniche variabili che possono essere definite private (o pubbliche o altro) sono quelle d'istanza, ovvero le uniche che possono essere accedute al di fuori della classe stessa.

    Riguardo al punto 3: nel main devi mettere tutte le operazioni di setup e avvio del programma: quindi se si tratta di un programma con GUI, ad esempio, dovranno essere inizializzate le classi relative alla grafica e i vari parametri, caricare i dati principali e mostrare la GUI stessa.
    Nel programma del tuo esercizio, invece, sarà necessario creare dei rettangoli e mostrarne il centro, quindi grosso modo bisognerà fare le seguenti operazioni:
    • Ottenere in qualche modo il punto di inizio dei rettangoli e le sue dimensioni: se i punti sono specificati direttamente nel codice allora la questione è semplice, altrimenti se vanno letti da tastiera o da file bisognerà creare le istanze delle classi che hanno il compito di fare ciò
    • A partire dai punti e dalle dimensioni bisogna creare i rettangoli
    • bisogna calcolare il centro ed eventualmente stamparlo in output.
    In sostanza qualcosa del genere:
    
    public class Main {
    
    	public static void main(String[] args) {
    		Punto p1 = new Punto(0, 0);
    		Rect r1 = new Rect(p1, 20, 10);
    		System.out.println(r1.calcolaCentro());
    	}
    }
    
    Una piccola annotazione:
    Mandando in esecuzione il programma noterai un output strano, e diverso da ciò che ti aspettavi. Questo accade perché quando viene passato un oggetto al metodo "println" allora viene invocato automaticamente sull'oggetto il metodo "toString()". In sostanza le due seguenti righe si equivalgono:
    
    System.out.println(r1.calcolaCentro());
    
    System.out.println(r1.calcolaCentro().toString());
    
    Dato che nella classe Punto non è stato definito tale metodo, allora viene utilizzato quello ereditato dalla classe Object, ed è questo il motivo per cui viene stampata quella stringa strana. Come fare, quindi, per stampare qualcosa di più comprensibile? Semplicemente basta ridefinire (cioè effettuare l'override) del metodo toString nella classe Punto:
    
    
    public class Punto {
    	private double x,y;
    	
            ...
    
    	@Override
    	public String toString() {
    		return "["+x+" ; "+y+"]";
    	}
    }
    
    In questo modo verrà stampato qualcosa nella forma: [10.0 ; 5.0]
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Per risolvere il problema legato alla restituzione di due valori con un solo metodo, non avendo ancora svolto la parte di corso sugli array, ho preso alla lettera il tuo primo consiglio e ho cercato di dividere in due parti il metodo per il riconoscimento dell'ascissa e dell'ordinata del punto centrale.

    public class Main {
    
       public static void main(String[] args) {
          Punto p1 = new Punto(0, 0);
          Rect r1 = new Rect(p1, 20, 10);
          System.out.println(r1.calcolaCentro());
       }
    }
    
    Da questo ho presupposto la creazione di una classe main che gestisce l'interfaccia GUI ma non saprei assolutamente come caratterizarla.
    Infine ti posto qui il nuovo codice, non sapendo però se mi sia effettivamente allontanato o avvicinato più di tanto alla soluzione
    public class Main {
    
       public static void main(String[] args) {
          //visualizzazione rettangolo//
          ...
          //come visualizzare le specifiche del rettangolo?
          ...
          //visualizzare il centro
      }
    }
    
    
    /* metodo d'istanza che calcola e restituisce il punto centrale
    di un rettangolo */
    import java.awt.Rectangle;
    import fiji.io.*;
    public class Rect {
       //variabili d'istanza
       private double width, height;
       private Punto centro;
       private punto centrox, centroy;
       private Punto inizio; //Punto di definizione del rettangolo
       //costruttore rettangolo
       public Rect(Punto inizio, double width, double height) {
    
       //calcolo base del rettangolo
    
        public double base() {
          Rect.width=Lettore.in.leggiInt();
          return width;
      }
        //calcolo altezza del rettangolo
    
        public double altezza() {
          Rect.height=Lettore.in.leggiInt();
          return height;
      }
    
      //calcola punto di inizio definizione rettangolo
    
        private void calcolaInizio() {
      	  double x,y;
      	  x = Lettore.in.leggiInt;
      	  y = Lettore.in.leggiInt;
    	  inizio = new Punto(x,y);
      }
    }
    
        //calcolo centro
    
       public double calcolaCentrox() {
          double x,y;
          x = inizio.getX()+ width/2;
          y = 0;
          centrox= new Punto (x,y);
          return x;
      }
       public double calcolaCentroy() {
    	  double y,x;
    	  x = 0;
          y = inizio.getY()+ height/2;
          centroy= new Punto (x,y);
          return y;
      }
       }
    
    
    /*rappresentazione di un punto su un piano bidimensionale*/
    import java.awt.Point;
    public class Punto {
    	//variabili d'istanza
       private double x,y;
       //costruttore punto
       public Punto(double x, double y) {
          this.x = x; //ascissa del punto
          this.y = y; //ordinata del punto
       }
       //metodi d'istanza
    
       //restituzione x di questo punto:
       public double getX() {
    		 return this.x;
    	 }
       //restituzione y di questo punto
       public double getY() {
    	     return this.y;
    	 }
    }
    
    
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    lukyluke93 ha scritto:


    Da questo ho presupposto la creazione di una classe main che gestisce l'interfaccia GUI ma non saprei assolutamente come caratterizarla.
    No, quel main funzionava con il codice che avevo proposto, non era per una GUI

    lukyluke93 ha scritto:


    Infine ti posto qui il nuovo codice ...
    Hai creato 2 punti "centrox" e "centroy" per due sole coordinate (riempiendo l'altra con un valore zero)..Avresti dovuto usare due double per rappresentare le sole coordinate, oppure il metodo calcolaCentro avrebbe dovuto restituire 1 oggetto di tipo Punto.

    Infine per quanto riguarda l'acquisizione dell'input per la costruzione dell'oggetto personalmente avrei fatto diversamente (mettendo la logica di acquisizione da tastiera direttamente nel main e lasciando il costruttore più semplice) ma si tratta di scelte di progettazione..

    Scusa se è una risposta poco esaustiva ma sono da cellulare


    Sent from my iPhone using Tapatalk
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Hai creato 2 punti "centrox" e "centroy" per due sole coordinate (riempiendo l'altra con un valore zero)..Avresti dovuto usare due double per rappresentare le sole coordinate, oppure il metodo calcolaCentro avrebbe dovuto restituire 1 oggetto di tipo Punto.
    Ho pensato che per servirmi dell'ascissa e dell'ordinata del punto Centro avrei potuto creare due punti distinti e prendere da ognuno le coordinate che mi servivano; é esatto come ragionamento o ho solo spostato il problema?
    Ho inoltre provato a usare il metodo calcolaCentro così che prendesse come ascissa quella di calcolaCentrox e come ordinata quella di calcolacentroy in questa forma (più che probabilmente errata) :
    public double calcolaCentro() {
    	  centro= new Punto(calcolaCentrox.getX(),calcolaCentroy.getY())
    	  return centro;
    non avrei ottenuto però un "Punto" ansiche due double? e come avrei potuto fare, ammettendo che sia lecito scrivere quello che ho scritto, far stampare in seguito le due coordinate?
    No, quel main funzionava con il codice che avevo proposto, non era per una GUI
    allora sono proprio fuori strada
  • Re: Calcolo e restituzione del punto centrale di un rettangolo

    Beh per funzionare funziona, però non è molto corretto a livello concettuale. In pratica crei 2 punti "fittizi" per utilizzarne solo una coordinata. E' una possibile soluzione, ma di sicuro non la migliore.
    Ho inoltre provato a usare il metodo calcolaCentro così che prendesse come ascissa quella di calcolaCentrox e come ordinata quella di calcolacentroy in questa forma (più che probabilmente errata)
    E' errata per diversi motivi: "calcolaCentrox" è un metodo, per cui la sintassi corretta sarebbe:
    
    public double calcolaCentro() {
         centro= new Punto(calcolaCentrox().getX(),calcolaCentroy().getY())
         return centro;
    
    cioè mancavano le parentesi tonde.

    In secondo luogo (ma questo è un errore più "grave") hai definito "calcolaCentrox" come un metodo che restituisce un double, ma nella sua implementazione gli fai restituire un oggetto di tipo Punto. Se, quindi, modifichi il tipo di dato restituito dal metodo allora ottieni ciò che volevi (e, presumibilmente, qualcosa che funziona). Lo stesso ovviamente vale anche per il metodo "calcolaCentroy".

    Per quanto riguarda il main, invece, quanto ti ho scritto non dovrebbe differire molto da quello che hai attualmente tu..no?
Devi accedere o registrarti per scrivere nel forum
9 risposte