java简单项目

1. 计算 Fibonacci 序列的第 n 项:
   Java 代码中使用了递归方法来计算 Fibonacci 数列的第 n 项。这是一种简单但效率不是很高的方法，因为它会重复计算很多子问题。对于较大的 n 值，可以考虑使用动态规划来优化。

   public class Solution {
       public static int fibonacci(int n) {
           if (n == 0 || n == 1) {
               return n;
           } else {
               return fibonacci(n - 1) + fibonacci(n - 2);
           }
       }

       public static void main(String[] args) {
           System.out.println("请输入你想输出的第几项:");
           Scanner scanner = new Scanner(System.in);
           int n = scanner.nextInt();
           System.out.println(fibonacci(n));
       }
   }

2. 计算 1! + 2! + 3! + … + 10! 的值:
   同样地，这里使用了递归方法来计算阶乘，然后将前 10 个自然数的阶乘相加得到最终结果。这种方法效率较高，因为阶乘的计算是纯数学问题，适合递归实现。

   public class Factorial {
       public static int factorial(int n) {
           if (n == 0 || n == 1) {
               return 1;
           } else {
               return n * factorial(n - 1);
           }
       }
       
       public static void main(String[] args) {
           int sum = 0;
           for (int i = 1; i <= 10; i++) {
               sum += factorial(i);
           }
           System.out.println("1! + 2! + 3! + ... + 10! = " + sum);
       }
   }
   

3. 判断一个三位数是否为水仙花数:
   水仙花数的判断通过提取三位数的百位、十位和个位数字，计算它们的立方和，然后判断这个和是否等于原始的三位数。

   import java.util.Scanner;
   
   public class Xian {
       public static void main(String[] args) {
           System.out.println("请输入一个三位数：");
           Scanner sc = new Scanner(System.in);
           int num = sc.nextInt();
           int a = num / 100; // 百位数
           int b = (num % 100) / 10; // 十位数
           int c = num % 10; // 个位数
           int sum = a * a * a + b * b * b + c * c * c;
           if (sum == num) {
               System.out.println(num + "是水仙花数！");
           } else {
               System.out.println(num + "不是水仙花数！");
           }
       }
   }
   

4. 求解一元二次方程 ax^2 + bx + c = 0 的根:
   这里提供了一个方法 solve 来计算一元二次方程的根。根据判别式 delta = b^2 - 4ac 的值，可以判断方程的根的情况：如果 delta < 0，则方程无实数根；如果 delta >= 0，则可以计算出两个实数根。

   public class Gen {
       public static double[] solve(double a, double b, double c) {
           double[] roots = new double[2];
           double delta = b * b - 4 * a * c;
           if (delta < 0) {
               System.out.println("方程无实数根");
           } else {
               roots[0] = (-b + Math.sqrt(delta)) / (2 * a);
               roots[1] = (-b - Math.sqrt(delta)) / (2 * a);
           }
           return roots;
       }
   
       public static void main(String[] args) {
           double a = 1;
           double b = -3;
           double c = 2;
           double[] roots = solve(a, b, c);
           System.out.println("方程的根为：" + roots[0] + " 和 " + roots[1]);
       }
   }