练习 -Java顺序结构之数学函数之根据三角形三边长求面积

1. 任务要求

• [任务描述]
• [编程要求]
• [测试说明]

---

任务描述

本关任务：根据从键盘输入的三角形的三个边长，求出三角形的面积，忽略三边长度不能组成一个三角形的情况，最后结果保留两位小数。

任意三角形面积公式-海伦公式

已知三角形三边a、b、c，则

p=21(a+b+c)

S三角形=p(p−a)(p−b)(p−c)

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。 输出格式详情请参照右侧预期输出。

注意：给定的三个数请使用 double 类型变量接收。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。 可在右侧“测试结果”区查看具体的测试集详情。

---

2. 任务分析

1. 输入输出分析

根据从键盘输入的三角形的三个边长，求出三角形的面积，忽略三边长度不能组成一个三角形的情况，最后结果保留两位小数。

输入: 三角形的三个边长 数字

输出: 三角形的面积

约束条件:

• 忽略三边长度不能组成一个三角形的情况

• 最后结果保留两位小数

2. 需求分析

1. 获取键盘输入的三条边 java输入获取
2. 将三条边转换为可以计算的数据类型 字符串转换为三个double类型
3. 将三条边计算为三角形的面积 海伦公式，定义一个方法
4. 忽略三边长度不能组成一个三角形的情况 可用if else语句
5. 输出三角形的面积要求 最后结果保留两位小数 print 然后中间加转换

3. 所需知识

1. java 库 如何获取输入

使用Scanner类 ：

当然，Scanner 类是 Java 标准库中的一个实用工具，用于获取用户从键盘输入的数据。它提供了多种方法来处理不同类型的输入，例如整数、浮点数、字符串等。下面我将详细介绍一些 Scanner 类的主要方法：

1. Scanner(InputStream source)：

Scanner 类的构造函数，用于创建一个新的 Scanner 对象，从指定的输入流（例如 System.in）读取数据。

// 从键盘输入创建 Scanner 对象
Scanner scannerFromKeyboard = new Scanner(System.in);

// 从字符串输入创建 Scanner 对象
String inputString = "Hello 123 World";
Scanner scannerFromString = new Scanner(inputString);

2. next()：

用于获取下一个以空白字符（空格、制表符、换行符等）分隔的字符串，并返回该字符串。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个字符串：");
String str = scanner.next();
System.out.println("你输入的字符串是：" + str);

3. nextInt()：

用于获取下一个整数，并返回该整数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int numInt = scanner.nextInt();
System.out.println("你输入的整数是：" + numInt);

4. nextDouble()：

用于获取下一个浮点数，并返回该浮点数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个浮点数：");
double numDouble = scanner.nextDouble();
System.out.println("你输入的浮点数是：" + numDouble);

5.nextLine()：

用于获取下一行的输入，并返回该行的字符串，包括换行符在内。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一行文本：");
scanner.nextLine(); // 消耗掉nextInt或nextDouble等方法末尾的换行符
String line = scanner.nextLine();
System.out.println("你输入的文本是：" + line);

6. hasNext()：

用于检查是否还有下一个标记（字符串、整数、浮点数等）可供读取，如果有则返回 true，否则返回 false。

Scanner scanner = new Scanner(System.in);
System.out.print("再输入一个字符串来检查 hasNext() 方法：");
boolean hasNextStr = scanner.hasNext();
System.out.println("是否有下一个字符串：" + hasNextStr);

7. hasNextInt()：

用于检查是否还有下一个整数可供读取，如果有则返回 true，否则返回 false。

Scanner scanner = new Scanner(System.in);
System.out.print("再输入一个整数来检查 hasNextInt() 方法：");
boolean hasNextInt = scanner.hasNextInt();
System.out.println("是否有下一个整数：" + hasNextInt);

8. hasNextDouble()：

用于检查是否还有下一个浮点数可供读取，如果有则返回 true，否则返回 false。

Scanner scanner = new Scanner(System.in);
System.out.print("再输入一个浮点数来检查 hasNextDouble() 方法：");
boolean hasNextDouble = scanner.hasNextDouble();
System.out.println("是否有下一个浮点数：" + hasNextDouble);

9. useDelimiter(String pattern)：

