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

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

  • 0 文章说明
  • 1 关键字 Keywords
  • 2 注释 Comments
    • 2.1 单行注释
    • 2.2 多行注释
    • 2.3 文档注释
  • 3 数据类型 Data Types
    • 3.1 基本数据类型
    • 3.2 引用数据类型
  • 4 变量与常量 Variables and Constant
  • 5 运算符 Operators
  • 6 字符串 String
  • 7 输入与输出 Input and Output
        • 标准输出（System.out）
  • 8 流程控制 Control Flow
  • 9 大数 Big Numbers
  • 10 数组 Arrays
  • Final 考试

0 文章说明

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

1 关键字 Keywords

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

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
returnshortstaticstrictfpsuper
switchsynchronizedthisthrowthrows
transienttryvoidvolatilewhile

比较陌生的：

  • 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）。

类型大小（位）默认值范围
byte80-128 到 127
short160-32,768 到 32,767
int320-2³¹ 到 2³¹-1
long640L-2⁶³ 到 2⁶³-1
float320.0f约 ±3.40282347E+38F
double640.0d约 ±1.79769313486231570E+308
char16‘\u0000’单个字符（支持 Unicode 编码）
boolean不固定false仅能取值 true 或 false

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 age = 25;
局部变量在方法或代码块中定义的变量，只在该方法或代码块中有效。public void myMethod() { int localVar = 10; }
实例变量在类中定义的变量，属于类的实例，每个对象都有自己的实例变量。public class Person { String name; int age; }
类变量在类中定义的静态变量，属于类本身，所有对象共享同一个类变量。public class Person { static String species = "Homo sapiens"; }
常量值在程序运行期间不会改变的变量，通常使用final关键字修饰。final double PI = 3.14159;
实例常量属于类的实例，每个对象都有自己的实例常量。public class Person { final String species = "Homo sapiens"; }
类常量属于类本身，所有对象共享同一个类常量。public class Person { static final String species = "Homo sapiens"; }

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

  • 变量类型不匹配

    • 类型不兼容的赋值：将不同类型的变量赋值给一个变量时，需要进行显式的类型转换，或者使用正确的类型。
      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 中占据着重要的位置，对程序的执行有着很大的帮助。除了常见的加减乘除， 还有许多其他类型的运算符。

类别运算符形式说明
算术运算符+, -, *, /, %用于执行基本的加、减、乘、除和取余运算。
++, - -自增和自减运算符，前缀或后缀形式。
赋值运算符|=, +=, -=, *=, /=, %=用于给变量赋值，可结合算术运算符形成复合赋值。
关系运算符==, !=, <, >, <=, >=比较两个值的关系，返回布尔值 true 或 false。
逻辑运算符&&, ||, !用于布尔逻辑运算：逻辑与、逻辑或和逻辑非。
位运算符&, |, ^, ~位与、位或、位异或、位取反运算符。
<<, >>, >>>位移运算符：左移、右移和无符号右移。
条件运算符? :三元运算符，根据条件返回不同的值。
类型比较运算符instanceof检查对象是否是某个类的实例。
位逻辑赋值运算符&=, |=, ^=结合位运算和赋值操作。

容易出错的点：

  • 取余运算：负数取余时，结果的符号与被除数一致。
    • -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中是不可变的，这意味着一旦创建，其内容就不能被修改。
常见方法：

