三天急速通关Java基础知识：Day1 基本语法

0 文章说明

本文目的是为了建立Java的基础知识体系，参考《Core Java, Volume I:Fundamentals》第十二版的第三章目录结构组织，内容由本人已学习的java知识为基础，kimi与gpt辅助完善。本文所提供的信息和内容仅供参考，作者和发布者不保证其准确性和完整性。

1 关键字 Keywords

Java关键字是Java语言的保留字，不能作为变量名、方法名、类名等标识符使用。下面列出经典的关键字，具体示例本篇不给出：

比较陌生的：

• assert：用于断言，是一种调试手段，检查程序中的某个条件是否为真。如果条件为假，会抛出AssertionError异常。

• default：在switch语句中表示默认情况，当没有任何case匹配时执行。在接口中，从Java 8开始，可以用于定义默认方法，为接口提供默认实现。

• finally：用于异常处理，finally块中的代码无论是否捕获到异常都会执行。通常用于资源清理，如关闭文件流、数据库连接等。

• instanceof：用于判断一个对象是否是某个类或其子类的实例，返回一个布尔值。常用于类型检查和类型转换。

• native：用于修饰方法，表示该方法是本地方法，即方法的实现不在Java代码中，而是在其他语言（如C或C++）中实现。通常用于调用底层系统资源或性能敏感的操作。

• strictfp：用于修饰方法或类，表示该方法或类中的浮点运算必须严格遵循IEEE 754标准。这可以确保浮点运算在不同平台上具有相同的精度和结果。

• synchronized：用于修饰方法或代码块，表示该方法或代码块是同步的，可以用于实现线程同步，防止多个线程同时访问共享资源。

• transient：用于修饰变量，表示该变量在对象序列化时不会被序列化。通常用于表示不需要持久化的临时数据。

• volatile：用于修饰变量，表示该变量的值可能会被多个线程同时访问和修改，对变量的读写操作需要保证可见性和禁止指令重排序。通常用于多线程环境中的变量共享。

2 注释 Comments

2.1 单行注释

• 语法：//
• 说明：单行注释从//开始，直到该行末尾。推荐在被注释语句上方另起一行
• 示例：

  // 这是一个单行注释
  int x = 10; // 这是变量x的声明和初始化
  

2.2 多行注释

• 语法：/* 和 */
• 说明：多行注释从/*开始，到*/结束，可以跨越多行。
• 示例：

    /*
     * 这是一个多行注释
     * 可以包含多行文本
     * 用于对代码块进行详细说明
     */
    int y = 20;
  

2.3 文档注释

• 语法：/** 和 */
• 说明：多行注释从/**开始，到*/结束，通常用于生成API文档。它主要用于类、接口、方法和字段的文档化。文档注释可以被javadoc工具解析，生成HTML格式的文档。
• 示例：

    /**
     * 这是一个文档注释
     * 用于生成API文档
     * @param x 输入参数
     * @return 返回值
     */
    public int add(int x, int y) {
        return x + y;
    }
  

3 数据类型 Data Types

Java的数据类型主要分为两大类：基本数据类型和引用数据类型。

3.1 基本数据类型

包括整数类型（byte、short、int、long）、浮点类型（float、double）、字符类型（char）和布尔类型（boolean）。

3.2 引用数据类型

引用数据类型在 Java 中是用于存储对象的内存地址，而不是直接存储数据值。引用类型主要包括 类（Class）、接口（Interface）、数组（Array） 和 枚举（Enum）。它们允许更复杂的数据结构和行为的定义。

• 类（Class）
  类是创建对象的模板，包含属性和方法。对象是类的实例。

  class Person {
      String name;
      int age;
  
      void sayHello() {
          System.out.println("Hello, my name is " + name);
      }
  }
  // 使用类创建对象
  Person person = new Person();
  person.name = "Alice";
  person.age = 25;
  person.sayHello(); // 输出: Hello, my name is Alice
  

• 接口（Interface）
  接口是行为的规范，定义了一组抽象方法。实现接口的类必须提供这些方法的具体实现。

  interface Animal {
      void makeSound();
  }
  
  class Dog implements Animal {
      public void makeSound() {
          System.out.println("Woof!");
      }
  }
  // 使用接口
  Animal dog = new Dog();
  dog.makeSound(); // 输出: Woof!
  
  