用于设置输入分隔符的模式，例如 useDelimiter(",") 将设置逗号为输入分隔符。

Scanner scanner = new Scanner(System.in);
// 使用逗号作为输入分隔符
scanner.useDelimiter(",");
System.out.println("请输入用逗号分隔的三个整数：");

// 获取三个整数输入，并以逗号分隔
int num1 = scanner.nextInt();
int num2 = scanner.nextInt();
int num3 = scanner.nextInt();

// 输出获取的三个整数
System.out.println("你输入的三个整数分别是：" + num1 + ", " + num2 + ", " + num3);

10. 全代码示例：

import java.util.Scanner;

public class ScannerExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // next() 方法示例
        System.out.print("请输入一个字符串：");
        String str = scanner.next();
        System.out.println("你输入的字符串是：" + str);

        // nextInt() 方法示例
        System.out.print("请输入一个整数：");
        int numInt = scanner.nextInt();
        System.out.println("你输入的整数是：" + numInt);

        // nextDouble() 方法示例
        System.out.print("请输入一个浮点数：");
        double numDouble = scanner.nextDouble();
        System.out.println("你输入的浮点数是：" + numDouble);

        // nextLine() 方法示例
        System.out.print("请输入一行文本：");
        scanner.nextLine(); // 消耗掉nextInt或nextDouble等方法末尾的换行符
        String line = scanner.nextLine();
        System.out.println("你输入的文本是：" + line);

        // hasNext() 方法示例
        System.out.print("再输入一个字符串来检查 hasNext() 方法：");
        boolean hasNextStr = scanner.hasNext();
        System.out.println("是否有下一个字符串：" + hasNextStr);

        // hasNextInt() 方法示例
        System.out.print("再输入一个整数来检查 hasNextInt() 方法：");
        boolean hasNextInt = scanner.hasNextInt();
        System.out.println("是否有下一个整数：" + hasNextInt);

        // hasNextDouble() 方法示例
        System.out.print("再输入一个浮点数来检查 hasNextDouble() 方法：");
        boolean hasNextDouble = scanner.hasNextDouble();
        System.out.println("是否有下一个浮点数：" + hasNextDouble);

        scanner.close();
    }
}

这些方法提供了灵活的方式来处理各种类型的用户输入。你可以根据需要选择适合的方法来读取用户输入的数据，并进行相应的处理。

2. java 库 如何将输入的数据转换为三个小数类型的数据

1. 用Scanner 类的 nextDouble() 方法

当用户输入数据时，你可以使用 Scanner 类的 nextDouble() 方法来获取输入的浮点数。下面是一个示例代码片段，演示如何将输入的数据转换为三个小数类型的数据：

Scanner scanner = new Scanner(System.in);

System.out.print("请输入三个小数，用空格分隔：");
double num1 = scanner.nextDouble();
double num2 = scanner.nextDouble();
double num3 = scanner.nextDouble();

System.out.println("你输入的三个小数分别是：" + num1 + ", " + num2 + ", " + num3);

scanner.close();

在这个示例中，我们使用 Scanner 类的 nextDouble() 方法三次，分别获取用户输入的三个小数，并将它们保存到 double 类型的变量 num1、num2 和 num3 中。然后，我们将这些变量打印输出以确认输入的正确性。

2. 用Scanner类的next()方法

如果输入的数据是一行代码空格分割的三个小数，你可以使用 Scanner 类的 next() 方法获取一行输入，然后使用 String 类的 split() 方法将其按空格分割成字符串数组，最后将字符串数组中的元素转换为小数类型。下面是相应的代码示例：

Scanner scanner = new Scanner(System.in);

System.out.print("请输入三个小数，用空格分隔：");
String input = scanner.nextLine();
String[] parts = input.split(" ");

// 将字符串数组中的元素转换为小数类型
double num1 = Double.parseDouble(parts[0]);
double num2 = Double.parseDouble(parts[1]);
double num3 = Double.parseDouble(parts[2]);

System.out.println("你输入的三个小数分别是：" + num1 + ", " + num2 + ", " + num3);

scanner.close();

在这个示例中，我们首先使用 nextLine() 方法获取一行输入，然后使用 split(" ") 方法将输入的字符串按空格分割成字符串数组 parts。最后，我们将字符串数组中的每个元素转换为小数类型，并保存到对应的变量中。

