Pergunta

Eu preciso criar uma classe que calcula a distância entre dois pontos. Eu estou preso e eu sou um novato total. Aqui estão as minhas 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;
    }    
}

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

Não estou certo de como obter um objeto de ponto (o ponto médio) entre ambos os pontos definidos.

Eu posso criar objetos de ponto, mas não tenho certeza de como retornar um objeto de ponto através do meu método midpoint() que fica entre esses dois objetos de ponto.

Foi útil?

Solução

A distância entre dois pontos (X1, Y1) e (x2, y2) sobre uma superfície plana é:

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

Mas, se tudo que você quer é o ponto médio de seus dois pontos, você deve mudar a sua função de ponto médio para:

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

Isso irá retornar um objeto de ponto nova marca com os pontos definidos para o meio dos dados dois pontos (sem ter que se preocupar com qualquer outra matemática). E, desde a sua segunda classe é uma linha, você só precisa de dois pontos finais para descrevê-lo, então eu fazer algumas pequenas alterações.

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

Line.java Então:

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

Estes dois arquivos, quando compilados e correr com os endpoints 2,2 e 5,6 (a hipotenusa de um triângulo 3/4/5 em ângulo recto clássico), gerar o correto:

Midpoint = (3.5,4.0)
Length   = 5.0

Outras dicas

Simples 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

Imagine que X e Y são os seus pontos em uma superfície plana. Então a é X.y - Y.y e b é Y.x - X.x. O comprimento de c é a sua distância, e é o comprimento da hipotenusa do triângulo que. Ele é calculado usando

sqrt(a^2 + b^2);

Uma vez que você vê que estão em quadratura com a e b, o sinal deles não é relevante - ele vai descer para o mesmo. Portanto, este método funciona sempre, onde quer que os pontos de mentir.

Lookup Pythagorean theorem

Você realmente precisa a distância, ou você está tentando obter apenas o ponto médio? Por causa de seu trecho de código, ele se parece com você só quer criar um novo ponto que fica a meio caminho entre dois pontos existentes.

Se você é realmente apenas após a metade, você realmente não precisa toda uma 2ª classe (ou seja, 'Line') para conseguir isso. Desde a coisa que você está tentando encontrar também um ponto, faz sentido para adicionar um construtor para a sua classe Point existente, como assim ..

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

.. então, em outro lugar, digamos que você já tem um par de pontos que deseja utilizar este, você usa o construtor assim:

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

e se você realmente quer distância entre dois pontos, isso não é realmente um atributo de qualquer ponto, por isso faz sentido usar um método estático para isso, como assim

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 volta no código de chamada, você pode usá-lo desta maneira:

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

Você pode usar uma função matemática para isso:

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 alças as questões com valores negativos e etc. Para você, usando Math.pow dá-lhe um método seguro porque tem um monte de cheques construídos dentro.

Você pode usar o Teorema de Pitágoras , como outro disse. Aqui está uma demostration visualmente a partir da Wolfram Projeto Demonstração .

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

Em sua segunda classe, parece que você está tentando definir os valores das x e y que são usados ??para construir sua variável mp. Todas as suas fórmulas estão corretas, mas é preciso considerar a ordem que tudo é executado. No código como está, está criando as variáveis ??x e y, que começam como 0, em seguida, os vários Points. x e y ainda são 0, então mp está definido para Point(0, 0).

O que você provavelmente vai querer fazer é mudar o tipo de retorno de midpoint para Point, de modo que quando você chamar essa função, você recebe de volta um Point. Depois, você pode criar um novo objeto Point com os valores que você calcular. Deve olhar mais como este:

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 em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top