• 数组（Array）
  数组是存储相同类型元素的集合，长度固定。

  int[] numbers = {1, 2, 3, 4, 5};
  System.out.println(numbers[2]); // 输出: 3
  
  String[] names = {"Alice", "Bob", "Charlie"};
  System.out.println(names[0]); // 输出: Alice
  
  

• 枚举（Enum）
  枚举是一个特殊的类，用于定义一组固定的常量。

  enum Day {
      MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
  }
  
  // 使用枚举
  Day today = Day.WEDNESDAY;
  System.out.println(today); // 输出: WEDNESDAY
  

• 注解（Annotations
  注解用于提供元数据，可以用于类、方法、字段等。注解可以被编译器、运行时环境或其他工具读取和处理。

  public @interface MyAnnotation {
      String value();
  }
  
  @MyAnnotation("Hello")
  public class MyClass {
  }
  

4 变量与常量 Variables and Constant

根据位置不同，分为不同类型的变量与常量，有哪些位置呢？方法中，类中以及类中用static修饰了，就这三种情况，分别就是局部，实例以及类(静态) 变量或常量。

变量和常量中容易出错的点：

• 变量类型不匹配

  • 类型不兼容的赋值：将不同类型的变量赋值给一个变量时，需要进行显式的类型转换，或者使用正确的类型。

    int a = 10;
    double b = 3.14;
    a = b; // 错误：类型不兼容，必须显式转换
    a = (int) b; // 正确：类型转换
    

• 常量定义

  • 常量初始化：常量必须在声明时初始化，否则会引发编译错误。

    final int MAX_VALUE; // 错误：常量必须初始化
    MAX_VALUE = 100; // 错误：常量只能赋值一次
    

• 常量修改

  • 不能修改常量值：常量被声明后值不可更改，尝试修改常量会引发编译错误。

    final int MAX_VALUE = 100;
    MAX_VALUE = 200; // 错误：常量的值不能被修改
    

• 常量命名

  • 常量命名规范：常量通常应使用全大写字母，并使用下划线分隔词。

    final int MaxValue = 100; // 不符合规范，应该使用 MAX_VALUE
    final int MAX_VALUE = 100; // 正确
    

• 变量作用域

  • 局部变量与全局变量冲突：如果局部变量和类字段（成员变量）同名，局部变量会遮蔽类字段。

    int x = 10; // 类字段
    public void method() {
        int x = 20; // 局部变量，遮蔽类字段
        System.out.println(x); // 输出 20，而不是类字段的 10
    }
    

• 静态变量和实例变量

  • 静态变量与实例变量的混淆：静态变量属于类，而实例变量属于对象。静态变量应通过类名访问，而实例变量应通过对象访问。

    class MyClass {
        static int staticVar = 5;
        int instanceVar = 10;
    
        public static void main(String[] args) {
            MyClass obj = new MyClass();
            System.out.println(staticVar); // 正确：可以直接访问静态变量
            System.out.println(obj.instanceVar); // 正确：通过对象访问实例变量
        }
    }
    

• 变量的默认值

  • 局部变量未初始化：局部变量没有默认值，必须初始化后才能使用。成员变量有默认值（例如，int 类型的成员变量默认为 0）。

    int x; // 错误：局部变量没有默认值，必须初始化
    

• 引用类型变量的默认值

  • 引用类型变量默认值为 null：引用类型的变量（如对象类型）默认值为 null，如果尝试访问它们的属性或方法，会引发 NullPointerException。

    String str; // 默认值为 null
    System.out.println(str.length()); // 错误：会抛出 NullPointerException
    

5 运算符 Operators

运算符在 Java 中占据着重要的位置，对程序的执行有着很大的帮助。除了常见的加减乘除， 还有许多其他类型的运算符。

容易出错的点：

• 取余运算：负数取余时，结果的符号与被除数一致。
  • -5 % 3 的结果是 -2。