3. java 选择结构 判断能不能组成三角形

这个主要涉及知识是，创造方法以及调用，java选择结构的使用，选择结构的判断条件

1.Java 如何创造方法

明白了，让我们从头开始。在Java中，你可以通过以下步骤来创建方法：

1. 方法的声明：你需要指定方法的访问修饰符（例如 public、private 等）、返回类型（如果方法不返回任何值，则返回类型为 void）、方法名称以及参数列表。方法的声明语法如下：

   访问修饰符 返回类型 方法名(参数列表) {
       // 方法体
   }
   

2. 方法的实现：在方法体内编写方法的具体功能。

3. 方法的调用：在其他地方通过方法名以及传递给方法的参数来调用该方法。

下面是一个示例代码，演示了如何创建一个简单的方法并在主程序中调用它：

public class MethodExample {
    // 方法的声明
    public static void printMessage(String message) {
        // 访问修饰符 返回类型 方法名 参数列表
        /***
        public static void printMessage(String message) 这个方法中使用了两个访问修饰符。在		Java中，一个方法可以同时具有多个修饰符，它们的顺序通常是任意的。

		public 是访问修饰符，表示该方法可以被其他类访问。
		static 是一个关键字，表示该方法属于类而不是对象，在调用时可以直接通过类名来调用。
		void 是返回类型，表示该方法不返回任何值。
		printMessage 是方法名。
		(String message) 是参数列表，这里表示该方法接受一个字符串类型的参数。
		因此，public static void printMessage(String message) 这个方法声明了一个公共的静态方法，它接受一个字符串参数，并且不返回任何值。
        */
        // 方法的实现
        System.out.println(message);
    }

    public static void main(String[] args) {
        // 方法的调用
        printMessage("Hello, World!");//这样可以只可视方法的使用，对隐藏代码很好
    }
}

在这个示例中，我们创建了一个名为 printMessage 的方法，它接受一个字符串参数 message，并在方法体内使用 System.out.println() 方法打印出这个消息。然后，在 main 方法中，我们通过方法名 printMessage 来调用这个方法，并传递一个字符串参数 “Hello, World!”。

---

2. java选择结构的使用

在Java中，选择结构用于根据条件来执行不同的代码块。常见的选择结构有以下几种：

1. if 语句：if 语句根据指定的条件执行代码块。如果条件为真，则执行 if 代码块；否则，执行可选的 else 或 else if 代码块。

   if (condition) {
       // 如果条件为真，则执行这里的代码块
   } else if (anotherCondition) {
       // 如果另一个条件为真，则执行这里的代码块
   } else {
       // 如果上述条件都不满足，则执行这里的代码块
   }
   

2. switch 语句：switch 语句根据表达式的值执行不同的代码块。它将表达式的值与每个 case 标签进行比较，并执行与匹配的 case 标签关联的代码块。

   switch (expression) {
       case value1:
           // 如果 expression 的值等于 value1，则执行这里的代码块
           break;
       case value2:
           // 如果 expression 的值等于 value2，则执行这里的代码块
           break;
       default:
           // 如果 expression 的值不等于任何一个 case，则执行这里的代码块
           break;
   }
   

3. 三元条件运算符：三元条件运算符 ? : 提供了一种简洁的方式根据条件选择执行不同的代码块。

   result = (condition) ? value1 : value2;
   

这些选择结构在不同的情况下有不同的用途，你可以根据需要选择适合的结构来实现你的代码逻辑。

---

3. 选择结构的判断条件 多判断条件的综合判定

在Java中，你可以使用逻辑运算符来进行多个条件的综合判断。常用的逻辑运算符包括：

1. 与运算符 (&&)：表示“与”，当且仅当所有条件都为真时，整个表达式才为真。

2. 或运算符 (||)：表示“或”，当至少有一个条件为真时，整个表达式就为真。

3. 非运算符 (!)：表示“非”，用于取反，将真变为假，假变为真。

这些逻辑运算符可以组合使用，以满足复杂的条件判断需求。下面是一个简单的示例代码，演示了如何使用逻辑运算符进行多个条件的综合判断：

