基础语法

1. Hello World

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

讲解

这是一个典型的Java程序，它定义了一个名为HelloWorld的类，该类包含一个main方法——Java应用程序的入口点。System.out.println("Hello, World!");打印出"Hello, World!"到控制台。

2. 数据类型

int a = 100;
float b = 5.25f;
double c = 5.25;
boolean d = true;
char e = 'A';
String f = "Hello";

讲解

此代码片段展示了Java中的基本数据类型。int是整数，float和double是浮点数，boolean是布尔类型，char用于单个字符，String用于字符串。

3. 条件判断

if (a > b) {
    // 条件成立时执行
} else if (a == b) {
    // 另一个条件
} else {
    // 条件都不成立时执行
}

讲解

使用条件判断来执行不同的代码块。if-else的结构帮助程序做出选择，执行基于不同条件的代码。

4. 循环结构

for循环

for (int i = 0; i < 10; i++) {
    System.out.println("i: " + i);
}

讲解

for循环允许在满足某个条件时重复执行代码。这里的for循环从0开始，打印到9。

while循环

int i = 0;
while (i < 10) {
    System.out.println("i: " + i);
    i++;
}

讲解

while循环在一个条件成立时不断执行一段代码。只要i小于10，就会继续循环。

do-while循环

int i = 0;
do {
    System.out.println("i: " + i);
    i++;
} while (i < 10);

讲解

do-while循环与while循环相似，但它在先执行一次代码之后，才检查条件。

5. 数组

int[] arr = new int[5];
arr[0] = 1;
arr[1] = 2;
// ...
int[] arr2 = {1, 2, 3, 4, 5};

讲解

数组是用于存储同一类型元素的集合。int[] arr是一个整数数组，arr2是一个带初始化的数组。

6. 方法定义与调用

public static int add(int a, int b) {
    return a + b;
}
int sum = add(5, 3); // 调用方法

讲解

方法是可重用的代码段。add是一个方法，它接收两个整数参数并返回它们的和。通过调用add(5, 3)获取结果。

面向对象编程

7. 类与对象

public class Dog {
    String name;

    public void bark() {
        System.out.println(name + " says: Bark!");
    }
}

Dog myDog = new Dog();
myDog.name = "Rex";
myDog.bark();

讲解

Dog类具有属性name和方法bark。通过创建Dog对象并设置其属性, 可以调用其方法。

8. 构造方法

public class User {
    String name;

    public User(String newName) {
        name = newName;
    }
}

User user = new User("Alice");

讲解

构造方法用于对象初始化。在User类中，构造函数赋值name为传入的参数。

9. 继承

public class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

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

Dog dog = new Dog();
dog.eat(); // 继承自Animal
dog.bark();

讲解

继承允许类继承其他类的属性和方法。Dog继承Animal，因此可以调用eat方法。

10. 接口

public interface Animal {
    void eat();
}

public class Dog implements Animal {
    public void eat() {
        System.out.println("The dog eats.");
    }
}

Dog dog = new Dog();
dog.eat();

讲解

接口定义类须实现的方法。Dog类实现Animal接口，需要具体化eat方法。

11. 抽象类

public abstract class Animal {
    abstract void eat();
}

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

Animal dog = new Dog();
dog.eat();

讲解

抽象类可以包含抽象方法，子类必须实现这些方法。Dog类实现抽象类Animal的eat方法。

12. 方法重载

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

    double add(double a, double b) {
        return a + b;
    }

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

Calculator calc = new Calculator();
calc.add(5, 3); // 调用第一个方法
calc.add(5.0, 3.0); // 调用第二个方法
calc.add(5, 3, 2); // 调用第三个方法

讲解

方法重载允许在同一类中创建多个同名方法，但参数类型或数量不同。Java选择最匹配的签名。

13. 方法重写

public class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

Animal myDog = new Dog();
myDog.makeSound(); // 输出 "Bark"

讲解

重写允许子类提供父类方法的新实现。在Dog中，makeSound方法重写了Animal类的方法。

14. 多态

public class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

public class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

public class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

Animal myAnimal = new Dog();
myAnimal.makeSound(); // Bark
myAnimal = new Cat();
myAnimal.makeSound(); // Meow

讲解

多态允许一个对象表现为多种类型。makeSound方法可由Animal类型引用调用，并根据对象类型改变行为。

15. 封装

public class Account {
    private double balance;

    public Account(double initialBalance) {
        if(initialBalance > 0) {
            balance = initialBalance;
        }
    }

    public void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if(amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}

Account myAccount = new Account(50);
myAccount.deposit(150);
myAccount.withdraw(75);
System.out.println(myAccount.getBalance()); // 应输出：125.0

讲解

封装通过隐藏类信息实现。使用private变量限制直接访问，提供公共方法来调整内部状态。

16. 静态变量和方法

public class MathUtils {
    public static final double PI = 3.14159;

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

