Home LLM的test oracle生成

# 基本语法

## 不同分类

  • JDK：Java 开发包，提供编译、运行 Java 程序所需的各种工具和资源，包括 Java 编译器、Java 运行时环境，以及常用的 Java 类库等。

  • JRE：Java 运行环境，用于解释执行 Java 的字节码文件

  • JVM：Java 虚拟机，是 JRE 的一部分。负责解释执行字节码文件，是可运行 java 字节码文件的虚拟计算机

  • JDK 包含 JRE，JDK 和 JRE 中都包含 JVM。JDK 出了包含 jre 还包含一些常用开发工具和基础类库。JDK 用于开发。

  • JRE 用于运行 java 程序

  • JVM 是 java 编程语言的核心并且具有平台独立性。

# Java 的基本语法

# 方法格式

1
2
3
4
5
6
7
权限修饰符	返回值声明	方法名称{参数列表}{

​	方法中封装的逻辑功能;

​	return 返回值：

}

# 权限修饰符

  1. public ：

    • 说明: public 修饰符可以应用于类、接口、方法和变量。

    • 访问权限：任何其他类都可以访问被 public 修饰的成员，不论这些类是否在同一个包内。

    • 示例:

      1
      2
      3
      4
      5
      6
      7
      public class MyClass {
          public int myPublicVar;
          
          public void myPublicMethod() {
              // 方法体
          }
      }

  2. protected :

    • 说明: protected 修饰符可以应用于成员变量和方法，但不能用于类（除非用于内部类）。

    • 访问权限：被 protected 修饰的成员可以被同一个包内的类以及其他包中的子类访问。

    • 示例：

      1
      2
      3
      4
      5
      6
      7
      public class MyClass {
          protected int myProtectedVar;
          
          protected void myProtectedMethod() {
              // 方法体
          }
      }

  3. default（无修饰符）:

    • 说明：如果没有显式地指定任何访问修饰符，则默认为包访问权限（也称为 “default”）。

    • 访问权限：只有同一个包内的类可以访问被 default 修饰的成员，其他包内的类无法访问。

    • 示例：

      1
      2
      3
      4
      5
      6
      7
      class MyClass {
          int myDefaultVar;
          
          void myDefaultMethod() {
              // 方法体
          }
      }

  4. private:

    • 说明: private 修饰符可以应用于成员变量和方法，但不能用于类（除非用于内部类）。

    • 访问权限：被 private 修饰的成员只能在它所在的类内部访问，其他类不能访问。

    • 示例：

      1
      2
      3
      4
      5
      6
      7
      class MyClass {
          int myDefaultVar;
          
          void myDefaultMethod() {
              // 方法体
          }
      }

# 简介

# 1. 基本结构

Java 程序的基本结构包括包声明、导入语句、类声明和方法。

1
2
3
4
5
6
7
8
9
package com.example; // 包声明

import java.util.Scanner; // 导入语句

public class Main { // 类声明
    public static void main(String[] args) { // 主方法
        System.out.println("Hello, World!"); // 输出语句
    }
}

# 2. 注释

Java 有三种类型的注释：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 单行注释：适用于短的注释

/*
多行注释：适用于较长的注释
可以覆盖多行
*/

/**
 * 文档注释：用于生成API文档
 * 通常用于类、方法和字段的说明
 */
public class Main {
    // ...
}

# 3. 变量和数据类型

Java 中的变量分为基本数据类型和引用数据类型。

# 基本数据类型：

  • 整数类型： byte (8 位), short (16 位), int (32 位), long (64 位)
  • 浮点类型： float (32 位), double (64 位)
  • 字符类型： char (16 位)
  • 布尔类型： boolean (true 或 false)

1
2
3
4
int age = 25;
double price = 19.99;
char grade = 'A';
boolean isJavaFun = true;

# 引用数据类型：

  • 类（包括字符串）、数组、接口等

1
2
String greeting = "Hello, World!";
int[] numbers = {1, 2, 3, 4, 5};

# 4. 运算符

Java 提供了丰富的运算符，包括：

# 算术运算符：

  • + (加)
  • - (减)
  • * (乘)
  • / (除)
  • % (取余)