int x = 5;
int y = 10;
int z = 15;

// 综合判断条件，当 x 大于 0 且 y 大于 0 且 z 大于 0 时，输出“所有数都大于 0”
if (x > 0 && y > 0 && z > 0) {
    System.out.println("所有数都大于 0");
}

// 综合判断条件，当 x 小于 0 或者 y 小于 0 或者 z 小于 0 时，输出“至少有一个数小于 0”
if (x < 0 || y < 0 || z < 0) {
    System.out.println("至少有一个数小于 0");
}

// 综合判断条件，当 x 不等于 0 时，输出“x 不等于 0”
if (x != 0) {
    System.out.println("x 不等于 0");
}

在这个示例中，我们使用了 &&、|| 和 ! 这三种逻辑运算符来组合判断多个条件。你可以根据具体的逻辑需求，灵活地使用这些运算符来编写条件判断语句。

---

4. java 顺序结构 定义一个计算三角形面积的海伦公式算法

1. Java 如何抽象数学表达式

在Java中，可以通过定义类和方法来抽象数学表达式。抽象数学表达式意味着将数学概念、运算符和操作封装在类和方法中，以便在程序中更方便地使用和操作。这通常涉及到面向对象的编程思想。

下面是一个简单的示例，演示了如何在Java中抽象一个简单的数学表达式：

public class MathExpression {
    // 定义一个方法，计算两个数的和
    public static double add(double num1, double num2) {
        return num1 + num2;
    }

    // 定义一个方法，计算两个数的差
    public static double subtract(double num1, double num2) {
        return num1 - num2;
    }

    // 定义一个方法，计算两个数的乘积
    public static double multiply(double num1, double num2) {
        return num1 * num2;
    }

    // 定义一个方法，计算两个数的商
    public static double divide(double num1, double num2) {
        if (num2 == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return num1 / num2;
    }

    public static void main(String[] args) {
        double a = 10.0;
        double b = 5.0;

        // 使用方法来计算数学表达式
        double sum = add(a, b);
        double difference = subtract(a, b);
        double product = multiply(a, b);
        double quotient = divide(a, b);

        // 输出结果
        System.out.println("和：" + sum);
        System.out.println("差：" + difference);
        System.out.println("乘积：" + product);
        System.out.println("商：" + quotient);
    }
}

在这个示例中，我们定义了一个 MathExpression 类，并在其中定义了四个静态方法 add、subtract、multiply 和 divide，分别用于计算两个数的加、减、乘、除运算。然后，在 main 方法中，我们使用这些方法来计算数学表达式，并输出结果。这种方式可以很好地抽象数学表达式，并在程序中重复使用。

2. 使用Java 抽象 海伦公式

海伦公式用于计算三角形的面积，它的公式如下所示：

$$Area=\sqrt{s\cdot (s-a)\cdot (s-b)\cdot (s-c)}$$

其中，(s) 为半周长，(a)、(b)、(c) 分别为三角形的三条边长。

我们可以将这个公式抽象成一个方法，以便在程序中方便地调用。下面是一个示例代码：

public class TriangleAreaCalculator {
    // 计算三角形的面积
    public static double calculateArea(double side1, double side2, double side3) {
        //访问修饰符：公共、静态、返回的数据类型：double, 
        //参数列表：side1 double类型、side2 double类型、side3 double类型
        
        // 计算半周长
        double s = (side1 + side2 + side3) / 2;

        // 计算海伦公式中的表达式
        double area = Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
        //

        return area;
    }

