Java 如何返回double'；s和一根来自另一个我的线

我需要找出这三个数字是否构成一个三角形，以及它是什么样的三角形。因此，我有另一个java文件为我实现了这一点

package atriangle;

import java.util.Scanner;

public class TriangleTest
{
    public static void main(String[] args)
    {
        double side1;
        double side2;
        double side3;
        String typeOfTriangle = "";
        Scanner input = new Scanner(System.in);
        System.out.print("Side1: ");
        side1 = input.nextDouble();
        System.out.print("Side2: ");
        side2 = input.nextDouble();
        System.out.print("Side3: ");
        side3 = input.nextDouble();
        Triangle  tester = new Triangle(side1, side2, side3, typeOfTriangle);
        System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ") " + typeOfTriangle);
    }
}

测试人员转到三角形java文件为我回答上述问题

package atriangle;

class Triangle
{
    public Triangle(double sideA, double sideB, double sideC, String typeOfTriangle)
    {
        double bigside;
        double leg;
        double arm;

        if(sideA>sideB)
        {
            if(sideA > sideC)
            {
                bigside = sideA;
                leg = sideB;
                arm = sideC;
                if (isTriangle(arm, leg, bigside, typeOfTriangle)== true)
                {
                    if (isRight(arm, leg, bigside, typeOfTriangle)== true)
                    {
                        return;//return is right
                    }
                    {
                        return;//return a triangle
                    }
                }
                else
                {
                    sideA = 1.0;
                    sideB = 1.0;
                    sideC = 1.0;
                    return;//return not a triangle
                }
            }
            else
            {
                bigside = sideC;
                leg = sideB;
                arm = sideA;
                if (isTriangle(arm, leg, bigside, typeOfTriangle)== true)
                {
                    if (isRight(arm, leg, bigside, typeOfTriangle)== true)
                    {
                        return;//return is right
                    }
                    {
                        return;//return a triangle
                    }
                }
                else
                {
                    sideA = 1.0;
                    sideB = 1.0;
                    sideC = 1.0;
                    return;//return not a triangle
                }
            }
        }
        if (sideB > sideC)
        {
            bigside =sideB;
            leg = sideA;
            arm = sideC;
            if (isTriangle(arm, leg, bigside, typeOfTriangle)== true)
                {
                    if (isRight(arm, leg, bigside, typeOfTriangle)== true)
                    {
                        typeOfTriangle = "is right";
                        return;//return is right
                    }
                    {
                        return;//return a triangle
                    }
                }
                else
                {
                    sideA = 1.0;
                    sideB = 1.0;
                    sideC = 1.0;
                    return;//return not a triangle
                }
        }
        if(sideC > sideA)
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
            if (isTriangle(arm, leg, bigside, typeOfTriangle)== true)
                {
                    if (isRight(arm, leg, bigside, typeOfTriangle)== true)
                    {
                        typeOfTriangle = "is right";
                        return;//return is right
                    }
                    {
                        return;//return a triangle
                    }
                }
                else
                {
                    sideA = 1.0;
                    sideB = 1.0;
                    sideC = 1.0;
                    return;//return not a triangle
                }
        }
        else
        {
            typeOfTriangle = "is equalaterial";
            return;//return is equalaterial
        }
    }
    public static boolean isTriangle(double arm, double leg, double bigside, String typeOfTriangle)
    {
        if (arm + leg > bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
    public static boolean isRight(double leg, double arm, double bigside, String typeOfTriangle)
    {
        if (leg*leg + arm*arm == bigside*bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
}

---

但我不知道如何返回String typeOfTriangle的新值。有谁能告诉我如何返回字符串typeOfTriangle和double:sideA，sideB，sideC吗？

有很多方法可以做到这一点，但是使用您已有的代码，我将创建一个名为“TriangleType”的Java枚举，其中包含每种类型的三角形，然后我将向Triangle类添加一个静态方法，当您将三个边作为参数传入时，该方法将返回一个枚举类型。然后，您可以向名为“type”的三角形类添加一个类成员，该类成员可以在构造函数中调用此方法，以便三角形的每个实例都知道它是什么类型的三角形。这里有一个未经测试的代码的快速修改，因此可能存在语法错误

public enum TriangleType {
    NOT_A_TRIANGLE("Not a triangle"),
    RIGHT("Right"),
    EQUILATERAL("Equilateral"),
    ISOSCELES("Isosceles"),
    SCALENE("Scalene");

    private String name;

    TriangleType(String name) {
        this.name = name;
    }

    public String toString() {
        return this.name;
    }
}

然后是三角班

class Triangle
{
    private int sideA;
    private int sideB;
    private int sideC;
    private TriangleType type;

    public Triangle(double sideA, double sideB, double sideC)
    {
        this.sideA = sideA;
        this.sideB = sideB;
        this.sideC = sideC;
        this.type = Triangle::getTriangleType(sideA, sideB, sideC);
    }

    public TriangleType getType() {
        return this.type;
    }

    public static TriangleType getTriangleType(double sideA, double sideB, double sideC) {

        double bigside;
        double leg;
        double arm;

        if(sideA>sideB)
        {
            if(sideA > sideC)
            {
                bigside = sideA;
                leg = sideB;
                arm = sideC;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
            else
            {
                bigside = sideC;
                leg = sideB;
                arm = sideA;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
        }
        if (sideB > sideC)
        {
            bigside =sideB;
            leg = sideA;
            arm = sideC;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        if(sideC > sideA)
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        else
        {
            return TriangleType.EQUILATERAL;
        }
    }
    public static boolean isTriangle(double arm, double leg, double bigside)
    {
        if (arm + leg > bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
    public static boolean isRight(double leg, double arm, double bigside)
    {
        if (leg*leg + arm*arm == bigside*bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
}

还有你的主要方法

public class TriangleTest
{
    public static void main(String[] args)
    {
        double side1;
        double side2;
        double side3;

        Scanner input = new Scanner(System.in);
        System.out.print("Side1: ");
        side1 = input.nextDouble();
        System.out.print("Side2: ");
        side2 = input.nextDouble();
        System.out.print("Side3: ");
        side3 = input.nextDouble();

        Triangle tester = new Triangle(side1, side2, side3);

        System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ") " + tester.getType());
    }
}

---

有很多方法可以做到这一点，但使用您已有的代码，我将创建一个名为“TriangletType”的Java枚举，其中包含每种类型的三角形，然后我将向您的triangle类添加一个静态方法，当您将三个边作为参数传入时，该方法将返回其中一种枚举类型。然后，您可以向名为“type”的三角形类添加一个类成员，该类成员可以在构造函数中调用此方法，以便三角形的每个实例都知道它是什么类型的三角形。这里有一个未经测试的代码的快速修改，因此可能存在语法错误

public enum TriangleType {
    NOT_A_TRIANGLE("Not a triangle"),
    RIGHT("Right"),
    EQUILATERAL("Equilateral"),
    ISOSCELES("Isosceles"),
    SCALENE("Scalene");

    private String name;

    TriangleType(String name) {
        this.name = name;
    }

    public String toString() {
        return this.name;
    }
}

然后是三角班

class Triangle
{
    private int sideA;
    private int sideB;
    private int sideC;
    private TriangleType type;

    public Triangle(double sideA, double sideB, double sideC)
    {
        this.sideA = sideA;
        this.sideB = sideB;
        this.sideC = sideC;
        this.type = Triangle::getTriangleType(sideA, sideB, sideC);
    }

    public TriangleType getType() {
        return this.type;
    }

    public static TriangleType getTriangleType(double sideA, double sideB, double sideC) {

        double bigside;
        double leg;
        double arm;

        if(sideA>sideB)
        {
            if(sideA > sideC)
            {
                bigside = sideA;
                leg = sideB;
                arm = sideC;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
            else
            {
                bigside = sideC;
                leg = sideB;
                arm = sideA;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
        }
        if (sideB > sideC)
        {
            bigside =sideB;
            leg = sideA;
            arm = sideC;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        if(sideC > sideA)
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        else
        {
            return TriangleType.EQUILATERAL;
        }
    }
    public static boolean isTriangle(double arm, double leg, double bigside)
    {
        if (arm + leg > bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
    public static boolean isRight(double leg, double arm, double bigside)
    {
        if (leg*leg + arm*arm == bigside*bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
}

还有你的主要方法

public class TriangleTest
{
    public static void main(String[] args)
    {
        double side1;
        double side2;
        double side3;

        Scanner input = new Scanner(System.in);
        System.out.print("Side1: ");
        side1 = input.nextDouble();
        System.out.print("Side2: ");
        side2 = input.nextDouble();
        System.out.print("Side3: ");
        side3 = input.nextDouble();

        Triangle tester = new Triangle(side1, side2, side3);

        System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ") " + tester.getType());
    }
}

---

有很多方法可以做到这一点，但使用您已有的代码，我将创建一个名为“TriangletType”的Java枚举，其中包含每种类型的三角形，然后我将向您的triangle类添加一个静态方法，当您将三个边作为参数传入时，该方法将返回其中一种枚举类型。然后，您可以向名为“type”的三角形类添加一个类成员，该类成员可以在构造函数中调用此方法，以便三角形的每个实例都知道它是什么类型的三角形。这里有一个未经测试的代码的快速修改，因此可能存在语法错误

public enum TriangleType {
    NOT_A_TRIANGLE("Not a triangle"),
    RIGHT("Right"),
    EQUILATERAL("Equilateral"),
    ISOSCELES("Isosceles"),
    SCALENE("Scalene");

    private String name;

    TriangleType(String name) {
        this.name = name;
    }

    public String toString() {
        return this.name;
    }
}

然后是三角班

class Triangle
{
    private int sideA;
    private int sideB;
    private int sideC;
    private TriangleType type;

    public Triangle(double sideA, double sideB, double sideC)
    {
        this.sideA = sideA;
        this.sideB = sideB;
        this.sideC = sideC;
        this.type = Triangle::getTriangleType(sideA, sideB, sideC);
    }

    public TriangleType getType() {
        return this.type;
    }

    public static TriangleType getTriangleType(double sideA, double sideB, double sideC) {

        double bigside;
        double leg;
        double arm;

        if(sideA>sideB)
        {
            if(sideA > sideC)
            {
                bigside = sideA;
                leg = sideB;
                arm = sideC;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
            else
            {
                bigside = sideC;
                leg = sideB;
                arm = sideA;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
        }
        if (sideB > sideC)
        {
            bigside =sideB;
            leg = sideA;
            arm = sideC;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        if(sideC > sideA)
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        else
        {
            return TriangleType.EQUILATERAL;
        }
    }
    public static boolean isTriangle(double arm, double leg, double bigside)
    {
        if (arm + leg > bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
    public static boolean isRight(double leg, double arm, double bigside)
    {
        if (leg*leg + arm*arm == bigside*bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
}

还有你的主要方法

public class TriangleTest
{
    public static void main(String[] args)
    {
        double side1;
        double side2;
        double side3;

        Scanner input = new Scanner(System.in);
        System.out.print("Side1: ");
        side1 = input.nextDouble();
        System.out.print("Side2: ");
        side2 = input.nextDouble();
        System.out.print("Side3: ");
        side3 = input.nextDouble();

        Triangle tester = new Triangle(side1, side2, side3);

        System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ") " + tester.getType());
    }
}

---

有很多方法可以做到这一点，但使用您已有的代码，我将创建一个名为“TriangletType”的Java枚举，其中包含每种类型的三角形，然后我将向您的triangle类添加一个静态方法，当您将三个边作为参数传入时，该方法将返回其中一种枚举类型。然后，您可以向名为“type”的三角形类添加一个类成员，该类成员可以在构造函数中调用此方法，以便三角形的每个实例都知道它是什么类型的三角形。这里有一个未经测试的代码的快速修改，因此可能存在语法错误

public enum TriangleType {
    NOT_A_TRIANGLE("Not a triangle"),
    RIGHT("Right"),
    EQUILATERAL("Equilateral"),
    ISOSCELES("Isosceles"),
    SCALENE("Scalene");

    private String name;

    TriangleType(String name) {
        this.name = name;
    }

    public String toString() {
        return this.name;
    }
}

然后是三角班

class Triangle
{
    private int sideA;
    private int sideB;
    private int sideC;
    private TriangleType type;

    public Triangle(double sideA, double sideB, double sideC)
    {
        this.sideA = sideA;
        this.sideB = sideB;
        this.sideC = sideC;
        this.type = Triangle::getTriangleType(sideA, sideB, sideC);
    }

    public TriangleType getType() {
        return this.type;
    }

    public static TriangleType getTriangleType(double sideA, double sideB, double sideC) {

        double bigside;
        double leg;
        double arm;

        if(sideA>sideB)
        {
            if(sideA > sideC)
            {
                bigside = sideA;
                leg = sideB;
                arm = sideC;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
            else
            {
                bigside = sideC;
                leg = sideB;
                arm = sideA;
                if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
            }
        }
        if (sideB > sideC)
        {
            bigside =sideB;
            leg = sideA;
            arm = sideC;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        if(sideC > sideA)
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
            if (isTriangle(arm, leg, bigside)== true)
                {
                    if (isRight(arm, leg, bigside)== true)
                    {
                        return TriangleType.RIGHT;
                    }
                }
                else
                {
                    return TriangleType.NOT_A_TRIANGLE;
                }
        }
        else
        {
            return TriangleType.EQUILATERAL;
        }
    }
    public static boolean isTriangle(double arm, double leg, double bigside)
    {
        if (arm + leg > bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
    public static boolean isRight(double leg, double arm, double bigside)
    {
        if (leg*leg + arm*arm == bigside*bigside)
        {
            return true;
        }
        {
            return false;
        }
    }
}

还有你的主要方法

public class TriangleTest
{
    public static void main(String[] args)
    {
        double side1;
        double side2;
        double side3;

        Scanner input = new Scanner(System.in);
        System.out.print("Side1: ");
        side1 = input.nextDouble();
        System.out.print("Side2: ");
        side2 = input.nextDouble();
        System.out.print("Side3: ");
        side3 = input.nextDouble();

        Triangle tester = new Triangle(side1, side2, side3);

        System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ") " + tester.getType());
    }
}

---

这是三角形类的外观：

class Triangle
{
private double bigside;
private double leg;
private double arm;

public Triangle(double sideA, double sideB, double sideC)
{

    if(sideA>sideB)
    {
        if(sideA > sideC)
        {
            bigside = sideA;
            leg = sideB;
            arm = sideC;
        }
        else
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
        }
    }
    if (sideB > sideC)
    {
        bigside =sideB;
        leg = sideA;
        arm = sideC;
    }
    if(sideC > sideA)
    {
        bigside = sideC;
        leg = sideB;
        arm = sideA;
    }
}

public String typeOfTriangle() {
     if (isTriangle(arm, leg, bigside )== true)
    {
        if (isRight(arm, leg, bigside )== true)
        {
            return "is Right";
        }
        else    {
            return "A triangle";
            }
    }
    else    {
        arm = 1.0;
        leg = 1.0;
        bigside = 1.0;
        return "Not a triangle";
    }
     return "is Equilateral";
}


public static boolean isTriangle(double arm, double leg, double bigside)
{
    if (arm + leg > bigside)
    {
        return true;
    }
    {
        return false;
    }
}
public static boolean isRight(double leg, double arm, double bigside)
{
    if (leg*leg + arm*arm == bigside*bigside)
    {
        return true;
    }
    {
        return false;
    }
   }
}

在main中，如果要调用并打印它，应更改最后两行，如下所示：

    Triangle  tester = new Triangle(side1, side2, side3);
    System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ")" + tester.typeOfTriangle();

---

这是三角形类的外观：

class Triangle
{
private double bigside;
private double leg;
private double arm;

public Triangle(double sideA, double sideB, double sideC)
{

    if(sideA>sideB)
    {
        if(sideA > sideC)
        {
            bigside = sideA;
            leg = sideB;
            arm = sideC;
        }
        else
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
        }
    }
    if (sideB > sideC)
    {
        bigside =sideB;
        leg = sideA;
        arm = sideC;
    }
    if(sideC > sideA)
    {
        bigside = sideC;
        leg = sideB;
        arm = sideA;
    }
}

public String typeOfTriangle() {
     if (isTriangle(arm, leg, bigside )== true)
    {
        if (isRight(arm, leg, bigside )== true)
        {
            return "is Right";
        }
        else    {
            return "A triangle";
            }
    }
    else    {
        arm = 1.0;
        leg = 1.0;
        bigside = 1.0;
        return "Not a triangle";
    }
     return "is Equilateral";
}


public static boolean isTriangle(double arm, double leg, double bigside)
{
    if (arm + leg > bigside)
    {
        return true;
    }
    {
        return false;
    }
}
public static boolean isRight(double leg, double arm, double bigside)
{
    if (leg*leg + arm*arm == bigside*bigside)
    {
        return true;
    }
    {
        return false;
    }
   }
}

在main中，如果要调用并打印它，应更改最后两行，如下所示：

    Triangle  tester = new Triangle(side1, side2, side3);
    System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ")" + tester.typeOfTriangle();

---

这是三角形类的外观：

class Triangle
{
private double bigside;
private double leg;
private double arm;

public Triangle(double sideA, double sideB, double sideC)
{

    if(sideA>sideB)
    {
        if(sideA > sideC)
        {
            bigside = sideA;
            leg = sideB;
            arm = sideC;
        }
        else
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
        }
    }
    if (sideB > sideC)
    {
        bigside =sideB;
        leg = sideA;
        arm = sideC;
    }
    if(sideC > sideA)
    {
        bigside = sideC;
        leg = sideB;
        arm = sideA;
    }
}

public String typeOfTriangle() {
     if (isTriangle(arm, leg, bigside )== true)
    {
        if (isRight(arm, leg, bigside )== true)
        {
            return "is Right";
        }
        else    {
            return "A triangle";
            }
    }
    else    {
        arm = 1.0;
        leg = 1.0;
        bigside = 1.0;
        return "Not a triangle";
    }
     return "is Equilateral";
}


public static boolean isTriangle(double arm, double leg, double bigside)
{
    if (arm + leg > bigside)
    {
        return true;
    }
    {
        return false;
    }
}
public static boolean isRight(double leg, double arm, double bigside)
{
    if (leg*leg + arm*arm == bigside*bigside)
    {
        return true;
    }
    {
        return false;
    }
   }
}

在main中，如果要调用并打印它，应更改最后两行，如下所示：

    Triangle  tester = new Triangle(side1, side2, side3);
    System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ")" + tester.typeOfTriangle();

---

这是三角形类的外观：

class Triangle
{
private double bigside;
private double leg;
private double arm;

public Triangle(double sideA, double sideB, double sideC)
{

    if(sideA>sideB)
    {
        if(sideA > sideC)
        {
            bigside = sideA;
            leg = sideB;
            arm = sideC;
        }
        else
        {
            bigside = sideC;
            leg = sideB;
            arm = sideA;
        }
    }
    if (sideB > sideC)
    {
        bigside =sideB;
        leg = sideA;
        arm = sideC;
    }
    if(sideC > sideA)
    {
        bigside = sideC;
        leg = sideB;
        arm = sideA;
    }
}

public String typeOfTriangle() {
     if (isTriangle(arm, leg, bigside )== true)
    {
        if (isRight(arm, leg, bigside )== true)
        {
            return "is Right";
        }
        else    {
            return "A triangle";
            }
    }
    else    {
        arm = 1.0;
        leg = 1.0;
        bigside = 1.0;
        return "Not a triangle";
    }
     return "is Equilateral";
}


public static boolean isTriangle(double arm, double leg, double bigside)
{
    if (arm + leg > bigside)
    {
        return true;
    }
    {
        return false;
    }
}
public static boolean isRight(double leg, double arm, double bigside)
{
    if (leg*leg + arm*arm == bigside*bigside)
    {
        return true;
    }
    {
        return false;
    }
   }
}

在main中，如果要调用并打印它，应更改最后两行，如下所示：

    Triangle  tester = new Triangle(side1, side2, side3);
    System.out.print("\nTriangle(" + side1 +"," + side2 + "," + side3 + ")" + tester.typeOfTriangle();

---

构造函数不会返回任何内容，请查看Java书籍/教程。如果您想要一个方法来创建和返回对象，您可能需要一个。同样在方法

isTriangle

：

返回（手臂+腿>大边）

就足够了，如果，则无需

；另一种方法也是一样的
isRight
。我强烈建议浏览。它写得很好，将为您提供解决此问题和其他类似问题所需的所有工具。如果你想先看一眼的话，还有一个问题，但我建议你完整地阅读主要部分。对于你的问题，一个很好的答案在这里会很长，而且几乎只会复制那些教程。构造函数不会返回任何内容，请查看Java书籍/教程。如果您想要一个方法来创建和返回对象，您可能需要一个。同样在方法
isTriangle
：
返回（手臂+腿>大边）
就足够了，如果

，则无需

；另一种方法也是一样的
isRight
。我强烈建议浏览。它写得很好，将为您提供解决此问题和其他类似问题所需的所有工具。如果你想先看一眼的话，还有一个问题，但我建议你完整地阅读主要部分。对于你的问题，一个很好的答案在这里会很长，而且几乎只会复制那些教程。构造函数不会返回任何内容，请查看Java书籍/教程。如果您想要一个方法来创建和返回对象，您可能需要一个。同样在方法
isTriangle
：
返回（手臂+腿>大边）
就足够了，如果

，则无需

；另一种方法也是一样的
isRight
。我强烈建议浏览。它写得很好，将为您提供解决此问题和其他类似问题所需的所有工具。如果你想先看一眼的话，还有一个问题，但我建议你完整地阅读主要部分。对于你的问题，一个很好的答案在这里会很长，而且几乎只会复制那些教程。构造函数不会返回任何内容，请查看Java书籍/教程。如果您想要一个方法来创建和返回对象，您可能需要一个。同样在方法
中为三角形