Pregunta

Es necesario crear una clase que calcula la distancia entre dos puntos. Estoy atascado y yo soy un principiante total. Aquí están mis clases:

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 segunda clase.

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

No estoy seguro de cómo conseguir un objeto de punto (el punto medio) entre los dos puntos definidos.

puedo crear objetos de punto, pero no estoy seguro de cómo devolver un objeto de punto a través de mi método midpoint() situado entre esos dos objetos de punto.

¿Fue útil?

Solución

La distancia entre dos puntos (x1, y1) y (x2, y2) sobre una superficie plana es:

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

Sin embargo, si lo que quieres es el punto medio de los dos puntos, debe cambiar su función de punto medio a:

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

Esto devolverá un nuevo objeto de punto de marca de los puntos que se exponen a la media de los dos puntos dados (sin tener que preocuparse por ninguna otra de matemáticas). Y, ya que su segunda clase es una línea, sólo necesita los dos puntos extremos de describirlo, por lo que me gustaría hacer algunos cambios menores.

En primer lugar 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; }
}

A continuación, 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);
    }
}

Estos dos archivos, una vez recopilados y correr con la 2,2 puntos finales y 5,6 (la hipotenusa de un triángulo 3/4/5 clásico ángulo derecho), generan la correcta:

Midpoint = (3.5,4.0)
Length   = 5.0

Otros consejos

Simple Pythag ... raíz (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

Imagínese X e Y son sus puntos en una superficie plana. Entonces a es X.y - Y.y y b es Y.x - X.x. La longitud de c es su distancia, y es la longitud de la hipotenusa de este triángulo. Se calcula utilizando

sqrt(a^2 + b^2);

Desde que se ve que están en armonía con a y b, el signo de ellos no es relevante - que se reducirá a la misma. Así que este método funciona siempre, donde quiera que los puntos se encuentran.

Pythagorean theorem

¿Usted realmente necesita la distancia, o estás tratando de obtener sólo el punto medio? Porque desde el fragmento de código, se parece un poco a lo que desea es crear un nuevo punto que se encuentra a medio camino entre dos puntos existentes.

Si usted es realmente justo después del punto medio, no es realmente necesita toda una segunda clase (es decir, 'Línea') para lograrlo. Ya que lo que está tratando de encontrar es también un punto, tiene sentido añadir un constructor para la clase de punto existente, como así ..

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

.. entonces, en otro lugar digamos que ya tiene un par de puntos que desea utilizar esta opción, se utiliza el constructor de esta manera:

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

y si realmente desea medir la distancia entre dos puntos, que en realidad no es un atributo de cualquiera de los puntos, por lo que tiene sentido utilizar un método estático para que, al igual que

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

y de regreso en el código de llamada, puede utilizar de esta manera:

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

Puede utilizar una función de Matemáticas para esto:

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 se ocupa de los problemas con valores negativos y etc Para usted, utilizando Math.pow le da un método seguro, ya que tiene una gran cantidad de cheques construido en el interior.

En su segunda clase, parece que usted está tratando de establecer los valores de x y y que se utilizan para construir la variable de mp. Todas las fórmulas son correctas, pero hay que tener en cuenta el Para que todo se ejecuta. En el código, ya que es, está creando las variables x y y, que empiezan como 0, entonces los diversos Points. x y y todavía son 0, por lo mp se establece en Point(0, 0).

Lo que usted probablemente querrá hacer es cambiar el tipo de retorno de midpoint a Point, de manera que cuando se llama a esa función, se obtiene una vuelta Point. A continuación, puede crear un nuevo objeto Point con los valores que calcular. Debe tener un aspecto más parecido a esto:

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);
}
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top