• 复合赋值：复合赋值运算符会自动进行类型转换，可能导致数据精度丢失。

  int a = 5;
  a += 2.5; // 等价于 a = (int)(a + 2.5)，结果为 7
  

• 浮点数比较：浮点数计算可能会有精度误差，因此直接使用 == 比较可能不准确。
  • 建议：使用 Math.abs(a - b) < epsilon 方法进行比较。
• 短路运算：&& 和 || 是短路运算符，可能导致右侧表达式不被执行。

  boolean result = (x > 5) && (y++ > 2); // 如果 x <= 5，y 不会自增
  

• 符号扩展：在位移运算中，>> 会保留符号位，>>> 不保留符号位。

  int a = -8;
  System.out.println(a >> 1);  // 结果是 -4
  System.out.println(a >>> 1); // 结果是一个正数
  

• 优先级问题：条件运算符 ? : 的优先级较低，可能需要加括号以避免误解。

  int a = 10, b = 5;
  int result = a > b ? a : b + 10; // 实际等价于 a > b ? a : (b + 10)
  

• 字符串连接：+ 运算符在连接字符串时，可能会误解数值操作。

  System.out.println("Sum: " + 5 + 3); // 输出为 Sum: 53，而不是 Sum: 8
  

6 字符串 String

在Java中，String 是一个非常重要的类，用于表示和操作字符串。字符串在Java中是不可变的，这意味着一旦创建，其内容就不能被修改。
常见方法：

一些技巧：

• 字符串比较
  • 错误：使用==比较字符串内容。

    String s1 = "Hello";
    String s2 = "hello";
    boolean isEqual = s1 == s2; // false（因为字符串常量池）
    

  • 正确做法：使用equals方法比较字符串内容。

    String s1 = "Hello";
    String s2 = "hello";
    boolean isEqual = s1.equals(s2); // false
    

• 字符串不可变性
  • 错误：尝试修改字符串内容。

    String s = "Hello";
    s.concat(" World"); // s 仍然是 "Hello"
    

  • 正确做法：使用新的变量接收修改后的字符串。

    String s = "Hello";
    String newS = s.concat(" World"); // newS 是 "Hello World"
    

• 字符串常量池
  • 错误：假设所有字符串字面量都会进入字符串常量池。

    String s1 = "Hello";
    String s2 = new String("Hello");
    boolean isSameObject = s1 == s2; // false（因为s2是通过new创建的）
    

  • 正确做法：使用intern方法确保字符串进入常量池。

    String s1 = "Hello";
    String s2 = new String("Hello").intern();
    boolean isSameObject = s1 == s2; // true
    

• 字符串分割
  • 错误：忽略分割后的空字符串。

    String s = "a,,b,c,,";
    String[] parts = s.split(",");
    // parts 会包含空字符串 ["a", "", "b", "c", "", ""]
    

  • 正确做法：使用正则表达式去除空字符串。

    String s = "a,,b,c,,";
    String[] parts = s.split(",+");
    // parts 不会包含空字符串 ["a", "b", "c"]
    

• 字符串连接
  • 错误：在循环中使用+连接字符串，导致性能问题。

    String result = "";
    for (int i = 0; i < 1000; i++) {
        result = result + i; // 每次迭代都会创建新的字符串对象
    }
    

  • 正确做法：使用StringBuilder或StringBuffer进行字符串连接。

    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 1000; i++) {
        sb.append(i); // 高效的字符串连接
    }
    String result = sb.toString();
    

7 输入与输出 Input and Output

输入和输出（I/O）是程序与用户或其他系统进行交互的重要方式。Java提供了丰富的类和接口来处理输入和输出操作，主要位于java.io包中。下面只介绍基础的输入输出处理：

• Scanner 类
  • nextLine()：读取一行文本。

    Scanner scanner = new Scanner(System.in);
    System.out.print("Enter your name: ");
    String name = scanner.nextLine(); // 读取一行文本
    

  • nextInt()：读取一个整数。

    System.out.print("Enter your age: ");
    int age = scanner.nextInt(); // 读取一个整数
    

  • nextDouble()：读取一个双精度浮点数。

    System.out.print("Enter your salary: ");
    double salary = scanner.nextDouble(); // 读取一个双精度浮点数
    

  • next()：读取一个单词（以空白字符分隔的字符串）。

    System.out.print("Enter your name: ");
    String name = scanner.next(); // 读取一个单词
    