    public static double subtract(double a, double b) {
        return a - b;
    }

    public static double multiply(double a, double b) {
        return a * b;
    }
}

double circumference = MathUtils.PI * 2 * 5;
System.out.println(circumference); // 打印圆的周长

讲解

静态变量和方法属于类本身，而不属于单一对象。可以直接用类名.方法进行调用，例如计算圆周长。

17. 内部类

public class OuterClass {
    private String msg = "Hello";

    class InnerClass {
        void display() {
            System.out.println(msg);
        }
    }

    public void printMessage() {
        InnerClass inner = new InnerClass();
        inner.display();
    }
}

OuterClass outer = new OuterClass();
outer.printMessage(); // 输出 "Hello"

讲解

内部类是定义在另一个类中的类。提供从内部访问外部类成员的权限。用于封装逻辑相关的类。

18. 匿名类

abstract class SaleTodayOnly {
    abstract int dollarsOff();
}

public class Store {
    public SaleTodayOnly sale = new SaleTodayOnly() {
        int dollarsOff() {
            return 3;
        }
    };
}

Store store = new Store();
System.out.println(store.sale.dollarsOff()); // 应输出3

讲解

匿名类允许创建没有名字的类实例。这些类通常用于简化一次性使用，定义新的子类或实现接口。

高级编程概念

19. 泛型

public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

Box<Integer> integerBox = new Box<>();
integerBox.set(10);
System.out.println(integerBox.get()); // 应输出：10

讲解

泛型提供一种创建类型安全的代码方式，允许类、接口和方法在实现中使用类型参数。这样可避免类型转换错误。

20. 集合框架

ArrayList

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list); // 应输出：[Java, Python, C++]

讲解

ArrayList是一个动态数组，允许根据需要调整大小。非常适合用于需要频繁添加和删除的场景。

HashMap

import java.util.HashMap;

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);
System.out.println(map.get("Apple")); // 应输出：1

讲解

HashMap是一种基于哈希表的数据结构，提供键与值的映射。高效支持基本操作如插入、检索、删除。

21. 异常处理

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
} finally {
    System.out.println("This will always be printed.");
}

讲解

Java支持异常处理以捕获和处理错误。try-catch-finally块用于检测错误并执行备用代码，确保某些操作无论是否发生异常都执行。

22. 文件I/O

读取文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

String line;
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

讲解

文件I/O用于读写文件。此代码使用BufferedReader和FileReader读取文件，捕获和处理IO异常，以便安全进行文件操作。

写入文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("Hello World!");
} catch (IOException e) {
    e.printStackTrace();
}

讲解

文件写入也使用了try-with-resources，确保在写入后自动关闭BufferedWriter，处理IO异常，保证写入的安全和完整性。

23. 多线程

创建线程

class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread running");
    }
}

MyThread myThread = new MyThread();
myThread.start();

讲解

继承Thread类并覆盖run方法可以创建新线程。通过调用start方法启动线程，执行run中的代码。

实现Runnable接口

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable running");
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

讲解

实现Runnable接口是创建线程的另一种方式。将Runnable实例传递给Thread构造方法并调用start。

24. 同步

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

讲解

同步确保线程安全访问共享资源。synchronized关键字用于锁定代码块，以防止多个线程同时访问，以便保证数据一致性。

25. 高级多线程

使用Executors

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService executor = Executors.newFixedThreadPool(2);

executor.submit(() -> {
    System.out.println("ExecutorService running");
});

executor.shutdown();

讲解

Executors提供一个框架来控制线程池。用于管理线程的创建和安排，优化多线程任务执行。

Future和Callable

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

Callable<Integer> callableTask = () -> {
    return 10;
};

ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Integer> future = executorService.submit(callableTask);

try {
    Integer result = future.get(); // this will wait for the task to finish
    System.out.println("Future result: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    executorService.shutdown();
}

讲解

Callable可以返回结果和抛出异常。结合Future和线程池可以执行耗时任务，并在以后获取结果或处理异常，是构建并发应用的实用工具。

26. 线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {
    fixedThreadPool.execute(() -> {
        System.out.println("Running in thread: " + Thread.currentThread().getName());
    });
}

fixedThreadPool.shutdown();

讲解

线程池管理线程的创建和销毁，允许重用现有的线程来处理多个任务，以减少开销并提高性能。newFixedThreadPool创建一个固定数量线程的线程池。

27. 可变参数

public static void printNumbers(int... numbers) {
    for (int num : numbers) {
        System.out.println(num);
    }
}

public static void main(String[] args) {
    printNumbers(1, 2, 3, 4, 5);
}

讲解

可变参数（varargs）允许传递不确定数量的参数给方法。用语法int... numbers定义变量参数，可以当作数组使用。

28. 枚举

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is " + today);
    }
}