    public static void main(String[] args) {
        // 三个边长作为示例输入
        double side1 = 3.0;
        double side2 = 4.0;
        double side3 = 5.0;

        // 调用方法计算三角形的面积
        double area = calculateArea(side1, side2, side3);

        // 输出结果
        System.out.println("三角形的面积为：" + area);
    }
}

在这个示例中，我们定义了一个 TriangleAreaCalculator 类，并在其中定义了一个静态方法 calculateArea，用于计算三角形的面积。在 main 方法中，我们提供了三条边长作为示例输入，然后调用 calculateArea 方法来计算三角形的面积，并输出结果。

5. Java如何规范化输出

在Java中，你可以使用格式化字符串来规范化输出，以满足特定的输出限定条件。常见的输出规范化方法包括：

1. 使用 System.out.printf() 方法：

这个方法允许你使用格式化字符串指定输出的格式。你可以在格式化字符串中使用占位符 % 来表示要输出的变量，然后提供相应的参数来替换占位符。

double num = 3.14159;
System.out.printf("保留两位小数：%.2f%n", num);

在上面的示例中，%.2f 表示输出一个浮点数，保留两位小数。

2. 使用 String.format() 方法：

这个方法与 System.out.printf() 类似，但它返回一个格式化后的字符串，而不是直接输出到控制台。

double num = 3.14159;
String formattedString = String.format("保留两位小数：%5.2f%n", num);
System.out.println(formattedString);

这里的 %5.2f 表示输出一个浮点数，总宽度为5，保留两位小数。

3. 使用 DecimalFormat 类：

这个类提供了更多灵活的格式化选项，你可以通过实例化 DecimalFormat 对象来设置输出的格式。

import java.text.DecimalFormat;

double num = 3.14159;
DecimalFormat df = new DecimalFormat("#.##");
System.out.println("保留两位小数：" + df.format(num));

在这个示例中，我们使用 # 表示可选的数字位置，. 表示小数点，## 表示保留两位小数。

通过使用这些方法，你可以灵活地规范化输出，满足特定的输出限定条件。

4. 确认代码框架

1.获取三条边的数据

// 创建一个输入流对象
InputSteam inputStream = createInputStream()

// 创建一个Scanner对象，用于从输入流中读取数据
Scanner scanner = new Scanner(inputStream)

// 提示用户输入第一条边
output("请输入第一条边的长度：")

// 读取用户输入的第一条边
double side1 = scanner.nextDouble()

// 提示用户输入第二条边
output("请输入第二条边的长度：")

// 读取用户输入的第二条边
double side2 = scanner.nextDouble()

// 提示用户输入第三条边
output("请输入第三条边的长度：")

// 读取用户输入的第三条边
double side3 = scanner.nextDouble()

// 关闭Scanner对象
scanner.close()

2. 定义一个判断三条边能否组成三角形的方法

// 函数：检查三角形是否合法
// 参数：
//   side1: 第一条边的长度
//   side2: 第二条边的长度
//   side3: 第三条边的长度
// 返回值：
//   布尔值，如果能够组成三角形则返回true，否则返回false
Function isValidTriangle(side1, side2, side3):
    // 检查条件：任意两边之和大于第三边
    If (side1 + side2 > side3) AND (side1 + side3 > side2) AND (side2 + side3 > side1) Then:
        Return true
    Else:
        Return false

// 主函数
Function main():
    // 从用户输入获取三条边的长度
    Output ("请输入第一条边的长度：")
    double side1 = Input
    
    Output ("请输入第二条边的长度：")
    double side2 = Input
    
    Output ("请输入第三条边的长度：")
    double side3 = Input
    
    // 调用函数检查是否能够组成三角形
    boolean isTriangle = isValidTriangle(side1, side2, side3)
    
    // 输出结果
    If isTriangle equals true Then:
        Output ("这三条边可以组成一个三角形。")
    Else:
		Output ("这三条边不能组成一个三角形。")

3. 定义一个计算三角形面积的海伦公式算法，并在主函数中调用它

// 函数：计算三角形面积
// 参数：
//   side1: 第一条边的长度
//   side2: 第二条边的长度
//   side3: 第三条边的长度
// 返回值：
//   浮点数，表示三角形的面积
Function calculateTriangleArea(side1, side2, side3):
    // 计算半周长
    s = (side1 + side2 + side3) / 2
    
    // 使用海伦公式计算面积
    area = √(s * (s - side1) * (s - side2) * (s - side3))
    
    Return area

// 主函数
Function main():
    // 获取用户输入的三条边的长度
    Output ("请输入第一条边的长度：")
    side1 = Input
    
    Output ("请输入第二条边的长度：")
    side2 = Input
    
    Output ("请输入第三条边的长度：")
    side3 = Input
    
    // 调用函数计算三角形的面积
    area = calculateTriangleArea(side1, side2, side3)
    