标准输出（System.out）

• print 方法
  • print(String s)：输出一个字符串，不换行。

    System.out.print("Hello, "); // 输出字符串，不换行
    

  • print(int i)：输出一个整数，不换行。

    System.out.print(123); // 输出整数，不换行
    

  • print(double d)：输出一个双精度浮点数，不换行。

    System.out.print(3.14); // 输出浮点数，不换行
    

• printf 方法
  • printf(String format, Object... args)：格式化输出。
    

    System.out.printf("Hello, %s. You are %d years old.", "John", 30); // 格式化输出
    

易错点：

• 使用Scanner类

  • 确保关闭Scanner对象，释放系统资源。
  • 捕获InputMismatchException，处理输入错误。
  • 在使用nextInt()或nextDouble()后调用nextLine()，清除缓冲区中的换行符。

• 使用print和printf方法

  • 确保格式化字符串中的占位符与实际参数类型匹配。
  • 使用println方法或手动添加换行符，确保输出内容格式正确。
  • 使用printf方法时，使用%n换行符确保每行输出后换行。

8 流程控制 Control Flow

略

9 大数 Big Numbers

Java提供了BigInteger和BigDecimal类来处理这种大数值（超出常规数据类型如int和long范围的数值问题。

• BigInteger类：任意精度的整数运算

• BigDecimal类：任意精度的浮点数运算

Java中BigInteger和BigDecimal类的常见易错点：

• BigInteger类

• 使用错误的构造方法

  • 错误：使用BigInteger(int signum, byte[] magnitude)构造方法时，传入的参数不正确。

    byte[] bytes = {1, 2, 3};
    BigInteger bigInt = new BigInteger(1, bytes); // 正确
    BigInteger bigInt = new BigInteger(-1, bytes); // 负数
    

  • 正确做法：确保signum参数正确，1表示正数，-1表示负数，0表示零。

    byte[] bytes = {1, 2, 3};
    BigInteger bigInt = new BigInteger(1, bytes); // 正确
    

• 除法运算未处理异常

  • 错误：在进行除法运算时，未处理ArithmeticException。

    BigInteger bigInt1 = new BigInteger("10");
    BigInteger bigInt2 = new BigInteger("0");
    BigInteger quotient = bigInt1.divide(bigInt2); // 抛出ArithmeticException
    

  • 正确做法：在进行除法运算时，确保除数不为零，或捕获ArithmeticException。

    BigInteger bigInt1 = new BigInteger("10");
    BigInteger bigInt2 = new BigInteger("0");
    try {
        BigInteger quotient = bigInt1.divide(bigInt2);
    } catch (ArithmeticException e) {
        System.out.println("除数不能为零");
    }
    

• 使用intValue、longValue等方法时未处理溢出

  • 错误：在将BigInteger转换为int或long时，未处理可能的溢出。

    BigInteger bigInt = new BigInteger("12345678901234567890");
    int value = bigInt.intValue(); // 可能溢出
    

  • 正确做法：在转换前，使用bitLength方法检查数值是否在范围内。

    BigInteger bigInt = new BigInteger("12345678901234567890");
    if (bigInt.bitLength() <= 31) {
        int value = bigInt.intValue();
    } else {
        System.out.println("数值超出int范围");
    }
    

• BigDecimal类

• 使用double值创建BigDecimal

  • 错误：使用double值创建BigDecimal，导致精度问题。

    BigDecimal bigDecimal = new BigDecimal(12345.67890); // 精度问题
    

  • 正确做法：使用字符串创建BigDecimal，避免精度问题。

    BigDecimal bigDecimal = new BigDecimal("12345.67890"); // 正确
    