讲解

枚举是一种特殊类，用于定义有限数量的常量。它显式表达一个变量可选项列表，提升代码可读性和安全性。

29. 反射

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("java.lang.String");
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println("Method: " + method.getName());
        }
    }
}

讲解

反射允许在运行时动态访问类、方法和字段。此技术可用于工具开发、序列化框架和依赖注入等高级任务，并提供方法遍历java.lang.String类。

30. 注解

@interface MyAnnotation {
    String value();
}

@MyAnnotation(value = "Example")
public class AnnotatedClass {
    // 该类使用了自定义注解
}

讲解

注解为代码提供元数据，广泛应用于框架和库中查找信息。自定义注解可用于文档记录和静态检查。

31. Singleton模式

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

讲解

单例模式保证一个类只有一个实例，并提供一个全局访问点。使用私有构造函数和静态方法，下次调用getInstance()时返回已有实例。

32. Builder模式

public class Product {
    private final String name;
    private final double price;

    private Product(Builder builder) {
        this.name = builder.name;
        this.price = builder.price;
    }

    public static class Builder {
        private String name;
        private double price;

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setPrice(double price) {
            this.price = price;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }
}

Product product = new Product.Builder()
    .setName("Example Product")
    .setPrice(29.99)
    .build();

讲解

建造者模式允许构建复杂对象的过程与表示分离。此模式尤其适合对象具有多个可选参数的情况，通过链式调用提升代码易读性。

33. Lambda表达式

interface MathOperation {
    int operation(int a, int b);
}

MathOperation addition = (a, b) -> a + b;

System.out.println(addition.operation(5, 3)); // 应输出8

讲解

Lambda表达式是简化的一种匿名内部类，提供了简洁的语法来表示函数式接口（只有一个抽象方法的接口）的实现。

34. 方法引用

import java.util.function.Consumer;

public class MethodReference {
    public static void main(String[] args) {
        Consumer<String> printer = System.out::println;
        printer.accept("Hello, Java!");
    }
}

讲解

方法引用是一种简洁且易读的Lambda表达式形式。使用::引用类方法或实例方法，如System.out::println。

35. Stream API

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.stream()
             .filter(name -> name.startsWith("A"))
             .forEach(System.out::println);
    }
}

讲解

Stream API支持以声明式风格处理数据集合，简化代码，并支持集合操作如过滤、映射和归约。

36. 正则表达式

import java.util.regex.Matcher;
import java.util.regex.Pattern;

Pattern pattern = Pattern.compile("a*b");
Matcher matcher = pattern.matcher("aaaaab");
boolean matchFound = matcher.matches();
System.out.println("Match Found: " + matchFound);

讲解

正则表达式提供强大的模式匹配机制。Pattern和Matcher类是Java正则表达式API的核心，支持各种复杂字符串操作。

37. JUnit单元测试

import static org.junit.Assert.assertEquals;
import org.junit.Test;

public class SimpleTest {
    @Test
    public void testAddition() {
        assertEquals(5, 2 + 3);
    }
}

讲解

JUnit是Java生态系统中常用的单元测试框架，使用简单注解@Test来定义测试方法，并通过断言检查程序行为。

38. 序列化和反序列化

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;

    Person(String name) {
        this.name = name;
    }
}

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
    Person person = new Person("Alice");
    oos.writeObject(person);
} catch (IOException e) {
    e.printStackTrace();
}

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
    Person deserializedPerson = (Person) ois.readObject();
    System.out.println("Deserialized Name: " + deserializedPerson.name);
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

讲解

序列化可将对象转换为字节流以便存储或传输。反序列化则是将字节流恢复为对象。Serializable接口标记类支持这些过程。

39. 图形用户界面(GUI)基础

import javax.swing.*;
import java.awt.*;

public class SimpleGUI {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Simple GUI");
        JButton button = new JButton("Press me");

        button.addActionListener(e -> System.out.println("Button pressed!"));

