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

news2025/1/21 3:43:45

三天急速通关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);
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

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…
阅读更多...
《AI赋能中国制造2025：智能变革，制造未来》

《AI赋能中国制造2025：智能变革，制造未来》

引言&#xff1a;开启智能制造新时代 在全球制造业格局深度调整的当下&#xff0c;科技变革与产业转型的浪潮汹涌澎湃。2015 年&#xff0c;我国重磅推出《中国制造 2025》这一宏伟战略&#xff0c;它如同一座灯塔&#xff0c;为中国制造业驶向高端化、智能化、绿色化的彼岸指明…
阅读更多...
Observability：最大化可观察性 AI 助手体验的 5 大提示（prompts）

Observability：最大化可观察性 AI 助手体验的 5 大提示（prompts）

作者&#xff1a;来自 Elastic Zoia_AUBRY 在过去三年担任客户工程师期间&#xff0c;我遇到了数百名客户&#xff0c;他们最常问的问题之一是&#xff1a;“我的数据在 Elastic 中&#xff1b;我该如何利用它获得最大优势&#xff1f;”。 如果这适用于你&#xff0c;那么本…
阅读更多...
Mysql常见问题处理集锦

Mysql常见问题处理集锦

Mysql常见问题处理集锦 root用户密码忘记&#xff0c;重置的操作(windows上的操作)MySQL报错&#xff1a;ERROR 1118 (42000): Row size too large. 或者 Row size too large (&#xff1e; 8126).场景&#xff1a;报错原因解决办法 详解行大小限制示例&#xff1a;内容来源于网…
阅读更多...
【前端】用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 计划后续费价格高达四…
阅读更多...
ROS2 与机器人视觉入门教程（ROS2 OpenCV）

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

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

02内存结构篇（D1_自动内存管理）

目录 一、内存管理 1. C/C程序员 2. Java程序员 二、运行时数据区 1. 程序计数器 2. Java虚拟机栈 3. 本地方法栈 4. Java堆 5. 方法区 运行时常量池 三、Hotspot运行时数据区 四、分配JVM内存空间 分配堆的大小 分配方法区的大小 分配线程空间的大小 一、内存管…
阅读更多...
C#，入门教程(01)—— Visual Studio 2022 免费安装的详细图文与动画教程

C#，入门教程(01)—— Visual Studio 2022 免费安装的详细图文与动画教程

通过本课程的学习&#xff0c;你可以掌握C#编程的重点&#xff0c;享受编程的乐趣。 在本课程之前&#xff0c;你无需具备任何C#的基础知识&#xff0c;只要能操作电脑即可。 不过&#xff0c;希望你的数学不是体育老师教的。好的程序是数理化的实现与模拟。没有较好的数学基础…
阅读更多...
BGP边界网关协议（Border Gateway Protocol）路由引入、路由反射器

BGP边界网关协议（Border Gateway Protocol）路由引入、路由反射器

一、路由引入背景 BGP协议本身不发现路由&#xff0c;因此需要将其他协议路由&#xff08;如IGP路由等&#xff09;引入到BGP路由表中&#xff0c;从而将这些路由在AS之内和AS之间传播。 BGP协议支持通过以下两种方式引入路由&#xff1a; Import方式&#xff1a;按协议类型将…
阅读更多...
【Vim Masterclass 笔记21】S09L39：Vim 设置与 vimrc 文件的用法示例（二）

【Vim Masterclass 笔记21】S09L39：Vim 设置与 vimrc 文件的用法示例（二）

文章目录 S09L39 Vim Settings and the Vimrc File - Part 21 Vim 的配色方案与 color 命令2 map 命令3 示例&#xff1a;用 map 命令快速生成 HTML 代码片段4 Vim 中的 Leader 键5 用 mkvimrc 命令自动生成配置文件 写在前面 本篇为 Vim 自定义配置的第二部分。当中的每个知识…
阅读更多...
owasp SQL 注入-03 (原理)

owasp SQL 注入-03 (原理)

1: 先看一下注入界面: 点submit 后&#xff0c;可以看到有语法报错&#xff0c;说明已经起作用了: 报如下的错误: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near at line 1 2:…
阅读更多...
SpringMVC (1)