• 除法运算未处理异常

  • 错误：在进行除法运算时，未处理ArithmeticException。

    BigDecimal bigDecimal1 = new BigDecimal("10");
    BigDecimal bigDecimal2 = new BigDecimal("0");
    BigDecimal quotient = bigDecimal1.divide(bigDecimal2); // 抛出ArithmeticException
    

  • 正确做法：在进行除法运算时，确保除数不为零，或捕获ArithmeticException。

    BigDecimal bigDecimal1 = new BigDecimal("10");
    BigDecimal bigDecimal2 = new BigDecimal("0");
    try {
        BigDecimal quotient = bigDecimal1.divide(bigDecimal2);
    } catch (ArithmeticException e) {
        System.out.println("除数不能为零");
    }
    

• 除法运算未指定舍入模式

  • 错误：在进行除法运算时，未指定舍入模式，导致ArithmeticException。

    BigDecimal bigDecimal1 = new BigDecimal("10");
    BigDecimal bigDecimal2 = new BigDecimal("3");
    BigDecimal quotient = bigDecimal1.divide(bigDecimal2); // 抛出ArithmeticException
    

  • 正确做法：在进行除法运算时，指定舍入模式。

    BigDecimal bigDecimal1 = new BigDecimal("10");
    BigDecimal bigDecimal2 = new BigDecimal("3");
    BigDecimal quotient = bigDecimal1.divide(bigDecimal2, 2, RoundingMode.HALF_UP); // 正确
    

• 使用floatValue、doubleValue等方法时未处理精度损失

  • 错误：在将BigDecimal转换为float或double时，未处理可能的精度损失。

    BigDecimal bigDecimal = new BigDecimal("12345.67890");
    double value = bigDecimal.doubleValue(); // 精度损失
    

  • 正确做法：在转换前，确保数值在范围内，或使用setScale方法调整精度。

    BigDecimal bigDecimal = new BigDecimal("12345.67890");
    BigDecimal scaledValue = bigDecimal.setScale(2, RoundingMode.HALF_UP);
    double value = scaledValue.doubleValue(); // 正确
    

希望这些信息对你有帮助！如果你有任何问题或需要进一步的解释，请随时告诉我。

10 数组 Arrays

• 一维数组

• 二维数组

• 常见方法

Final 考试

• 关键字
  模拟一个动物世界，支持鸟类和哺乳动物的多态行为，并限制某些动物不能被继承或扩展。

  interface Animal {
      void makeSound();
      void move();
  }
  
  abstract class Bird implements Animal {
      protected String name;
  
      public Bird(String name) {
          this.name = name;
      }
  
      public abstract void fly();
  
      @Override
      public void move() {
          System.out.println(name + " is moving.");
      }
  }
  
  final class Eagle extends Bird {
      public Eagle(String name) {
          super(name);
      }
  
      @Override
      public void makeSound() {
          System.out.println(name + " screeches!");
      }
  
      @Override
      public void fly() {
          System.out.println(name + " is soaring high.");
      }
  }
  
  class Mammal implements Animal {
      private String name;
  
      public Mammal(String name) {
          this.name = name;
      }
  
      @Override
      public void makeSound() {
          System.out.println(name + " makes a mammal sound.");
      }
  
      @Override
      public void move() {
          System.out.println(name + " is walking.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal eagle = new Eagle("Golden Eagle");
          eagle.makeSound();
          eagle.move();
  
          Animal lion = new Mammal("Lion");
          lion.makeSound();
          lion.move();
      }
  }
  

• 注释
  为一个贷款利息计算器编写详细的注释，解释计算步骤和逻辑。

  /**
   * 贷款利息计算器
   * 计算贷款的月还款金额和总利息
   */
  public class LoanCalculator {
      /**
       * 计算月还款金额
       * @param principal 贷款本金
       * @param annualRate 年利率（小数形式）
       * @param months 贷款期数（以月为单位）
       * @return 每月还款金额
       */
      public double calculateMonthlyPayment(double principal, double annualRate, int months) {
          double monthlyRate = annualRate / 12; // 月利率
          return (principal * monthlyRate) / (1 - Math.pow(1 + monthlyRate, -months));
      }
  
      /**
       * 计算总利息
       * @param monthlyPayment 每月还款金额
       * @param months 贷款期数
       * @param principal 贷款本金
       * @return 总利息
       */
      public double calculateTotalInterest(double monthlyPayment, int months, double principal) {
          return (monthlyPayment * months) - principal;
      }
  
      public static void main(String[] args) {
          LoanCalculator calculator = new LoanCalculator();
          double principal = 50000; // 本金
          double annualRate = 0.05; // 年利率
          int months = 24; // 期数
  
          double monthlyPayment = calculator.calculateMonthlyPayment(principal, annualRate, months);
          double totalInterest = calculator.calculateTotalInterest(monthlyPayment, months, principal);
  
          System.out.printf("每月还款金额: %.2f\n", monthlyPayment);
          System.out.printf("总利息: %.2f\n", totalInterest);
      }
  }
  
  

• 数据类型
  模拟一个个人信息管理系统，支持用户输入、修改和打印复杂的个人数据。

  import java.util.Scanner;
  
  public class PersonalInfoManager {
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
  
          // 基本数据类型
          System.out.print("请输入姓名: ");
          String name = scanner.nextLine();
  
          System.out.print("请输入年龄: ");
          int age = scanner.nextInt();
  
          System.out.print("请输入身高 (米): ");
          float height = scanner.nextFloat();
  
          System.out.print("是否已婚 (true/false): ");
          boolean isMarried = scanner.nextBoolean();
  
          // 输出个人信息
          System.out.println("\n个人信息:");
          System.out.printf("姓名: %s\n", name);
          System.out.printf("年龄: %d\n", age);
          System.out.printf("身高: %.2f 米\n", height);
          System.out.printf("婚姻状况: %s\n", isMarried ? "已婚" : "未婚");
      }
  }
  
  