1
2
3
4
5
6
7
int a = 10;
int b = 5;
int sum = a + b;       // 15
int difference = a - b; // 5
int product = a * b;    // 50
int quotient = a / b;   // 2
int remainder = a % b;  // 0

# 关系运算符：

  • == (等于)
  • != (不等于)
  • > (大于)
  • < (小于)
  • >= (大于等于)
  • <= (小于等于)

1
2
3
4
boolean isEqual = (a == b);   // false
boolean isNotEqual = (a != b); // true
boolean isGreater = (a > b);   // true
boolean isLess = (a < b);      // false

# 逻辑运算符：

  • && (逻辑与)
  • || (逻辑或)
  • ! (逻辑非)

1
2
3
boolean andResult = (a > 0 && b > 0); // true
boolean orResult = (a > 0 || b > 0);  // true
boolean notResult = !(a > 0);         // false

# 5. 控制结构

# 条件语句：

用于根据条件执行不同的代码块。

1
2
3
4
5
6
7
8
9
int score = 85;

if (score >= 90) {
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else {
    System.out.println("Grade: C");
}

# 循环语句：

用于重复执行代码块。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

// while 循环
int j = 0;
while (j < 5) {
    System.out.println("j = " + j);
    j++;
}

// do-while 循环
int k = 0;
do {
    System.out.println("k = " + k);
    k++;
} while (k < 5);

# 6. 数组

数组用于存储相同类型的多个值。

1
2
3
4
5
6
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie"};

for (int i = 0; i < numbers.length; i++) {
    System.out.println("Number: " + numbers[i]);
}

# 7. 方法

方法用于封装一段代码，使其可以被多次调用。

1
2
3
4
5
6
7
8
9
10
public class Main {
    public static void main(String[] args) {
        int result = add(5, 10);
        System.out.println("Sum: " + result);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

# 8. 面向对象编程 (OOP) 概念

# 类和对象：

类是对象的模板，对象是类的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        person1.display();
    }
}

# 继承：

类可以继承其他类的属性和方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Animal {
    public void eat() {
        System.out.println("This animal eats food.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();
        myDog.bark();
    }
}

# 多态：

多态允许对象以多种形式出现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class Cat extends Animal {
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Dog extends Animal {
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound(); // 输出 "Dog barks"

        myAnimal = new Cat();
        myAnimal.sound(); // 输出 "Cat meows"
    }
}

# 9. 异常处理

Java 中的异常处理机制包括 try-catch-finally 块，用于处理程序运行时的异常。

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // 会抛出ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Error: Division by zero");
        } finally {
            System.out.println("This block is always executed");
        }
    }
}

# 10. 文件 I/O

Java 提供了丰富的文件 I/O 类来读写文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.io.*;