方法说明示例返回值
concat(String str)连接两个字符串java String s1 = "Hello"; String s2 = s1.concat(" World"); “Hello World”
+ 运算符连接两个字符串java String s1 = "Hello"; String s2 = s1 + " World"; “Hello World”
equals(Object anObject)比较两个字符串的内容是否相同java String s1 = "Hello"; String s2 = "Hello"; boolean isEqual = s1.equals(s2); true
equalsIgnoreCase(String anotherString)比较两个字符串的内容是否相同，忽略大小写java String s1 = "Hello"; String s2 = "hello"; boolean isEqual = s1.equalsIgnoreCase(s2); true
==比较两个字符串对象是否是同一个对象java String s1 = "Hello"; String s2 = "Hello"; boolean isSameObject = s1 == s2; true（因为字符串常量池）
indexOf(int ch)返回指定字符在字符串中第一次出现的索引java String s = "Hello, World!"; int index = s.indexOf('o'); 4
lastIndexOf(int ch)返回指定字符在字符串中最后一次出现的索引java String s = "Hello, World!"; int index = s.lastIndexOf('o'); 8
substring(int beginIndex)返回从指定索引开始到字符串末尾的子字符串java String s = "Hello, World!"; String sub = s.substring(7); “World!”
substring(int beginIndex, int endIndex)返回从指定开始索引到结束索引的子字符串java String s = "Hello, World!"; String sub = s.substring(7, 12); “World”
toLowerCase()将字符串转换为小写java String s = "Hello, World!"; String lower = s.toLowerCase(); “hello, world!”
toUpperCase()将字符串转换为大写java String s = "Hello, World!"; String upper = s.toUpperCase(); “HELLO, WORLD!”
trim()去除字符串两端的空白字符java String s = " Hello, World! "; String trimmed = s.trim(); “Hello, World!”
split(String regex)根据指定的正则表达式分割字符串，返回一个字符串数组java String s = "Hello,World,Java"; String[] parts = s.split(","); [“Hello”, “World”, “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类：任意精度的整数运算
方法说明示例
BigInteger(String val)通过字符串创建BigInteger对象BigInteger bigInt1 = new BigInteger("123456789012345678901234567890");
BigInteger.valueOf(long val)通过长整数值创建BigInteger对象BigInteger bigInt2 = BigInteger.valueOf(12345678901234567890L);
add(BigInteger val)加法BigInteger sum = bigInt1.add(bigInt2);
subtract(BigInteger val)减法BigInteger difference = bigInt1.subtract(bigInt2);
multiply(BigInteger val)乘法BigInteger product = bigInt1.multiply(bigInt2);
divide(BigInteger val)除法BigInteger quotient = bigInt1.divide(bigInt2);
mod(BigInteger val)取模BigInteger remainder = bigInt1.mod(bigInt2);
  • BigDecimal类：任意精度的浮点数运算
方法说明示例
BigDecimal(String val)通过字符串创建BigDecimal对象BigDecimal bigDecimal1 = new BigDecimal("12345.67890");
BigDecimal.valueOf(double val)通过double值创建BigDecimal对象BigDecimal bigDecimal2 = BigDecimal.valueOf(12345.67890);
add(BigDecimal val)加法BigDecimal sum = bigDecimal1.add(bigDecimal2);
subtract(BigDecimal val)减法BigDecimal difference = bigDecimal1.subtract(bigDecimal2);
multiply(BigDecimal val)乘法BigDecimal product = bigDecimal1.multiply(bigDecimal2);
divide(BigDecimal val, int scale, RoundingMode mode)除法，指定小数位数和舍入模式BigDecimal quotient = bigDecimal1.divide(bigDecimal2, 2, RoundingMode.HALF_UP);

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

  • 一维数组
方法说明示例
声明数组声明一个数组，但不初始化int[] arr;
静态初始化在声明数组时直接赋值int[] arr = {1, 2, 3, 4, 5};
动态初始化指定数组的长度，元素默认初始化int[] arr = new int[5];
  • 二维数组
方法说明示例
声明和初始化二维数组声明并初始化二维数组int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
  • 常见方法
方法说明示例
length获取数组长度int len = arr.length;
arr[index]访问数组元素int element = arr[0];
arr[index] = value修改数组元素arr[0] = 10;
Arrays.sort排序数组Arrays.sort(arr);
Arrays.binarySearch查找数组元素int index = Arrays.binarySearch(arr, 3);
Arrays.fill填充数组Arrays.fill(arr, 10);
Arrays.copyOf复制数组int[] copy = Arrays.copyOf(arr, arr.length);
Arrays.asList将数组转换为列表List<Integer> list = Arrays.asList(arr);
Arrays.toString将数组转换为字符串System.out.println(Arrays.toString(arr));
Arrays.deepToString将多维数组转换为字符串System.out.println(Arrays.deepToString(matrix));

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);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/956494.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Excel 技巧10 - 如何检查输入重复数据(★★）

Excel 技巧10 - 如何检查输入重复数据(★★）

本文讲了如何在Excel中通过COUNTIF来检查输入重复数据。 当输入重复数据时&#xff0c;显示错误提示。 1&#xff0c;通过COUNTIF来检查输入重复数据 比如下面是想检查不要输入重复的学号。 选中C列&#xff0c;点 Menu > 数据 > 数据验证 在数据验证页面&#xff0c…
阅读更多...
请求响应-

请求响应-

一.DispatcherServlet 前端控制器 二.HttpServletRequest 请求:获取请求数据 三.HttpServletResponse 响应:设置响应数据 四.简单参数接收 简单参数:参数名与形参变量名相同,定义形参即可接收参数。 如果参数对应不上需要通过RequestParam完成映射,注意事项:加上了参数就必须…
阅读更多...
MySQL中的GROUP_CONCAT函数将分组后的多个行值合并成一个字符串，并用指定分隔符连接

MySQL中的GROUP_CONCAT函数将分组后的多个行值合并成一个字符串，并用指定分隔符连接

文章目录 前言什么是GROUP_CONCAT&#xff1f;基本语法 使用示例示例1: 基本用法示例2: 去重并排序 高级应用应用场景示例注意事项 结论表结构1. Orders 表 (订单表)2. Order_Details 表 (订单详情表) 示例数据Orders 表的数据Order_Details 表的数据 使用 GROUP_CONCAT 的查询…
阅读更多...
游戏开发中常用的设计模式

游戏开发中常用的设计模式

目录 前言一、工厂模式二、单例模式三、观察者模式观察者模式的优势 四、状态模式状态模式的优势 五、策略模式策略模式的优势策略模式与状态模式有什么区别呢? 六、组合模式七、命令模式八、装饰器模式 前言 本文介绍了游戏开发中常用的设计模式&#xff0c;如工厂模式用于创…
阅读更多...
【前端】用OSS增强Hexo的搜索功能

【前端】用OSS增强Hexo的搜索功能

文章目录 前言配置 _config.fluid.yml云端实时更新 local-search.xml解决 OSS.Bucket 的跨域问题 前言 原文地址&#xff1a;https://blog.dwj601.cn/FrontEnd/Hexo/hexo-enhance-local-search-with-oss/ 考虑到某著名云服务商提供的云服务器在两年的 99 计划后续费价格高达四…
阅读更多...
Redis和MongoDB的区别

Redis和MongoDB的区别

前言 在项目选型阶段&#xff0c;MongoDB被选中主要是基于其处理大规模数据集的能力&#xff0c;而当时并未深入探讨其他替代方案。此前&#xff0c;Redis被用于管理少量但访问频繁的热数据。目前&#xff0c;项目采用MongoDB存储百万级数据&#xff0c;预计未来数据量将增长至…
阅读更多...
[JavaScript] 深入理解流程控制结构

[JavaScript] 深入理解流程控制结构

文章目录 1. **if-else 语句**基本语法&#xff1a;示例&#xff1a;扩展&#xff1a;else if 2. **switch-case 语句**基本语法&#xff1a;示例&#xff1a;注意事项&#xff1a; 3. **for 循环**基本语法&#xff1a;示例&#xff1a;扩展&#xff1a;for-in 和 for-of 4. *…
阅读更多...
渗透笔记1

渗透笔记1

第一天 工具&#xff1a;cs cobalt strike 4.9 / msf kali &#xff08;自带 Ubuntu&#xff09; cs cobalt strike 4.9&#xff1a;server-client server部署在云服务器上&#xff0c;client分别在各地&#xff0c;与server相连接&#xff1b;连接上后就可以共享上线主机。…
阅读更多...
C#--在多线程中使用任务并行库(TPL)--15

C#--在多线程中使用任务并行库(TPL)--15

目录 一.任务并行库的概念以及定义 二.主要特性 三.代码使用示例 1.最基础的Parallel.For使用方式 2.使用 ParallelOptions 来控制并行执行 3.Parallel.ForEach的使用(用于处理集合) 4.带有本地变量的并行循环(用于需要累加或统计的场景) 5.结合Task和Parallel的高级示…
阅读更多...
与“神”对话：Swift 语言在 2025 中的云霓之望

与“神”对话：Swift 语言在 2025 中的云霓之望

0. 引子 夜深人静&#xff0c;是一片极度沉醉的黑&#xff0c;这便于我与深沉的 macbook 悄悄隐秘于其中。一股异香袭来&#xff0c;恍惚着&#xff0c;撸码中身心极度疲惫、头脑昏沉的我仿佛感觉到了一束淡淡的微光轻洒在窗边。 我的对面若隐若现逐渐浮现出一个熟悉的身影。他…
阅读更多...
WOA-Transformer鲸鱼算法优化编码器时间序列预测（Matlab实现）

WOA-Transformer鲸鱼算法优化编码器时间序列预测（Matlab实现）

WOA-Transformer鲸鱼算法优化编码器时间序列预测&#xff08;Matlab实现&#xff09; 目录 WOA-Transformer鲸鱼算法优化编码器时间序列预测&#xff08;Matlab实现&#xff09;预测效果基本介绍程序设计参考资料 预测效果 基本介绍 1.Matlab实现WOA-Transformer鲸鱼算法优化编…
阅读更多...
基于SpringBoot和PostGIS的各国及所属机场信息检索及可视化实现

基于SpringBoot和PostGIS的各国及所属机场信息检索及可视化实现

目录 前言 一、空间数据简介 1、全球国家信息表 2、机场信息表 3、国家机场检索实现 二、SpringBoot后台实现 1、模型层实现 2、控制层实现 三、WebGIS可视化实现 1、Leaflet界面实现 2、国家及其机场可视化成果 3、全球机场数量排行榜 四、总结 前言 新春佳节即将…
阅读更多...
MLMs之Agent：Phidata的简介、安装和使用方法、案例应用之详细攻略

MLMs之Agent：Phidata的简介、安装和使用方法、案例应用之详细攻略

MLMs之Agent&#xff1a;Phidata的简介、安装和使用方法、案例应用之详细攻略 目录 Phidata简介 Phidata安装和使用方法 1、安装 2、使用方法 (1)、认证 (2)、创建 Agent (3)、运行 Agent (4)、Agent Playground Phidata 案例应用 1、多工具 Agent 2、多模态 Agent …
阅读更多...
【机器学习实战入门项目】使用深度学习创建您自己的表情符号

【机器学习实战入门项目】使用深度学习创建您自己的表情符号

深度学习项目入门——让你更接近数据科学的梦想 表情符号或头像是表示非语言暗示的方式。这些暗示已成为在线聊天、产品评论、品牌情感等的重要组成部分。这也促使数据科学领域越来越多的研究致力于表情驱动的故事讲述。 随着计算机视觉和深度学习的进步&#xff0c;现在可以…
阅读更多...
【ArcGIS微课1000例】0140：总览（鹰眼）、放大镜、查看器的用法

【ArcGIS微课1000例】0140：总览（鹰眼）、放大镜、查看器的用法

文章目录 一、总览工具二、放大镜工具三、查看器工具ArcGIS中提供了三种局部查看的工具： 总览（鹰眼）、放大镜、查看器，如下图所示，本文讲述这三种工具的使用方法。 一、总览工具 为了便于效果查看与比对，本实验采用全球影像数据（位于配套实验数据包中的0140.rar中），加…
阅读更多...
从零搭建一套远程手机的桌面操控和文件传输的小工具

从零搭建一套远程手机的桌面操控和文件传输的小工具

从零搭建一套远程手机的桌面操控和文件传输的小工具 --ADB连接专题 一、前言 前面的篇章中&#xff0c;我们确定了通过基于TCP连接的ADB控制远程手机的操作思路。本篇中我们将进行实际的ADB桥接的具体链路搭建工作&#xff0c;从原理和实际部署和操作层面上&#xff0c;从零…
阅读更多...
ROS2 与机器人视觉入门教程（ROS2 OpenCV）

ROS2 与机器人视觉入门教程（ROS2 OpenCV）

系列文章目录 前言 由于现有的ROS2与计算机视觉&#xff08;特别是机器人视觉&#xff09;教程较少&#xff0c;因此根据以往所学与积累的经验&#xff0c;对ROS2与机器人视觉相关理论与代码进行分析说明。 本文简要介绍了机器人视觉。首先介绍 ROS2 中图像发布者和订阅者的基…
阅读更多...
JVM 面试八股文

JVM 面试八股文

目录 1. 前言 2. JVM 简介 3. JVM 内存划分 3.1 为什么要进行内存划分 3.2 内存划分的核心区域 3.2.1 核心区域一: 程序计数器 3.2.2 核心区域二: 元数据区 3.2.3 核心区域三: 栈 3.2.4 核心区域四: 堆 4. JVM 类加载机制 4.1 类加载的步骤 4.1.1 步骤一: 加载 4…
阅读更多...
我的世界-与门、或门、非门等基本门电路实现

我的世界-与门、或门、非门等基本门电路实现

一、红石比较器 (1) 红石比较器结构 红石比较器有前端单火把、后端双火把以及两个侧端 其中后端和侧端是输入信号,前端是输出信号 (2) 红石比较器的两种模式 比较模式 前端火把未点亮时处于比较模式 侧端>后端 → 0 当任一侧端强度大于后端强度时,输出…
阅读更多...
【2024年华为OD机试】 (B卷,100分)- 字符串分割（Java JS PythonC/C++）

【2024年华为OD机试】 (B卷,100分)- 字符串分割（Java JS PythonC/C++）

一、问题描述 题目解析 问题描述 给定一个非空字符串 s&#xff0c;要求将该字符串分割成若干子串&#xff0c;使得每个子串的 ASCII 码值之和均为“水仙花数”。具体要求如下&#xff1a; 若分割不成功&#xff0c;则返回 0&#xff1b;若分割成功且分割结果不唯一&#x…
阅读更多...
最新文章

Copyright @ 2022~2023