Calcolo della distanza tra due punti

Devo creare una class che calcoli la distanza tra due punti. Sono bloccato e sono un principiante assoluto. Ecco le mie classi:

package org.totalbeginner.tutorial; public class Point { public double x; public double y; Point(double xcoord, double ycoord){ this.x = xcoord; this.y = ycoord; } public double getX() { return x; } public double getY() { return y; } } 

La seconda class.

 package org.totalbeginner.tutorial; public class Line { double x; double y; Point p1 = new Point(2.0,2.0); Point p2 = new Point(4.0,4.0); Point mp = new Point(x,y); public void midpoint() { x = (p1.getX() + p2.getX()) / 2; y = (p1.getY() + p2.getY()) / 2; } } 

Non sono sicuro di come ottenere un object punto (il punto medio) tra entrambi i punti definiti.

Posso creare oggetti punto, ma non sono sicuro di come restituire un object punto attraverso il mio metodo midpoint() che si trova tra questi due oggetti punto.

La distanza tra due punti (x1, y1) e (x2, y2) su una superficie piana è:

  ____________________ / 2 2 \/ (y2-y1) + (x2-x1) 

Ma, se tutto ciò che vuoi è il punto medio dei tuoi due punti, dovresti cambiare la funzione del punto medio in:

 public Point midpoint (Point p1, Point p2) { return new Point ((p1.getX() + p2.getX()) / 2, (p1.getY() + p2.getY()) / 2); } 

Ciò restituirà un object punto nuovissimo con i punti impostati al centro dei due punti indicati (senza doversi preoccupare di altri calcoli matematici). E poiché la tua seconda class è una linea, hai solo bisogno dei due punti finali per descriverla, quindi apporterei alcune modifiche minori.

Primo Point.java :

 class Point { double x, y; Point (double xcoord, double ycoord) { this.x = xcoord; this.y = ycoord; } public double getX() { return x; } public double getY() { return y; } } 

Quindi Line.java :

 public class Line { Point p1, p2; Line (Point point1, Point point2) { this.p1 = point1; this.p2 = point2; } public Point midpoint() { return new Point ((p1.getX()+p2.getX())/2, (p1.getY()+p2.getY())/2); } public double abstand() { return Math.sqrt( (p1.getX() - p2.getX()) * (p1.getX() - p2.getX()) + (p1.getY() - p2.getY()) * (p1.getY() - p2.getY()) ); } static public void main (String args[]) { Line s = new Line (new Point(2.0, 2.0), new Point(5.0, 6.0)); Point mp = s.midpoint(); System.out.println ("Midpoint = (" + mp.getX() + "," + mp.getY() + ")"); double as = s.abstand(); System.out.println ("Length = " + as); } } 

Questi due file, quando sono compilati e corrono con gli endpoint 2,2 e 5,6 (l’ipotenusa di un classico triangolo rettangolo 3/4/5), generano il corretto:

 Midpoint = (3.5,4.0) Length = 5.0 

Simple Pythag … root (dx ^ 2 + dy ^ 2)

 Math.sqrt(Math.pow((p2.getX() - p1.getX()), 2) + Math.pow((p2.getY() - p1.getY()), 2)) 
  X + |\ | \ a| \c | \ | \ +-----+ b Y 

Immagina che X e Y siano i tuoi punti su una superficie piana. Quindi a è Xy - Yy e b è Yx - Xx . La lunghezza di c è la loro distanza, ed è la lunghezza dell’ipotenusa di quel triangolo. È calcolato usando

 sqrt(a^2 + b^2); 

Dal momento che vedete che stiamo squadrando b , il loro segno non è rilevante – arriverà allo stesso modo. Quindi questo metodo funziona sempre, dove mai i punti si trovano.

Cerca il Pythagorean theorem

Hai davvero bisogno della distanza o stai cercando di ottenere il punto medio? Perché dal tuo snippet di codice, sembra che tu voglia solo creare un nuovo punto che si trova a metà strada tra due punti esistenti.

Se sei davvero solo dopo il punto medio, non hai davvero bisogno di un’intera 2a class (cioè, ‘Linea’) per ottenere ciò. Poiché anche la cosa che stai cercando di trovare è un punto, ha senso aggiungere un costruttore alla tua class Point esistente, in questo modo ..

 Point(Point a, Point b) { x = (ax + bx) / 2; y = (ay + by) / 2; } 

.. poi, altrove diciamo che hai già un paio di punti su cui vuoi usare questo, usi il costruttore così:

 Point p1 = new Point(2,2); Point p2 = new Point(4,4); Point midpoint = new Point(p1, p2); 

e se vuoi davvero la distanza tra due punti, non è proprio un attributo di entrambi i punti, quindi ha senso usare un metodo statico per questo, come in questo caso

 public static double distance(Point a, Point b) { double dx = ax - bx; double dy = ay - by; return Math.sqrt(dx * dx + dy * dy); } 

e di nuovo nel codice chiamante, puoi usarlo in questo modo:

 Point p1 = new Point(2,2); Point p2 = new Point(4,4); System.out.println("Distance between them is " + Point.distance(p1, p2)); 

Puoi usare una funzione matematica per questo:

 public Point midpoint() { //Calculate the difference between the old and new x/y double dx = p1.getX() - p2.getX(); double dy = p1.getY() - p2.getY(); double newX = Math.pow(dx, 2D); double newY = Math.pow(dz, 2D); return new Point(newX, newZ); } 

Math.pow gestisce i problemi con valori negativi e così via. Per te, usare Math.pow ti dà un metodo sicuro perché ha un sacco di controlli integrati all’interno.

Puoi usare il Teorema di Pitagora , come già detto. Ecco una dimostrazione visiva del Wolfram Demostration Project .

alt text http://demonstrations.wolfram.com/DistanceBetweenTwoPoints/HTMLImages/index.en/popup_5.jpg

Nella tua seconda class, sembra che tu stia cercando di impostare i valori di x e y usati per build la tua variabile mp . Tutte le tue formule sono corrette, ma devi considerare l’ ordine che tutto venga eseguito. Nel codice così com’è, sta creando le variabili x e y , che iniziano come 0, quindi i vari Point s. x e y sono ancora 0, quindi mp è impostato su Point(0, 0) .

Quello che probabilmente vorresti fare è cambiare il tipo di ritorno del midpoint in Point , in modo che quando chiami quella funzione, ottieni un Point . Quindi puoi creare un nuovo object Point con i valori che calcoli. Dovrebbe assomigliare più a questo:

 public Point midpoint() { // calculate the middle x and y double x = (p1.getX() + p2.getX()) / 2; double y = (p1.getY() + p2.getY()) / 2; // now make a new Point with those values, and return it return new Point(x, y); }