Java程序在没有警告的情况下停止工作

我创建了一个方法：

public double Calculouno(double x1,double x2,double y1,double y2)
{
    double ecuacion1;
    ecuacion1= (x2-x1)+(y2-y1);
    ecuacion1= Math.sqrt(ecuacion1);
    return ecuacion1;
}

当我的程序尝试使用数学函数（如

pow

和

sqrt

）来计算ecuacion1时（至少我怀疑是这样），它会在没有编译器警告的情况下停止工作，并说“Build successful”。请帮忙

当我到达这个部分（方法）时，编译器说“buildsuccessful”，它就结束了。在这一部分之前，我的程序运行得很好

这是完整的源代码

    import java.util.Scanner;
import java.lang.Math;

public class Ejercicio12
{
    public static void main(String args[])
    {
        double[] x= new double[3];
        double[] y= new double[3];
        double a,b,c;
        int con=0, con2=0;
        double[] angulo= new double[3];
        Scanner entrada = new Scanner(System.in);
        Calculos cal= new Calculos();

        for(con=0;con<3;con++)
        {
        System.out.println("Ingrese un valor x para el punto "+(con+1)+": ");
        x[con]= entrada.nextDouble();
        System.out.println("Ingrese un valor y para el punto "+(con+1)+": ");
        y[con]= entrada.nextDouble();
        }

        a= cal.Calculouno(x[0],x[1],y[0],y[1]);
        b= cal.Calculouno(x[1],x[2],y[1],y[2]);
        c= cal.Calculouno(x[2],x[0],y[2],y[0]);

        angulo[0]= cal.Angulo(a,b,c);
        angulo[1]= cal.Angulo(c,a,b);
        angulo[2]= cal.Angulo(b,a,c);

        if(angulo[0]>90||angulo[1]>90||angulo[2]>90)
        {
            System.out.println("El triangulo es obtusangulo");
        }
        else
        {
            if(angulo[0]==90||angulo[1]==90||angulo[2]==90)
            {
                System.out.println("El triangulo es rectangulo");
            }
            else
            {
                if(angulo[0]<90&&angulo[1]<90&&angulo[2]<90)
                {
                    System.out.println("El triangulo es acutangulo");
                }
            }

        }
    }


}



 import static java.lang.Math.sqrt;
    import static java.lang.Math.pow;
    import static java.lang.Math.acos;
    public class Calculos
    {
    public double Calculouno(double x1,double x2,double y1,double y2)
        {
            double ecuacion1;
            double dx= (x2-x1);
            double dy= (y2-y1);
            return Math.sqrt(dy+dx);

        }


        public double Angulo(double a1,double b1, double c1)
        {
            double ecuacion2;
            double a11 = pow(a1,2);
            double b11 = pow(b1,2);
            double c11 = pow(c1,1);

            double xx=(b11+c11-a11);
            double zz=(2*b1*c1);

            return Math.acos(xx/zz);
     }

}

