Domanda

Ho bisogno di creare una classe che calcola la distanza tra due punti. Sono bloccato e io sono un principiante totale. Qui ci sono 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 classe.

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 oggetto punto (il punto centrale) tra due punti definiti.

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

È stato utile?

Soluzione

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

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

Ma, se invece si è il punto medio dei vostri due punti, si dovrebbe cambiare la funzione di punto medio a:

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

Ciò restituirà un nuovo oggetto punto di zecca ai punti indicati alla metà dei dati due punti (senza dover preoccuparsi con qualsiasi altro di matematica). E, dal momento che la vostra seconda classe è una linea, è necessario solo i due punti finali per descriverlo, quindi mi piacerebbe fare alcune piccole modifiche.

Per prima 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; }
}

Poi 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 compilato ed eseguito con l'endpoint 2,2 e 5,6 (l'ipotenusa di un classico 3/4/5 triangolo rettangolo), generano la corretta:

Midpoint = (3.5,4.0)
Length   = 5.0

Altri suggerimenti

Semplice pitag ... 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

Immaginate X e Y sono i tuoi punti su una superficie piana. Poi a è X.y - Y.y e b è Y.x - X.x. La lunghezza di c è la loro distanza, ed è la lunghezza dell'ipotenusa di tale triangolo. Si è calcolato utilizzando

sqrt(a^2 + b^2);

Dal che si vede che stiamo squadratura a e b, il segno della loro non è rilevante - si scenderà alla stessa. Quindi questo metodo funziona sempre, dove mai i punti si trovano.

Pythagorean theorem

Avete veramente bisogno la distanza, o stai cercando di ottenere solo il punto medio? Perché da snippet di codice, che tipo di sembra si vuole solo creare un nuovo punto che si trova a metà strada tra due punti esistenti.

Se siete davvero solo dopo il punto medio, non si ha realmente bisogno di un intero 2a classe (vale a dire, 'Linea') per realizzare questo. Dal momento che la cosa si sta cercando di trovare è anche un punto, ha senso aggiungere un costruttore per la classe Point esistente, in questo modo ..

Point(Point a, Point b)
{
  x = (a.x + b.x) / 2;
  y = (a.y + b.y) / 2;
}

.. poi, andiamo altrove di dire si dispone già di un paio di punti che si desidera utilizzare questo su, è possibile utilizzare la funzione di costruzione in tal modo:

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

e se si vuole veramente distanza tra due punti, che non è proprio un attributo di uno dei due punti, quindi ha senso usare un metodo statico per questo, in questo modo

public static double distance(Point a, Point b)
{
  double dx = a.x - b.x;
  double dy = a.y - b.y;
  return Math.sqrt(dx * dx + dy * dy);
}

e di nuovo nel codice chiamante, è possibile utilizzare 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));

È possibile utilizzare 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 ecc Per te, utilizzando Math.pow ti dà un metodo sicuro, perché ha un sacco di controlli costruito all'interno.

È possibile utilizzare il teorema di Pitagora , come altri hanno detto. Ecco una dimostrazione visivamente dal Wolfram progetto dimostrativo .

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

Nella seconda classe, sembra che si sta cercando di impostare i valori di x e y che vengono utilizzati per costruire la variabile mp. Tutte le formule sono corrette, ma è necessario prendere in considerazione il ordine che tutto viene eseguito. Nel codice così com'è, è creando le x e y variabili, che iniziano come 0, poi i vari Points. x e y sono ancora 0, quindi mp è impostato su Point(0, 0).

Quello che probabilmente vuole fare è cambiare il tipo di ritorno di midpoint a Point, in modo che quando si chiama quella funzione, si ottiene indietro un Point. Quindi è possibile creare un nuovo oggetto Point con i valori che calcolare. Dovrebbe apparire più simile 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);
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top