Idea断点调试（debug）详解

1.打断点，并启动

打断点：

鼠标左键点击这里就会出现一个红点标志 （有各种形状，后续解释），就打上了一个断点。

启动：

• 对于已经运行过的程序，直接点击，小虫子就能启动
  

• 对于没有运行过的程序，找到程序入口（main方法）前面的三角形 ，鼠标右键启动

启动后，当我们的程序执行到断点程序处，就会出现调试界面，如下：

如果没有出现调试界面，那就是说明：根本没有执行断点处的程序。

2.按钮介绍

1.测试程序

先写一个简单的类来做测试，如下：

public class TestDemo {

    public static int add(int a, String b) {
        int c = Integer.parseInt(b);
        return a + c;
    }

    public static char sub(int d, int e) {
        char res = (char) Math.abs(d - e);
        return res;
    }

    public static void main(String[] args) {
        String b = "45";
        int a = 13;
        int sum = add(a, b);
        int d = 17;
        int e = 89;
        char f = sub(17, 89);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

接着，找个地方打上断点（确保程序会执行的地方）打上断点：

然后开始debug。

2.Step Over

步过：

作用：

• 一行代码一行代码地往下执行
• 不会进入到路经的方法里面

3.Step Into

步入：

作用：

• 进入我们自定义的方法
• 不会进入其他类库的方法

4.Force Step Into

强制步入：

作用:

• 可以进入更深层次的方法
• 自定义类库或者其他类库的方法都能进入

5.Step Out

步出：

作用：

• 从对应的方法中出来，返回上一层

6.Drop Frame

回退断点：

作用：

• 当进入到更深层的方法后才能使用
• 当我们错过了debug的位置时使用
• 这个按钮可以让焦点回到调用方法之前，然后再次debug一次方法（给你犯错重来的机会）
• 对于数据库增删改操作无法回退

注意： 此回退仅限于，那个方法还没有调用完，否则是无法回去的再次debug那个方法的，只能重新启动debug。

7.Run to Cursor

跳到光标处

作用：

• 将debug执行位置跳转到光标位置，然后继续debug
• 只能往后面跳，如果光标在debug执行位置前面，就会终止debug

8.Evaluate Expression

表达式计算：

作用：

• 获取已经debug过的参数的值
  
• 计算已经debug过的参数的值（表达式、方法）
  

9.Resume Program

恢复程序：

作用：

• 当有多个断点时使用
• 直接跳转到下一个断点的位置
  

10.Stop

停止程序：

作用：

• 停止debug
• 会继续跑完程序

11.View BreakPoints

查看断点：

作用：

• 查看所有断点，并进行相关设置
  

12.Mute BreakPoints

禁用断点：

作用：

• 暂时禁用掉所有断点，放行程序

3.断点分类

1.方法断点

给方法打上断点之后，当我们的debug到调用该方法的位置的时候，会直接跳转到方法处（直接Step Out就会跳转）。

2.属性断点

断点右键可以进行设置：

3.异常断点

添加异常断点流程：

作用：

• 在全局打上异常（上述添加的是堆栈溢出异常）
• 只要哪里出现了堆栈溢出异常，程序就会跳转到那个地方，方便快速找到异常位置
• 可在run程序抛出异常后，根据异常去打断点，然后进行调试

4.条件断点

右键断点，设置条件，只有当满足条件时，才会进入该断点程序停留，否则就直接往下面执行程序。

5.流断点

调试流程：

• 代码：

      public static void main(String[] args) {
          Stream.of(10, 30, 50, 90, 40)
                  .mapToLong(e -> e*e )
                  .filter(e -> e > 2500)
                  .forEach(System.out::println);
      }
  1
  2
  3
  4
  5
  6

• 断点调试：
  
  

作用：

• 可以查看流的工作流程

6.多线程断点

调试流程：

• 代码：

      public static void main(String[] args) {
          new Thread(() -> {
              System.out.println();
              System.out.println("thread1 is running");
              StringBuilder sb = new StringBuilder(".");
              for (int i = 0; i < 10; i++) {
                  try {
                      Thread.sleep(100);
                      System.out.print(sb.append(".").toString());
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }, "thread1").start();
  
          new Thread(() -> {
              System.out.println();
              System.out.println("thread22 is running");
              StringBuilder sb = new StringBuilder(".");
              for (int i = 0; i < 10; i++) {
                  try {
                      Thread.sleep(100);
                      System.out.print(sb.append(".").toString());
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }, "thread22").start();
  
          new Thread(() -> {
              System.out.println();
              System.out.println("thread333 is running");
              StringBuilder sb = new StringBuilder(".");
              for (int i = 0; i < 10; i++) {
                  try {
                      Thread.sleep(100);
                      System.out.print(sb.append(".").toString());
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }, "thread333").start();
      }
  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
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43

• 断点：
  

• 查看输出：
  

作用：

• 将 suspend 设置为 Thread
• 这样就可以单个线程单个线程地调试，而不会出现，线程之间争抢资源的情况（线程不断切换）