import java.util.Scanner；
导入java.lang.Math；
公共类Ejercicio12
{
公共静态void main（字符串参数[]）
{
double[]x=新的double[3]；
双精度[]y=新双精度[3]；
双a、b、c；
int con=0，con2=0；
double[]angulo=新的double[3]；
Scanner entrada=新扫描仪（System.in）；
Calculos cal=新Calculos（）；
对于（con=0；con90 | | angulo[1]>90 | | angulo[2]>90）
{
System.out.println（“El triangulo es obtusangulo”）；
}
其他的
{
如果（angulo[0]==90 | | angulo[1]==90 | | angulo[2]==90）
{
System.out.println（“El triangulo es rectangulo”）；
}
其他的
{
如果（angulo[0]，我相信这里有两个链接可以很好地描述您想要解决的问题：


及


我可以这样写。我没有对它进行详尽的测试：

package cruft;

/**
 * Junk description here
 * @author Michael
 * @link
 * @since 9/8/12 10:19 PM
 */

public class Triangle {

    private final Point p1;
    private final Point p2;
    private final Point p3;

    public static void main(String args[]) {
        if (args.length > 5) {
            Point p1 = new Point(Double.valueOf(args[0]), Double.valueOf(args[1]));
            Point p2 = new Point(Double.valueOf(args[2]), Double.valueOf(args[3]));
            Point p3 = new Point(Double.valueOf(args[4]), Double.valueOf(args[5]));
            Triangle triangle = new Triangle(p1, p2, p3);
            double angle = triangle.calculateAngle();
            System.out.println(triangle);
            if (angle > 0.0) {
                System.out.println("obtuse");
            } else if (angle < 0.0) {
                System.out.println("acute");
            } else {
                System.out.println("right triangle");
            }
        } else {
            System.out.println("Usage: Triangle x1 y1 x2 y2 x3 y3");
        }
    }

    public Triangle(Point p1, Point p2, Point p3) {
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }

    public double calculateAngle(){
        double a = Point.distance(this.p1, this.p2);
        double b = Point.distance(this.p2, this.p3);
        double c = Point.distance(this.p3, this.p1);
        return Math.acos(a*a + b*b - c*c)/2.0/a/b;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("Triangle");
        sb.append("{p1=").append(p1);
        sb.append(", p2=").append(p2);
        sb.append(", p3=").append(p3);
        sb.append('}');
        return sb.toString();
    }
}

class Point {
    public final double x;
    public final double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public static double distance(Point q1, Point q2) {
        double dx = Math.abs(q1.x-q2.x);
        double dy = Math.abs(q1.y-q2.y);
        if (dx > dy) {
            double r = dy/dx;
            return dx*Math.sqrt(1.0+r*r);
        } else {
            double r = dx/dy;
            return dy*Math.sqrt(1.0+r*r);
        }
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append('(').append(x);
        sb.append(',').append(y);
        sb.append(')');
        return sb.toString();
    }
}

包装破损；
/**
*垃圾描述在这里
*@作者迈克尔
*@link
*@从9/8/12 10:19开始
*/
公共阶级三角{
私人终点p1；
私人终点p2；
私人终点p3；
公共静态void main（字符串参数[]）{
如果（参数长度>5）{
点p1=新点（Double.valueOf（args[0]），Double.valueOf（args[1]）；
点p2=新点（Double.valueOf（args[2]），Double.valueOf（args[3]）；
点p3=新点（Double.valueOf（args[4]），Double.valueOf（args[5]）；
三角形=新三角形（p1、p2、p3）；
双角度=三角形。计算角度（）；
System.out.println（三角形）；
如果（角度>0.0）{
System.out.println（“钝角”）；
}否则如果（角度<0.0）{
系统输出打印项次（“急性”）；
}否则{
System.out.println（“直角三角形”）；
}
}否则{
System.out.println（“用法：三角形x1 y1 x2 y2 x3 y3”）；
}
}
公共三角形（点p1、点p2、点p3）{
这是1.p1=p1；
这是p2=p2；
这是p3=p3；
}
公共双计算表（）{
双a=点距离（this.p1，this.p2）；
double b=点距离（this.p2，this.p3）；
double c=点距离（this.p3，this.p1）；
返回Math.acos（a*a+b*b-c*c）/2.0/a/b；
}
@凌驾
公共字符串toString（）{
最终StringBuilder sb=新StringBuilder（）；
某人附加（“三角形”）；
sb.append（“{p1=”）。append（p1）；
sb.append（“，p2=”）.append（p2）；
某人追加（“，p3=”）。追加（p3）；
某人附加（'}'）；
使某人返回字符串（）；
}
}
类点{
公开决赛双x；
公开决赛双y；
公共点（双x，双y）{
这个.x=x；
这个。y=y；
}
公共静态双距离（q1点、q2点）{
双dx=数学绝对值（q1.x-q2.x）；
双dy=数学绝对值（q1.y-q2.y）；
如果（dx>dy）{
双r=dy/dx；
返回dx*Math.sqrt（1.0+r*r）；
}否则{
双r=dx/dy；
返回dy*Math.sqrt（1.0+r*r）；
}
}
@凌驾
公共字符串toString（）{
最终StringBuilder sb=新StringBuilder（）；
某人附加（‘（’）。附加（x）；
某人附加（’，’）。附加（y）；
某人附加（'）；
使某人返回字符串（）；
}
}
代码段中的代码中没有任何内容会（直接）导致程序“停止而不发出警告”


不存在会导致构建失败的语法错误（等等）

向
Math.sqrt
提供“错误”输入不会导致它停止，甚至不会引发异常。javadoc说：“[返回]a的正平方根。如果参数为NaN或小于零，则结果为NaN。”也就是说，错误输入将给您一个
NaN
值

错误输入不会导致
sqrt
调用之前的算术抛出异常。JLS表示（对于浮点
+
和
-
运算符）“[i]如果任一操作数为NaN，则结果为NaN。”


因此，应用程序停止的直接原因必须是应用程序中的其他地方

我希望发生的是，当您的代码的其他部分从这个方法（可能是NaN）中得到意外结果时，它会抛出一个异常，并且您的应用程序正在挤压该异常


我现在明白这个问题了

发生的情况是，对
sqrt
和
pow
>的算术和/或调用是x）；
System.out.println（x==x）；
System.out.println（x！=x）；
系统输出println（xx）；

以上所有内容都将打印“false”。是的，所有内容都是

---

测试NaN的唯一方法是使用

Double.isNaN（Double）

或

Float.isNaN（Float）

定义“停止工作”。它是否崩溃或挂起？它是否没有响应？您如何调用此函数？您对结果做了什么？您好，

Math.sqrt（）

可能抛出错误；当

ecuacion1

小于零时。顺便说一句，您对问题的描述非常缺乏，请尽量提供更多信息。@varchar:当

Math.sqrt（）

的参数小于0时，它返回

NaN

；它不会抛出任何异常。我做了更改。它不起作用，专业人士说

    double x = 0.0 / 0.0;  // generate a NaN
    System.out.println(0.0 == x);
    System.out.println(0.0 != x);
    System.out.println(0.0 < x);
    System.out.println(0.0 > x);
    System.out.println(x == x);
    System.out.println(x != x);
    System.out.println(x < x);
    System.out.println(x > x);