• 变量与常量
  设计一个动态管理圆的系统，可以根据用户输入动态创建多个圆，并输出总圆数和每个圆的面积。

  class Circle {
      private static int totalCircles = 0; // 类变量
      private double radius; // 实例变量
      private static final double PI = 3.14159; // 类常量
  
      public Circle(double radius) {
          this.radius = radius;
          totalCircles++;
      }
  
      public double calculateArea() {
          return PI * radius * radius;
      }
  
      public static int getTotalCircles() {
          return totalCircles;
      }
  }
  
  public class CircleManager {
      public static void main(String[] args) {
          Circle c1 = new Circle(3.5);
          Circle c2 = new Circle(4.2);
  
          System.out.printf("圆1的面积: %.2f\n", c1.calculateArea());
          System.out.printf("圆2的面积: %.2f\n", c2.calculateArea());
          System.out.println("总圆数: " + Circle.getTotalCircles());
      }
  }
  
  

• 运算符

  public class OperatorsExample {
      public static void main(String[] args) {
          int a = 15, b = 5, c = 2;
  
          // 使用括号来明确运算优先级
          int result = (a + b) * c - (b % c);
          System.out.println("表达式计算结果: " + result);
  
          // 复合赋值运算符
          a += 5;  // a = a + 5
          System.out.println("a 经过复合赋值运算后的值: " + a);
  
          // 三目运算符
          int max = (a > b) ? a : b;
          System.out.println("a 和 b 中较大的值: " + max);
  
          // 自增和自减运算符
          int preIncrement = ++a;  // 先加再使用
          int postDecrement = b--; // 先使用再减
          System.out.println("自增后的 a: " + preIncrement);
          System.out.println("自减后的 b: " + postDecrement);
  
          // 逻辑运算符
          boolean condition = (a > 20) && (b < 10);
          System.out.println("逻辑运算结果 (a > 20) && (b < 10): " + condition);
      }
  }
  
  

• 字符串

  import java.nio.charset.StandardCharsets;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  public class StringExample {
      public static void main(String[] args) {
          String str = "Hello, World! 123 Java";
  
          // 字符串拼接
          String result = str + " - Welcome!";
          System.out.println("拼接后的字符串: " + result);
  
          // 查找某一子字符串
          int index = str.indexOf("Java");
          System.out.println("Java 字符串的起始索引: " + index);
  
          // 正则表达式匹配
          String regex = "\\d+";  // 匹配数字
          Pattern pattern = Pattern.compile(regex);
          Matcher matcher = pattern.matcher(str);
          while (matcher.find()) {
              System.out.println("找到的数字: " + matcher.group());
          }
  
          // 字符串替换
          String replaced = str.replace("World", "Java");
          System.out.println("替换后的字符串: " + replaced);
  
          // 字符串分割
          String[] words = str.split(" ");
          System.out.println("分割后的数组: ");
          for (String word : words) {
              System.out.println(word);
          }
  
          // 大小写转换
          System.out.println("大写字符串: " + str.toUpperCase());
          System.out.println("小写字符串: " + str.toLowerCase());
  
          // 字符编码转换
          byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
          String encodedString = new String(bytes, StandardCharsets.UTF_8);
          System.out.println("编码转换后的字符串: " + encodedString);
      }
  }
  
  

