S15L01 - IntelliJ IDEA 调试器概述

html

掌握 IntelliJ IDEA 中的 Java 调试：全面指南
目录

简介 ............................................................................... 1
理解 IntelliJ IDEA 中的调试 .................................. 3

2.1 什么是 Debugging？ ......................................................... 3
2.2 Java 开发中 Debugging 的重要性 ..................... 4


设置 Debugger .......................................................... 6

3.1 配置 Debug 设置 ............................................. 6
3.2 在 Debugger 中使用命令行参数 .......... 7


断点和观察点 .................................................. 9

4.1 设置断点 .......................................................... 9
4.2 实施观察点 ................................................ 10
4.3 条件断点 ................................................... 12
4.4 管理多个断点 ....................................... 14


逐步执行代码 ............................................................ 17

5.1 Step Over ................................................................. 17
5.2 Step Into ................................................................. 18
5.3 Step Out ................................................................. 19
5.4 Force Step Into .......................................................... 20


高级调试功能 ............................................... 23

6.1 检查变量 ..................................................... 23
6.2 动态修改变量值 ............................ 24
6.3 利用 Variables 面板 ......................................... 25
6.4 处理多线程应用程序 .................... 26


有效调试的最佳实践 .................................... 29

7.1 组织断点 ................................................... 29
7.2 有效使用日志 ................................................... 30
7.3 优化 Debugger 性能 ................................ 31


结论 ................................................................................. 34
补充信息 ........................................................ 36

9.1 比较表：观察点 vs. 断点 ................. 36
9.2 示例程序代码 ..................................................... 38
9.3 其他资源 .................................................. 42




简介
Debugging 是任何 Java 开发者致力于编写高效且无错误代码的基本技能。在集成开发环境 (IDEs) 领域，IntelliJ IDEA 作为一款强大的工具，配备了 robust 的 Debugger，简化了调试过程。这本电子书深入探讨了在 IntelliJ IDEA 中使用 Debugger 的复杂性，指导初学者和具备基础知识的开发者通过 essential 功能和最佳实践。
了解如何有效利用调试工具可以显著提升您的编码工作流程，使识别和快速纠正问题变得更容易。本指南涵盖了从设置 Debugger，使用断点和观察点，逐步执行代码，到利用高级调试功能的所有内容。通过阅读本电子书，您将全面了解如何使用 IntelliJ IDEA 高效地调试 Java 应用程序。
优点：

通过识别和修复 bug 提高代码质量
改善对代码执行流程的理解
节省开发过程中的时间

缺点：

如果使用不当，可能会花费大量时间
初学者可能需要一定的学习曲线

何时何地使用 Debugging：
在开发阶段，尤其是处理复杂应用程序或排除意外行为时，Debugging 是不可或缺的。在集成新功能、优化性能或维护旧代码时，Debugging 特别有用。
表格数据：使用场景


主题
使用时机
应用地点


断点
在特定代码行暂停执行以检查代码
任何关键的代码部分


观察点
监控特定变量的变化
影响关键结果的变量


条件断点
基于特定条件暂停执行
需要上下文特定检查的场景



理解 IntelliJ IDEA 中的调试
2.1 什么是 Debugging？
Debugging 是系统地识别、分析和移除软件应用程序中的 bug 或缺陷的过程。它涉及在受控环境中运行程序，开发者可以在此环境中监控执行流程、检查变量，并在不同的点评估应用程序的状态。
2.2 Java 开发中 Debugging 的重要性
在 Java 开发中，Debugging 对确保应用程序按预期运行至关重要。它有助于：

识别逻辑错误：找到导致不正确行为的代码错误。
优化性能：检测和解决性能瓶颈。
提高代码质量：确保代码健壮、可靠且易于维护。

有效的 Debugging 带来更稳定和高效的应用程序，最终提升用户体验并降低维护成本。

设置 Debugger
3.1 配置 Debug 设置
在 IntelliJ IDEA 中开始 Debugging，您需要适当地配置 Debug 设置。请按照以下步骤操作：

