Calcul de la distance entre deux points

Question

Je dois créer une classe qui calcule la distance entre deux points. Je suis coincé et je suis un débutant. Voici mes classes:

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 deuxième 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;
    }
}

Je ne sais pas comment obtenir un objet point (le point médian) entre les deux points définis.

Je peux créer des objets ponctuels, mais je ne suis pas sûr de savoir comment retourner un objet point par ma méthode de midpoint() qui se trouve entre ces deux objets ponctuels.

Answer 1

La distance entre deux points (x1, y1) et (x2, y2) sur une surface plane est la suivante:

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

Mais, si vous voulez simplement est le point central de vos deux points, vous devriez changer votre fonction à mi-chemin:

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

Ceci renvoie une nouvelle marque objet point avec les points fixés au milieu des données deux points (sans avoir à vous préoccuper de tout autre calcul). Et, puisque votre deuxième classe est une ligne, il vous suffit les deux points d'extrémité pour le décrire, je ferais quelques changements mineurs.

Première 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; }
}

Alors 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);
    }
}

Ces deux fichiers, lors de la compilation et exécuter avec les points d'extrémité 2,2 et 5,6 (l'hypoténuse d'un 3/4/5 classique triangle rectangle), génèrent le bon:

Midpoint = (3.5,4.0)
Length   = 5.0

Answer 2

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

Math.sqrt(Math.pow((p2.getX() - p1.getX()), 2) + Math.pow((p2.getY() - p1.getY()), 2))

Answer 3

 X
 +
 |\
 | \
a|  \c
 |   \
 |    \
 +-----+ 
    b   Y

Imaginez X et Y sont vos points sur une surface plane. Ensuite a est X.y - Y.y et b est Y.x - X.x. La longueur de c est la distance, et est la longueur de l'hypoténuse de ce triangle. Il est calculé en utilisant

sqrt(a^2 + b^2);

le signe d'entre eux ne sont pas Puisque vous le voyez, nous élevant au carré a et b, pertinent - il descendra au même. Ainsi, cette méthode fonctionne toujours, où que les points se trouvent.

Pythagorean theorem

Answer 4

Avez-vous vraiment besoin de la distance, ou vous essayez d'obtenir juste le milieu? En raison de l'extrait de code, il ressemble un peu comme vous voulez juste créer un nouveau point qui est à mi-chemin entre deux points existants.

Si vous êtes vraiment juste après le milieu, vous ne avez pas vraiment besoin d'une 2ème classe entière (à savoir, « Line ») pour y parvenir. Étant donné que la chose que vous essayez de trouver est aussi un point, il est logique d'ajouter un constructeur à votre classe de point existant, comme si ..

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

.. alors, nous allons d'ailleurs de dire que vous avez déjà quelques points que vous souhaitez utiliser, vous utilisez le constructeur ainsi:

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

et si vous voulez vraiment la distance entre deux points, ce n'est pas vraiment un attribut de l'un des points, il est donc logique d'utiliser une méthode statique pour cela, comme si

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);
}

et de retour dans le code d'appel, vous pouvez l'utiliser de cette façon:

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

Answer 5

Vous pouvez utiliser une fonction Maths pour cela:

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 gère les problèmes avec des valeurs négatives et etc. Pour vous, en utilisant Math.pow vous donne une méthode sûre, car il a beaucoup de contrôles construit à l'intérieur.

Answer 6

Vous pouvez utiliser le théorème de Pythagore , comme autre dit. Voici un demostration visuellement Wolfram Demostration projet .

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

Answer 7

Dans votre deuxième classe, il semble que vous essayez de définir les valeurs de x et y qui sont utilisés pour construire votre variable mp. Toutes vos formules sont correctes, mais vous devez tenir compte de la pour que tout est exécuté. Dans le code tel qu'il est, cela crée les variables x et y, qui commencent à 0, puis les différents Points. x et y sont encore de 0, donc mp est réglé sur Point(0, 0).

Qu'est-ce que vous voulez sans doute faire est de changer le type de retour de midpoint à Point, de sorte que lorsque vous appelez cette fonction, vous revenez un Point. Ensuite, vous pouvez créer un nouvel objet Point avec les valeurs que vous indiquez. Il devrait ressembler à ceci:

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);
}