        frame.setLayout(new FlowLayout());
        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

讲解

Java的Swing库用于创建图形用户界面，需要创建JFrame作为窗口，添加JButton等组件，并添加事件监听来处理用户交互。

40. 网络编程

import java.net.*;
import java.io.*;

public class SimpleClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 1234);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            out.println("Hello Server!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

讲解

网络编程支持通信程序之间的连接和数据交换。这里程序创建一个简单的TCP客户端，通过Socket连接发送数据。

41. JDBC数据库连接

import java.sql.*;

public class DatabaseExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "username";
        String password = "password";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM mytable")) {
            while (rs.next()) {
                System.out.println(rs.getString("column_name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

讲解

JDBC是Java用于数据库交互的API，执行查询和更新SQL数据库。连接数据库后，通过Statement接口执行SQL语句操作。

42. 使用Optional类

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Hello");
        optionalValue.ifPresent(System.out::println);

        String value = optionalValue.orElse("Default Value");
        System.out.println(value);
    }
}

讲解

Optional是Java 8引入的一个容器类，用于避免null值引发的异常，提供安全获取和操作潜在有无的值的方法。

43. 使用LocalDate和LocalDateTime

import java.time.LocalDate;
import java.time.LocalDateTime;

public class DateExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalDateTime dateTime = LocalDateTime.now();

        System.out.println("Date: " + date);
        System.out.println("DateTime: " + dateTime);
    }
}

讲解

LocalDate和LocalDateTime是用于处理日期和时间的新API，提供更简便和安全的方法来操作时间信息，而不再使用线程不安全的java.util.Date.

44. 在Java中使用正则进行匹配

import java.util.regex.Pattern;

public class RegexExample {
    public static void main(String[] args) {
        String text = "Java is fun!";
        Pattern pattern = Pattern.compile("Java");
        if (pattern.matcher(text).find()) {
            System.out.println("The text contains 'Java'");
        }
    }
}

讲解

正则表达式是一种强有力的工具，用于在字符串中寻找符合条件的子串，Pattern和Matcher在Java中提供了正则表达式的完整支持。

45. 使用CompletableFuture进行异步编程

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("Async Task");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
    }
}

讲解

CompletableFuture 是 Java 8 中引入的新类，用于异步编程，可以在非阻塞的方式下完成任务，提高程序的性能和响应能力。

46. Java中VCS的应用

Java中的版本控制系统（VCS）通常使用Git，在代码示例中不直接涉及VCS的具体应用，而是强调良好使用版本控制策略的重要性，包括常见的分支管理（如Git Flow）、提交管理以及使用IDE集成VCS工具进行代码变更跟踪和历史管理。

47. Java中实现Observer设计模式

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();
    
    void addObserver(Observer o) {
        observers.add(o);
    }
    
    void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

class ConcreteObserver implements Observer {
    private String name;
    
    ConcreteObserver(String name) {
        this.name = name;
    }

    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

public class ObserverDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");
        
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        
        subject.notifyObservers("Hello, Observers!");
    }
}

讲解

观察者模式定义对象间的一对多依赖关系。当一个对象改变状态时，所有依赖者都会收到通知并自动更新。适用于系统中多个对象间的这类通信需求。

48. 使用Spring Boot构建Web应用

Spring Boot是一个用于创建独立、生产级Spring应用程序的框架，提供了约定优于配置理念，简化了Spring应用的开发过程。以下是一个简单的Spring Boot应用示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

讲解

@SpringBootApplication注解标记Spring Boot应用主类，该类需拥有main方法来启动应用。@RestController和@GetMapping用于定义RESTful Web服务端点。

49. 使用Hibernate进行持久化

Hibernate是Java中的一种持久化框架，简化了数据库访问，并实现了轻量级的Object-Relational Mapping (ORM)。以下是一个基本示例：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and setters
}

public class HibernateUtil {
    private static final SessionFactory sessionFactory = new Configuration()
        .configure("hibernate.cfg.xml")
        .buildSessionFactory();
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

public class HibernateExample {
    public static void main(String[] args) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();

            User user = new User();
            user.setName("Alice");
            
            session.save(user);
            session.getTransaction().commit();
        }
    }
}

讲解

Hibernate simplifies the task of interacting with a relational database by automatically handling the low-level details. Using annotations like @Entity, @Id, and @GeneratedValue, Hibernate can map Java objects to database tables.

50. 使用Mockito进行单元测试

Mockito是Java单元测试过程中常用的一个mocking框架，以下是一个示例：

import static org.mockito.Mockito.*;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;

public class MockitoExample {
    @Mock
    MyDatabase databaseMock;
    
    @InjectMocks
    MyService service;
    
    @Test
    public void testQuery() {
        when(databaseMock.query(anyString())).thenReturn("some data");

        String result = service.queryDatabase("query string");
        
        assertEquals("some data", result);
        verify(databaseMock).query("query string");
    }
}

讲解

Mockito通过创建、配置以及验证mock对象简化单元测试。@Mock标记的对象由Mockito的mocking机制自动生成，而@InjectMocks通过注入mock对象，实现对被测类的依赖管理。

---

以上是Java学习中常见的50个编程概念与代码示例。在掌握这些基础与高级技巧后，你将更具备驾驭Java项目开发的能力。不断学习和实践将提升你的编程技能和职业发展潜力。