打开配置设置：

导航到顶部工具栏，找到配置设置图标（通常类似于扳手或齿轮）。


编辑配置：

点击 Edit Configurations 以访问 run/debug 配置对话框。


设置主类：

确保选择了正确的主类，特别是如果您的程序包含多个 main 方法。


应用并保存：

配置完成后，点击 Apply 然后 OK 保存设置。



图 3.1：在 IntelliJ IDEA 中编辑配置设置

3.2 在 Debugger 中使用命令行参数
IntelliJ IDEA 允许您在 Debugging 期间向程序传递命令行参数。方法如下：

访问 Run/Debug 配置：

转到 Run > Edit Configurations。


添加参数：

在 Program Arguments 部分，输入所需的命令行参数。


应用并 Debug：

点击 Apply 然后 Debug 以使用指定的参数运行程序。



示例程序代码：使用命令行参数




		
		
			
			
Java
			
			public class DebugDemo {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("Command-Line Arguments:");
            for (String arg : args) {
                System.out.println(arg);
            }
        } else {
            System.out.println("No command-line arguments provided.");
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class DebugDemo {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("Command-Line Arguments:");
            for (String arg : args) {
                System.out.println(arg);
            }
        } else {
            System.out.println("No command-line arguments provided.");
        }
    }
}
					
				
			
		


说明：

程序检查是否提供了任何命令行参数。
如果存在参数，它将打印每个参数；否则，它会通知用户没有提供参数。

输出示例：




		
		
			
			
Java
			
			Command-Line Arguments:
Debugging
IntelliJ IDEA
Java
			
				
					
				
					1
2
3
4
				
						Command-Line Arguments:
Debugging
IntelliJ IDEA
Java
					
				
			
		



断点和观察点
4.1 设置断点
断点是在特定代码行上设置的标记，允许您在这些点暂停程序的执行。这使您能够检查应用程序的状态并了解其行为。
如何设置断点：

定位行：

在编辑器中打开 Java 文件。


点击边距：

点击行号旁边的左侧边距（gutter）以设置断点。一个红点将出现，表示已设置断点。



带有断点的示例代码：




		
		
			
			