• 流程控制
  实现一个科学计算器，支持平方、平方根和阶乘计算。

  import java.util.Scanner;
  
  public class ScientificCalculator {
  
      public static double square(double number) {
          return number * number;
      }
  
      public static double squareRoot(double number) {
          if (number < 0) {
              throw new IllegalArgumentException("不能计算负数的平方根！");
          }
          return Math.sqrt(number);
      }
  
      public static long factorial(int number) {
          if (number < 0) {
              throw new IllegalArgumentException("不能计算负数的阶乘！");
          }
          long result = 1;
          for (int i = 1; i <= number; i++) {
              result *= i;
          }
          return result;
      }
  
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
  
          while (true) {
              System.out.print("\n选择操作：1. 平方  2. 平方根  3. 阶乘  4. 退出\n请输入选项：");
              int choice = scanner.nextInt();
  
              if (choice == 4) {
                  System.out.println("退出程序。");
                  break;
              }
  
              System.out.print("请输入一个数字：");
              double number = scanner.nextDouble();
  
              switch (choice) {
                  case 1 -> System.out.printf("平方结果：%.2f\n", square(number));
                  case 2 -> System.out.printf("平方根结果：%.2f\n", squareRoot(number));
                  case 3 -> {
                      int intNumber = (int) number;
                      System.out.printf("阶乘结果：%d\n", factorial(intNumber));
                  }
                  default -> System.out.println("无效选项！");
              }
          }
      }
  }
  

• 大数

  import java.math.BigInteger;
  import java.math.BigDecimal;
  
  public class BigNumbersExample {
      public static void main(String[] args) {
          // BigInteger 示例
          BigInteger big1 = new BigInteger("9876543210123456789");
          BigInteger big2 = new BigInteger("1234567890987654321");
  
          // 大数加法
          BigInteger sum = big1.add(big2);
          System.out.println("大数加法结果: " + sum);
  
          // 大数乘法
          BigInteger product = big1.multiply(big2);
          System.out.println("大数乘法结果: " + product);
  
          // BigDecimal 示例 - 处理精度高的小数
          BigDecimal decimal1 = new BigDecimal("0.123456789123456789123456789");
          BigDecimal decimal2 = new BigDecimal("0.987654321987654321987654321");
  
          // 小数加法
          BigDecimal decimalSum = decimal1.add(decimal2);
          System.out.println("大数小数加法结果: " + decimalSum);
  
          // 小数乘法
          BigDecimal decimalProduct = decimal1.multiply(decimal2);
          System.out.println("大数小数乘法结果: " + decimalProduct);
  
          // 限定小数精度
          BigDecimal rounded = decimalProduct.setScale(10, BigDecimal.ROUND_HALF_UP);
          System.out.println("四舍五入后的小数: " + rounded);
      }
  }
  

• 数组
  实现一个成绩管理系统，支持存储、更新和计算多个学生的平均成绩。

  import java.util.Scanner;
  
  public class GradeManager {
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
          System.out.print("请输入学生人数：");
          int numStudents = scanner.nextInt();
  
          double[] grades = new double[numStudents];
  
          for (int i = 0; i < numStudents; i++) {
              System.out.printf("请输入学生 %d 的成绩：", i + 1);
              grades[i] = scanner.nextDouble();
          }
  
          double sum = 0;
          for (double grade : grades) {
              sum += grade;
          }
          double average = sum / numStudents;
  
          System.out.printf("所有学生的平均成绩为：%.2f\n", average);
      }
  }