    // 输出结果
    Output ("三角形的面积为：" + area)

4. 规范化 输出

// Function: 格式化输出
// 参数：
//   value: 要输出的值
//   decimalPlaces: 小数点后要保留的位数
// 返回值：
//   无
Function formatOutput(value, decimalPlaces):
    // 将值转换为字符串
    stringValue = Convert value to string
    
    // 寻找小数点的位置
    decimalPointIndex = Find the position of decimal point in stringValue
    
    // 获取小数点后的位数
    decimalDigits = Calculate the number of digits after the decimal point in stringValue
    
    // 如果小数点位数大于要求的位数，则截取到要求的位数
    If decimalDigits > decimalPlaces Then:
        Truncate stringValue to decimalPlaces digits after the decimal point
    
    // 如果小数点位数小于要求的位数，则补零到要求的位数
    Else if decimalDigits < decimalPlaces Then:
        Pad stringValue with zeros to have decimalPlaces digits after the decimal point
    
    // 输出格式化后的值
    Output stringValue

// 主函数
Function main():
    // 定义一个数值
    number = 3.1415
    
    // 调用格式化输出函数
    Call formatOutput(number, 2) // 保留两位小数

5. 书写代码

import java.util.*;
import java.text.DecimalFormat;
public class TriangleArea{
    public static void main(String[] args){
        Scanner scanner = new Scanner (System.in);
        double side1 = scanner.nextDouble();
        double side2 = scanner.nextDouble();
        double side3 = scanner.nextDouble();
        if !(isValidTriangle(side1,side2,side3)){
            print
            return 0;
        }
        double area = calculateTriangleArea(side1,side2,side3);
        num_to_str(area);
        scanner.close()
    }
    public static boolean isValidTriangle(double side1,double side2,double side3){
        if (side1 + side2 > side3) &&(side1 + side3 > side2)&&(side2 + side3 > side1){
            return True;
        }
        else{
            return False;
        }
    }
    public static double calculateTriangleArea(double side1,double side2,double side3){
        double area = math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
        return area;
    }
    public static void num_to_str(double num){
        DecimalFormat df = new DecimalFormat("#.##");
        String output = df.format(num);
        System.out.pirntf("三角形的面积为："+output);
    }
}

3. 代码

修改后的最终代码

import java.util.*;
import java.text.DecimalFormat;
import java.lang.*;

public class TriangleArea {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double side1 = scanner.nextDouble();
        double side2 = scanner.nextDouble();
        double side3 = scanner.nextDouble();
        if (isValidTriangle(side1, side2, side3) == false) {
            System.out.println("三角形不存在");
            return;
        }
        double area = calculateTriangleArea(side1, side2, side3);
        num_to_str(area);
        scanner.close();
    }

    public static boolean isValidTriangle(double side1, double side2, double side3) {
        if ((side1 + side2 > side3) && (side1 + side3 > side2) && (side2 + side3 > side1)) {
            return true;
        } else {
            return false;
        }
    }

    public static double calculateTriangleArea(double side1, double side2, double side3) {
        double s = (side1 + side2 + side3) / 2;
        double area = Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
        return area;
    }

    public static void num_to_str(double num) {
        DecimalFormat df = new DecimalFormat("#.##");
        df.setMinimumFractionDigits(2); // 设置最小的小数位数为2
        String output = df.format(num);
        System.out.printf("三角形的面积为：" + output);
    }
}

之前的代码

/**
 * 任务：根据从键盘输入的三角形的三个边长，求出三角形的面积。
 * 类名为：TriangleArea
 */


/**
 * 任务：根据从键盘输入的三角形的三个边长，求出三角形的面积。
 * 类名为：TriangleArea
 */


import java.util.Scanner;

public class TriangleArea {
    public static void main(String[] args) {

        Scanner reader = new Scanner(System.in);

        /********** Begin **********/
        // 第一步：获取键盘三次输入的值
        double a = reader.nextDouble();
        double b = reader.nextDouble();
        double c = reader.nextDouble();

        // 第二步：根据三角形面积公式求取三角形面积
        double s = (a + b + c) / 2;
        double area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

        // 第三步：格式化输出三角形的面积
        System.out.printf("三角形的面积为：%.2f", area);
        /********** End **********/

        reader.close();
    }
}