public class Main {
    public static void main(String[] args) {
        // 写入文件
        try {
            FileWriter writer = new FileWriter("output.txt");
            writer.write("Hello, World!");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读取文件
        try {
            BufferedReader reader = new BufferedReader(new FileReader("output.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

# 11. 枚举

枚举是一种特殊的类，用于定义常量集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {
    public enum Day {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }

    public static void main(String[] args) {
        Day day = Day.MONDAY;

        switch (day) {
            case SUNDAY:
                System.out.println("It's Sunday");
                break;
            case MONDAY:
                System.out.println("It's Monday");
                break;
            // 其他情况...
            default:
                System.out.println("Other day");
                break;
        }
    }
}

# 12. 泛型

泛型允许在类、接口和方法中使用类型参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");

        for (String s : list) {
            System.out.println(s);
        }
    }
}

# 总结

这些基本语法和概念涵盖了 Java 编程的主要方面，包括变量、运算符、控制结构、数组、方法、面向对象编程、异常处理、文件 I/O、枚举和泛型。掌握这些内容将帮助你建立坚实的 Java 编程基础，能够编写、调试和维护 Java 应用程序。

# Assert 介绍

# org.assertj.core.api 库

# 通用断言 ( AbstractAssert )

  • isEqualTo(Object expected) : 断言对象等于预期值。
  • isNotEqualTo(Object other) : 断言对象不等于给定值。
  • isNull() : 断言对象为 null。
  • isNotNull() : 断言对象不为 null。
  • isSameAs(Object expected) : 断言对象与预期对象是同一个实例。
  • isNotSameAs(Object other) : 断言对象与给定对象不是同一个实例。
  • isInstanceOf(Class<?> type) : 断言对象是给定类型的实例。
  • isNotInstanceOf(Class<?> type) : 断言对象不是给定类型的实例。
  • isInstanceOfAny(Class<?>... types) : 断言对象是给定类型中的任意一种的实例。
  • isNotInstanceOfAny(Class<?>... types) : 断言对象不是给定类型中的任意一种的实例。

# 数值断言 ( AbstractComparableAssert )

  • isGreaterThan(Comparable<?> other) : 断言对象大于给定值。
  • isLessThan(Comparable<?> other) : 断言对象小于给定值。
  • isGreaterThanOrEqualTo(Comparable<?> other) : 断言对象大于或等于给定值。
  • isLessThanOrEqualTo(Comparable<?> other) : 断言对象小于或等于给定值。
  • isBetween(Comparable<?> start, Comparable<?> end) : 断言对象在给定范围内。

# 字符串断言 ( AbstractCharSequenceAssert )

  • contains(CharSequence... values) : 断言字符串包含给定值。
  • doesNotContain(CharSequence... values) : 断言字符串不包含给定值。
  • startsWith(CharSequence prefix) : 断言字符串以给定前缀开始。
  • endsWith(CharSequence suffix) : 断言字符串以给定后缀结束。
  • matches(CharSequence regex) : 断言字符串匹配给定正则表达式。
  • doesNotMatch(CharSequence regex) : 断言字符串不匹配给定正则表达式。

# 集合断言 ( AbstractIterableAssert )

  • contains(T... values) : 断言集合包含给定元素。
  • doesNotContain(T... values) : 断言集合不包含给定元素。
  • containsExactly(T... values) : 断言集合包含且仅包含给定元素，且顺序一致。
  • containsExactlyInAnyOrder(T... values) : 断言集合包含且仅包含给定元素，但顺序不必一致。
  • containsAnyOf(T... values) : 断言集合包含给定元素中的任意一个。
  • isEmpty() : 断言集合为空。
  • isNotEmpty() : 断言集合不为空。
  • hasSize(int size) : 断言集合大小为给定值。

# Map 断言 ( AbstractMapAssert )

  • containsKey(K key) : 断言映射包含给定键。
  • doesNotContainKey(K key) : 断言映射不包含给定键。
  • containsValue(V value) : 断言映射包含给定值。
  • doesNotContainValue(V value) : 断言映射不包含给定值。
  • containsEntry(K key, V value) : 断言映射包含给定键值对。
  • doesNotContainEntry(K key, V value) : 断言映射不包含给定键值对。
  • hasSize(int size) : 断言映射大小为给定值。

# 异常断言 ( AbstractThrowableAssert )

  • hasMessage(String message) : 断言异常信息为给定值。
  • hasMessageContaining(String message) : 断言异常信息包含给定值。
  • hasCause(Throwable cause) : 断言异常有给定原因。
  • hasNoCause() : 断言异常没有原因。

# 文件断言 ( AbstractFileAssert )

  • exists() : 断言文件存在。
  • doesNotExist() : 断言文件不存在。
  • isFile() : 断言是文件。
  • isDirectory() : 断言是目录。
  • hasContent(String content) : 断言文件内容为给定值。
  • hasExtension(String extension) : 断言文件扩展名为给定值。

# 日期时间断言 ( AbstractDateAssert , AbstractLocalDateTimeAssert , AbstractLocalTimeAssert , AbstractZonedDateTimeAssert )

  • isBefore(Date date) : 断言日期早于给定日期。
  • isAfter(Date date) : 断言日期晚于给定日期。
  • isEqualTo(Date date) : 断言日期等于给定日期。
  • isBetween(Date start, Date end) : 断言日期在给定范围内。

# 其它常用断言

  • OptionalAssert : 用于 Optional 类型的断言。
  • StreamAssert : 用于 Stream 类型的断言。
  • FutureAssert : 用于 Future 类型的断言。