SpringMVC (1)

目录 1. 什么是Spring Web MVC 1.1 MVC的定义 1.2 什么是Spring MVC 1.3 Spring Boot 1.3.1 创建一个Spring Boot项目 1.3.2 Spring Boot和Spring MVC之间的关系 2. 学习Spring MVC 2.1 SpringBoot 启动类 2.2 建立连接 1. 什么是Spring Web MVC 1.1 MVC的定义 MVC 是…
阅读更多...
LabVIEW 实现线路板 PCB 可靠性测试

LabVIEW 实现线路板 PCB 可靠性测试

在电子设备制造领域&#xff0c;线路板 PCB&#xff08;Printed Circuit Board&#xff09;的可靠性直接影响产品的整体性能和使用寿命。企业在生产新型智能手机主板时&#xff0c;需要对 PCB 进行严格的可靠性测试&#xff0c;以确保产品在复杂环境下能稳定运行。传统的测试方…
阅读更多...
【大数据2025】Hadoop 万字讲解

【大数据2025】Hadoop 万字讲解

文章目录 一、大数据通识大数据诞生背景与基本概念大数据技术定义与特征大数据生态架构概述数据存储数据计算与易用性框架分布式协调服务和任务调度组件数仓架构流处理架构 二、HDFSHDFS 原理总结一、系统架构二、存储机制三、数据写入流程四、心跳机制与集群管理 安全模式&…
阅读更多...
【蓝桥杯】43687.赢球票

【蓝桥杯】43687.赢球票

题目描述 某机构举办球票大奖赛。获奖选手有机会赢得若干张球票。 主持人拿出 N 张卡片&#xff08;上面写着 1⋯N 的数字&#xff09;&#xff0c;打乱顺序&#xff0c;排成一个圆圈。 你可以从任意一张卡片开始顺时针数数: 1,2,3 ⋯ ⋯ 如果数到的数字刚好和卡片上的数字…
阅读更多...
Amazon MSK 开启 Public 访问 SASL 配置的方法

Amazon MSK 开启 Public 访问 SASL 配置的方法

1. 开启 MSK Public 1.1 配置 MSK 参数 进入 MSK 控制台页面&#xff0c;点击左侧菜单 Cluster configuration。选择已有配置&#xff0c;或者创建新配置。在配置中添加参数 allow.everyone.if.no.acl.foundfalse修改集群配置&#xff0c;选择到新添加的配置。 1.2 开启 Pu…
阅读更多...
学习Hibernate的调优方案

学习Hibernate的调优方案

Hibernate是一个非常流行的Java ORM&#xff08;对象关系映射&#xff09;框架&#xff0c;它可以帮助开发者更轻松地处理数据库操作。然而&#xff0c;如果不进行适当的性能调优&#xff0c;Hibernate可能会导致应用程序运行缓慢。本文将详细探讨Hibernate的调优方案&#xff…
阅读更多...
基于.Net Core+Vue的文件加密系统

基于.Net Core+Vue的文件加密系统

1系统架构图 2 用例图 管理员角色的用例&#xff1a; 文件分享大厅&#xff1a;管理员可以访问文件分享大厅&#xff0c;下载文件。个人信息管理&#xff1a;管理员可以更新自己的个人信息&#xff0c;修改密码。用户管理&#xff1a;管理员负责创建、更新或删除用户账户&…
阅读更多...
【React】静态组件动态组件

【React】静态组件动态组件

目录 静态组件动态组件创建一个构造函数(类)使用 class 实现组件**使用 function 实现类组件** 静态组件 函数组件是静态组件&#xff1a; 组件第一次渲染完毕后&#xff0c;无法基于内部的某些操作让组件更新「无法实现自更新」&#xff1b;但是&#xff0c;如果调用它的父组…
阅读更多...
Linux UDP 编程详解

Linux UDP 编程详解

一、引言 在网络编程领域&#xff0c;UDP&#xff08;User Datagram Protocol&#xff0c;用户数据报协议&#xff09;作为一种轻量级的传输层协议&#xff0c;具有独特的优势和适用场景。与 TCP&#xff08;Transmission Control Protocol&#xff0c;传输控制协议&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023