Java
			
			public class BreakpointExample {
    public static void main(String[] args) {
        int x = 5; // 在这里设置断点
        int y = x + 10;
        System.out.println("Value of y: " + y);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class BreakpointExample {
    public static void main(String[] args) {
        int x = 5; // 在这里设置断点
        int y = x + 10;
        System.out.println("Value of y: " + y);
    }
}
					
				
			
		


说明：

在 int x = 5; 行设置了断点。当调试时，程序将在这一行暂停执行，允许您检查 x 的值在改变之前。

4.2 实施观察点
观察点允许您在程序执行过程中监控特定变量的值。每当值发生变化时，Debugger 会暂停执行，使您能够实时观察变化。
如何设置观察点：

识别变量：

选择您要监控的变量。


添加观察：

右键点击变量并选择 Add Watch，或使用 Watch 面板手动添加变量。



带有观察点的示例代码：




		
		
			
			
Java
			
			public class WatchpointExample {
    static int count = 0;

    public static void main(String[] args) {
        increment();
        System.out.println("Count: " + count);
    }

    public static void increment() {
        count += 1; // 在 'count' 上设置观察点
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class WatchpointExample {
    static int count = 0;
 
    public static void main(String[] args) {
        increment();
        System.out.println("Count: " + count);
    }
 
    public static void increment() {
        count += 1; // 在 'count' 上设置观察点
    }
}
					
				
			
		


说明：

在静态变量 count 上设置了观察点。每次 count 值变化时，Debugger 会暂停，使您能够跟踪其在程序执行过程中的值。

4.3 条件断点
条件断点使 Debugger 仅在满足特定条件时暂停执行。这在您希望在特定情况下检查程序状态时特别有用。
设置条件断点：

设置断点：

在所需行上放置断点。


添加条件：

右键点击断点并选择 Condition。


定义条件：

输入条件表达式，如 x == 10。



示例：




		
		
			
			
Java
			
			public class ConditionalBreakpointExample {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            System.out.println("x = " + x);
            // 设置条件断点，当 x == 10 时暂停
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class ConditionalBreakpointExample {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            System.out.println("x = " + x);
            // 设置条件断点，当 x == 10 时暂停
        }
    }
}
					
				
			
		


说明：

在循环内设置了一个断点，并加上条件 x == 10。当 x 达到 10 时，Debugger 将暂停执行，允许您检查特定迭代下程序的状态。

4.4 管理多个断点
在处理较大项目时，您可能需要高效地管理多个断点。IntelliJ IDEA 提供了工具来查看、启用/禁用和删除断点。
管理断点：

查看所有断点：

按 Ctrl + Shift + F8（Windows/Linux）或 Cmd + Shift + F8（Mac）打开断点对话框。


启用/禁用断点：

使用复选框启用或禁用特定断点，而不删除它们。


删除断点：

选择断点并点击 Remove 按钮以删除它。



最佳实践：

组织断点：将相关断点分组，便于管理。
使用描述性名称：为断点命名以反映其用途。
定期检查断点：移除过时的断点以保持清晰。


逐步执行代码
逐步执行代码允许您逐行执行程序，观察每一步的行为和应用程序状态。IntelliJ IDEA 提供了多种逐步执行选项来促进这一过程。
5.1 Step Over
Step Over 执行当前代码行并移动到同一方法中的下一行。如果当前行包含方法调用，Step Over 将执行整个方法而不进入方法内部。
使用场景：
当您希望执行方法调用而不深入其内部实现时。
示例：




		
		
			
			
Java
			
			public class StepOverExample {
    public static void main(String[] args) {
        int a = 5;
        int b = add(a, 10); // 在这里使用 Step Over
        System.out.println("Result: " + b);
    }

    public static int add(int x, int y) {
        return x + y;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class StepOverExample {
    public static void main(String[] args) {
        int a = 5;
        int b = add(a, 10); // 在这里使用 Step Over
        System.out.println("Result: " + b);
    }
 
    public static int add(int x, int y) {
        return x + y;
    }
}
					
				
			
		


说明：

在 int b = add(a, 10); 行设置断点并使用 Step Over 将执行 add 方法而不进入该方法内部，使您快速跳转到下一行。

5.2 Step Into
Step Into 进入被调用的方法，允许您调试该方法的内部代码。
使用场景：
当您需要检查方法内部的功能或定位方法实现中的问题时。
示例：




		
		
			
			
Java
			
			public class StepIntoExample {
    public static void main(String[] args) {
        int a = 5;
        int b = multiply(a, 10); // 在这里使用 Step Into
        System.out.println("Result: " + b);
    }

    public static int multiply(int x, int y) {
        return x * y;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class StepIntoExample {
    public static void main(String[] args) {
        int a = 5;
        int b = multiply(a, 10); // 在这里使用 Step Into
        System.out.println("Result: " + b);
    }
 
    public static int multiply(int x, int y) {
        return x * y;
    }
}
					
				
			
		


说明：

在 int b = multiply(a, 10); 行设置断点并使用 Step Into 将带您进入 multiply 方法内部，允许您调试其逻辑。

5.3 Step Out
Step Out 继续执行，直到当前方法返回， effectively stepping out of it.
使用场景：
当您完成调试一个方法，并希望返回调用者而不逐行执行方法剩余代码时。
示例：




		
		
			
			
Java
			
			public class StepOutExample {
    public static void main(String[] args) {
        int a = 5;
        int b = calculate(a, 10); // 从这里使用 Step Out
        System.out.println("Result: " + b);
    }

    public static int calculate(int x, int y) {
        int result = x + y;
        return result;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class StepOutExample {
    public static void main(String[] args) {
        int a = 5;
        int b = calculate(a, 10); // 从这里使用 Step Out
        System.out.println("Result: " + b);
    }
 
    public static int calculate(int x, int y) {
        int result = x + y;
        return result;
    }
}
					
				
			
		


说明：

在进入 calculate 方法并检查其逻辑后，使用 Step Out 将返回到 main 方法，允许您从那里继续调试。

5.4 Force Step Into
Force Step Into 比 Step Into 更深一步，允许您进入通常无法通过常规逐步执行访问的方法（例如库方法）。
使用场景：
当您需要调试通常对开发者不可见的方法内部实现时。
示例：




		
		
			
			
Java
			
			public class ForceStepIntoExample {
    public static void main(String[] args) {
        String text = "Hello, World!";
        int length = text.length(); // 在这里使用 Force Step Into
        System.out.println("Length: " + length);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class ForceStepIntoExample {
    public static void main(String[] args) {
        String text = "Hello, World!";
        int length = text.length(); // 在这里使用 Force Step Into
        System.out.println("Length: " + length);
    }
}
					
				
			
		


说明：

通过在 text.length() 上使用 Force Step Into，您可以进入 String 类的 length 方法，检查其执行，这是通常对开发者隐藏的。


高级调试功能
IntelliJ IDEA 提供了一套先进的调试功能，提升了调试体验，使其更高效和有洞察力。
6.1 检查变量
Variables 面板 提供了当前作用域中所有变量的详细视图，显示它们的名称、类型和当前值。
功能：

实时更新：在逐步执行代码时，变量实时更新。
可展开的对象：您可以展开对象以查看其内部字段和嵌套对象。

示例：




		
		
			
			
Java
			
			public class VariableInspectionExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.setAge(31);
        System.out.println(person);
    }
}

class Person {
    private String name;
    private int age;

    // 构造函数和 getters/setters 为简洁起见省略
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						public class VariableInspectionExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.setAge(31);
        System.out.println(person);
    }
}
 
class Person {
    private String name;
    private int age;
 
    // 构造函数和 getters/setters 为简洁起见省略
}
					
				
			
		


说明：

在调试时，Variables 面板将显示 person 对象及其 name 和 age 字段，允许您在每一步检查和验证其值。

6.2 动态修改变量值
IntelliJ IDEA 允许您在调试过程中修改变量的值，使您可以在不重新启动应用程序的情况下测试不同的场景。
如何修改变量：

暂停执行：

设置断点并开始 Debugging。


选择变量：

在 Variables 面板中，右键点击您想要修改的变量。


设置值：

选择 Set Value 并输入新的期望值。



示例：




		
		
			
			
Java
			
			public class ModifyVariableExample {
    public static void main(String[] args) {
        int counter = 10;
        counter += 5; // 在这里将 'counter' 修改为 20
        System.out.println("Counter: " + counter);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class ModifyVariableExample {
    public static void main(String[] args) {
        int counter = 10;
        counter += 5; // 在这里将 'counter' 修改为 20
        System.out.println("Counter: " + counter);
    }
}
					
				
			
		


说明：

在调试过程中，您可以在 println 语句之前将 counter 的值从 15 修改为 20，观察程序在不同变量值下的行为。

6.3 利用 Variables 面板
Variables 面板提供了多种功能以增强变量检查：

监视表达式：添加表达式以监视特定变量或计算。
过滤：过滤变量以专注于当前调试需求相关的变量。
分组：按作用域或类型分组变量以便于组织。

提示：

添加监视：定期监控对应用逻辑关键的变量。
使用评估：直接在 Variables 面板中评估复杂表达式以理解其结果。

6.4 处理多线程应用程序
调试多线程应用程序可能具有挑战性，因为线程的并发执行。IntelliJ IDEA 提供了工具以有效地管理和检查多个线程。
功能：

线程概览：在 Threads 面板中查看所有活动线程。
切换线程：轻松切换线程以检查它们的状态和变量。
挂起线程：挂起和恢复线程以控制执行流程。

示例：




		
		
			
			
Java
			
			public class MultithreadedDebugExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task(), "Thread-1");
        Thread thread2 = new Thread(new Task(), "Thread-2");
        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    @Override
    public void run() {
        int x = 0;
        while (x < 5) {
            System.out.println(Thread.currentThread().getName() + " - x: " + x);
            x++;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						public class MultithreadedDebugExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task(), "Thread-1");
        Thread thread2 = new Thread(new Task(), "Thread-2");
        thread1.start();
        thread2.start();
    }
}
 
class Task implements Runnable {
    @Override
    public void run() {
        int x = 0;
        while (x < 5) {
            System.out.println(Thread.currentThread().getName() + " - x: " + x);
            x++;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
					
				
			
		


说明：

在调试时，您可以单独检查每个线程的执行，监控它们的 x 变量，并了解它们在应用程序中的交互方式。


有效调试的最佳实践
遵循最佳实践可以使您的 Debugging 过程更高效，错误更少。以下是一些关键策略，以提升您的 Debugging 技能。
7.1 组织断点
合理地组织断点可确保您在调试会话中能够快速导航和管理它们。
策略：

分类断点：根据模块、功能或特性分组断点。
命名断点：为断点命名以反映其用途。
使用条件断点：通过为断点添加条件减少不必要的暂停。

7.2 有效使用日志
日志记录是 Debugging 的补充工具，提供了无需手动检查即可了解应用程序行为的洞察。
提示：

策略性日志记录：在关键代码点放置日志语句以跟踪执行流程和变量状态。
不同的日志级别：使用不同的日志级别（INFO、DEBUG、ERROR）控制日志的详细程度。
分析日志输出：定期查看日志输出以识别模式和潜在问题。

示例：




		
		
			
			
Java
			
			import java.util.logging.Logger;

public class LoggingExample {
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());

    public static void main(String[] args) {
        logger.info("Application started.");
        int result = compute(5, 10);
        logger.info("Computation result: " + result);
    }

    public static int compute(int a, int b) {
        logger.debug("Computing the sum of " + a + " and " + b);
        return a + b;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						import java.util.logging.Logger;
 
public class LoggingExample {
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());
 
    public static void main(String[] args) {
        logger.info("Application started.");
        int result = compute(5, 10);
        logger.info("Computation result: " + result);
    }
 
    public static int compute(int a, int b) {
        logger.debug("Computing the sum of " + a + " and " + b);
        return a + b;
    }
}
					
				
			
		


说明：

日志提供了应用程序事件的时间顺序记录，有助于追踪和诊断问题。

7.3 优化 Debugger 性能
有效地使用 Debugger 可以节省时间和资源，尤其是在处理大型项目时。
策略：

限制断点数量：避免过多断点以防止 Debugger 过载。
使用 Evaluate Expression：而不是逐行执行，使用 Evaluate Expression 功能快速检查复杂表达式。
选择性挂起线程：专注于相关线程以减少混乱并提高性能。


结论
Debugging 是 Java 开发中不可或缺的一部分，确保应用程序运行顺畅和高效。IntelliJ IDEA 强大的调试工具，包括断点、观察点和高级逐步执行功能，使开发者能够精准地识别和解决问题。通过掌握这些工具并遵循最佳实践，您可以显著提升编码工作流程，减少开发时间，并生产出高质量的软件。
关键要点：

断点和观察点：用于暂停执行和监控变量变化的基本工具。
逐步执行代码：了解执行流程和定位问题的关键。
高级功能：利用变量检查、动态修改和多线程支持来简化 Debugging。
最佳实践：组织断点，有效使用日志，优化 Debugger 性能，以提高 Debugging 会话的效率。

采用这些 Debugging 策略，提升您的 Java 开发技能，构建健壮、无错误的应用程序。
SEO 关键词：Java 调试, IntelliJ IDEA 调试器, 断点, 观察点, Step Over, Step Into, Step Out, 条件断点, 多线程调试, Debugging 最佳实践, Java 开发工具, 代码检查, 变量监控, Debugging 技术, IntelliJ IDEA 提示, Java IDE 调试, 高效 Debugging, Debugging 工具, Java 代码故障排除

补充信息
9.1 比较表：观察点 vs. 断点


功能
断点
观察点


目的
在特定代码行暂停执行
监控并在变量值变化时暂停执行


使用
检查程序在特定点的状态
跟踪变量的修改


设置复杂性
通过点击边距简单设置
需要识别要监控的变量


执行影响
无论条件如何都会暂停执行
仅在监视变量满足条件时暂停


常见使用场景
调试控制流，检查变量状态
监控关键变量，调试状态变化


9.2 示例程序代码
程序：调试演示




		
		
			
			
Java
			
			public class DebuggerDemo {
    static int x = 50;

    public static void main(String[] args) {
        System.out.println("Starting Debugger Demo");
        displayValue();
        modifyValue();
        System.out.println("Final Value of x: " + x);
    }

    public static void displayValue() {
        System.out.println("Value of x: " + x);
    }

    public static void modifyValue() {
        x = 10; // 在 'x' 上设置观察点
        System.out.println("Value of x modified to: " + x);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						public class DebuggerDemo {
    static int x = 50;
 
    public static void main(String[] args) {
        System.out.println("Starting Debugger Demo");
        displayValue();
        modifyValue();
        System.out.println("Final Value of x: " + x);
    }
 
    public static void displayValue() {
        System.out.println("Value of x: " + x);
    }
 
    public static void modifyValue() {
        x = 10; // 在 'x' 上设置观察点
        System.out.println("Value of x modified to: " + x);
    }
}
					
				
			
		


说明：

断点：设置在 main 方法的行上以观察流程。
观察点：设置在静态变量 x 上以监控其在执行过程中的变化。

Debugger 交互：

初始运行：观察启动消息和 x 的初始值。
在 modifyValue() 上的断点：进入方法以查看 x 从 50 变为 10。
在 x 上的观察点：当 x 被修改时自动暂停，允许在变化前后进行检查。
最终输出：验证修改后的 x 的最终值。

输出：




		
		
			
			
Java
			
			Starting Debugger Demo
Value of x: 50
Value of x modified to: 10
Final Value of x: 10
			
				
					
				
					1
2
3
4
				
						Starting Debugger Demo
Value of x: 50
Value of x modified to: 10
Final Value of x: 10
					
				
			
		


9.3 其他资源
为了进一步提升您在 IntelliJ IDEA 和 Java 开发中的 Debugging 技能，可以考虑探索以下资源：

IntelliJ IDEA 文档： 官方指南
Oracle 的 Java 教程： Java Debugging 技术
《Effective Java》作者 Joshua Bloch： Java 最佳实践的全面指南。
在线课程：

Udemy： 使用 IntelliJ IDEA 掌握 Java Debugging
Coursera： Java 编程与 Debugging


社区论坛：

Stack Overflow： 与开发者社区互动，解决具体的 Debugging 问题。
JetBrains 社区： 参与讨论并寻求有关 IntelliJ IDEA 的支持。



参与这些资源将提供更深入的见解和实践知识，补充本电子书中涵盖的概念。
Output：

注意：本文由 AI 生成。
主题	使用时机	应用地点
断点	在特定代码行暂停执行以检查代码	任何关键的代码部分
观察点	监控特定变量的变化	影响关键结果的变量
条件断点	基于特定条件暂停执行	需要上下文特定检查的场景
功能	断点	观察点
目的	在特定代码行暂停执行	监控并在变量值变化时暂停执行
使用	检查程序在特定点的状态	跟踪变量的修改
设置复杂性	通过点击边距简单设置	需要识别要监控的变量
执行影响	无论条件如何都会暂停执行	仅在监视变量满足条件时暂停
常见使用场景	调试控制流，检查变量状态	监控关键变量，调试状态变化