IntelliJ IDEA快捷键及调试

文章目录

一、IntelliJ IDEA 常用快捷键一览表
- 1-IDEA的日常快捷键
- - 第1组：通用型
  - 第2组：提高编写速度（上）
  - 第3组：提高编写速度（下）
  - 第4组：类结构、查找和查看源码
  - 第5组：查找、替换与关闭
  - 第6组：调整格式
- 2-Debug快捷键
二、查看快捷键
- 1-已知快捷键操作名，未知快捷键
- 2-已知快捷键，不知道对应的操作名
- 3-自定义快捷键
- 4-使用其它平台快捷键
三、IDEA断点调试(Debug)
- 1-为什么需要Debug
- 2-Debug的步骤
- - 1、添加断点
  - 2、启动调试
  - 3、单步调试工具介绍
- 3-多种Debug情况介绍
- - 1、行断点
  - 2、方法断点
  - 3、字段断点
  - 4、条件断点
  - 5、异常断点（暂略）
  - 6、线程调试（暂略）
  - 7、强制结束
- 4-自定义调试数据视图（暂略）
- 5-常见问题
四、IDEA常用插件
- 推荐1：Alibaba Java Coding Guidelines
- 推荐2：jclasslib bytecode viewer
- 推荐3：Translation
- 推荐4：GenerateAllSetter
- 推荐5：Rainbow Brackets
- 推荐6：CodeGlance Pro
- 推荐7：Statistic
- 推荐8：Presentation Assistant
- 推荐9：Key Promoter X
- 推荐10：JavaDoc
- 推荐11： LeetCode Editor
- 推荐12：GsonFormatPlus
- 插件13：Material Theme UI

一、IntelliJ IDEA 常用快捷键一览表

1-IDEA的日常快捷键

第1组：通用型

说明	快捷键
复制代码-copy	ctrl + c
粘贴-paste	ctrl + v
剪切-cut	ctrl + x
撤销-undo	ctrl + z
反撤销-redo	ctrl + shift + z
保存-save all	ctrl + s
全选-select all	ctrl + a

第2组：提高编写速度（上）

说明	快捷键
智能提示-edit	alt + enter
提示代码模板-insert live template	ctrl+j
使用xx块环绕-surround with …	ctrl+alt+t
调出生成getter/setter/构造器等结构-generate …	alt+insert
自动生成返回值变量-introduce variable …	ctrl+alt+v
复制指定行的代码-duplicate line or selection	ctrl+d
删除指定行的代码-delete line	ctrl+y
切换到下一行代码空位-start new line	shift + enter
切换到上一行代码空位-start new line before current	ctrl +alt+ enter
向上移动代码-move statement up	ctrl+shift+↑
向下移动代码-move statement down	ctrl+shift+↓
向上移动一行-move line up	alt+shift+↑
向下移动一行-move line down	alt+shift+↓
方法的形参列表提醒-parameter info	ctrl+p

第3组：提高编写速度（下）

说明	快捷键
批量修改指定的变量名、方法名、类名等-rename	shift+f6
抽取代码重构方法-extract method …	ctrl+alt+m
重写父类的方法-override methods …	ctrl+o
实现接口的方法-implements methods …	ctrl+i
选中的结构的大小写的切换-toggle case	ctrl+shift+u
批量导包-optimize imports	ctrl+alt+o

第4组：类结构、查找和查看源码

说明	快捷键
如何查看源码-go to class…	ctrl + 选中指定的结构或 ctrl+n
显示当前类结构，支持搜索指定的方法、属性等-file structure	ctrl+f12
退回到前一个编辑的页面-back	ctrl+alt+←
进入到下一个编辑的页面-forward	ctrl+alt+→
打开的类文件之间切换-select previous/next tab	alt+←/→
光标选中指定的类，查看继承树结构-Type Hierarchy	ctrl+h
查看方法文档-quick documentation	ctrl+q
类的UML关系图-show uml popup	ctrl+alt+u
定位某行-go to line/column	ctrl+g
回溯变量或方法的来源-go to implementation(s)	ctrl+alt+b
折叠方法实现-collapse all	ctrl+shift+ -
展开方法实现-expand all	ctrl+shift+ +

第5组：查找、替换与关闭

说明	快捷键
查找指定的结构	ctlr+f
快速查找：选中的Word快速定位到下一个-find next	ctrl+l
查找与替换-replace	ctrl+r
直接定位到当前行的首位-move caret to line start	home
直接定位到当前行的末位 -move caret to line end	end
查询当前元素在当前文件中的引用，然后按 F3 可以选择	ctrl+f7
全项目搜索文本-find in path …	ctrl+shift+f
关闭当前窗口-close	ctrl+f4

第6组：调整格式

说明	快捷键
格式化代码-reformat code	ctrl+alt+l
使用单行注释-comment with line comment	ctrl + /
使用/取消多行注释-comment with block comment	ctrl + shift + /
选中数行，整体往后移动-tab	tab
选中数行，整体往前移动-prev tab	shift + tab

2-Debug快捷键

说明	快捷键
单步调试（不进入函数内部）- step over	F8
单步调试（进入函数内部）- step into	F7
强制单步调试（进入函数内部） - force step into	alt+shift+f7
选择要进入的函数 - smart step into	shift + F7
跳出函数 - step out	shift + F8
运行到断点 - run to cursor	alt + F9
继续执行，进入下一个断点或执行完程序 - resume program	F9
停止 - stop	Ctrl+F2
查看断点 - view breakpoints	Ctrl+Shift+F8
关闭 - close	Ctrl+F4

二、查看快捷键

1-已知快捷键操作名，未知快捷键

2-已知快捷键，不知道对应的操作名

3-自定义快捷键

4-使用其它平台快捷键

苹果电脑或者是用惯Eclipse快捷的，可以选择其他快捷键插件。

三、IDEA断点调试(Debug)

1-为什么需要Debug

编好的程序在执行过程中如果出现错误，该如何查找或定位错误呢？简单的代码直接就可以看出来，但如果代码比较复杂，就需要借助程序调试工具（Debug）来查找错误了。

运行编写好的程序时，可能出现的几种情况：
> 情况1：没有任何bug,程序执行正确！

====================如果出现如下的三种情况，都又必要使用debug=============================
> 情况2：运行以后，出现了错误或异常信息。但是通过日志文件或控制台，显示了异常信息的位置。
> 情况3：运行以后，得到了结果，但是结果不是我们想要的。
> 情况4：运行以后，得到了结果，结果大概率是我们想要的。但是多次运行的话，可能会出现不是我们想要的情况。
        比如：多线程情况下，处理线程安全问题。

2-Debug的步骤

Debug(调试)程序步骤如下：

1、添加断点

2、启动调试

3、单步执行

4、观察变量和执行流程，找到并解决问题

1、添加断点

在源代码文件中，在想要设置断点的代码行的前面的标记行处，单击鼠标左键就可以设置断点，在相同位置再次单击即可取消断点。

2、启动调试

IDEA提供多种方式来启动程序(Launch)的调试，分别是通过菜单(Run –> Debug)、图标(“绿色臭虫”）等等。

3、单步调试工具介绍

或

【解释】

：Step Over（F8）：进入下一步，如果当前行断点是调用一个方法，则不进入当前方法体内。

：Step Into（F7）：进入下一步，如果当前行断点是调用一个自定义方法，则进入该方法体内。

：Force Step Into（Alt +Shift + F7）：进入下一步，如果当前行断点是调用一个核心类库方法，则进入该方法体内。（强制进入）

：Step Out（Shift + F8）：跳出当前方法体。

：Run to Cursor（Alt + F9)：直接跳到光标处继续调试。

：Resume Program（F9）：恢复程序运行，但如果该断点下面代码还有断点则停在下一个断点上。（跳到下一个断点）

：Stop（Ctrl + F2）：结束调试。

：View Breakpoints（Ctrl + Shift + F8）：查看所有断点。

：Mute Breakpoints：使得当前代码后面所有的断点失效，一下执行到底。

：重新运行。

：显示执行点，若在此行代码中，进入了其中一个函数查看，想要再返回刚才调试的这一行代码，可以点这个按钮。

说明：在Debug过程中，可以动态的下断点。

3-多种Debug情况介绍

1、行断点

断点打在代码所在的行上。执行到此行时，会停下来。

【案例1】

package com.atguigu.debug;

/**
 * ClassName: Debug01
 * Package: com.atguigu.debug
 * Description: 演示1：行断点  &  测试debug各个常见操作按钮
 */
public class Debug01 {
    public static void main(String[] args) {
        //1.
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ",n = " + n);
        swap(m, n);
        System.out.println("m = " + m + ",n = " + n);

        //2.
        // int[] arr = new int[] {1,2,3,4,5};
        // System.out.println(arr);//地址值

        // char[] arr1 = new char[] {'a','b','c'};
        // System.out.println(arr1);//abc
    }

    public static void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
    }

}

此时得到的不是想要的结果：

此时就可以通过调试来发现问题。

打断点在哪里打呢？一般在你怀疑出错的代码的前面一行打上断点。

比如现在怀疑swap()方法有问题，就可以将断点打到上面一行，如下：

断点是红色的，用鼠标左键在左边点一下即可。

接下来调试一下，点击“Debug”：

然后代码就会执行到首次添加断点的位置，此时这一行代码还没有执行。如下：

然后执行下一步：

此时想进入swap()方法内部，点击第二个按钮（因为这里的swap方法是自己写的，若是系统函数比如print函数，就需要第三个按钮强制进入）：

然后一步一步执行：

此时swap()执行完毕，可以跳出来，不用继续执行后续代码：

【案例2】

package com.atguigu.debug;

/**
 * ClassName: Debug01
 * Package: com.atguigu.debug
 * Description: 演示1：行断点  &  测试debug各个常见操作按钮
 */
public class Debug01 {
    public static void main(String[] args) {
        //1.
        // int m = 10;
        // int n = 20;
        // System.out.println("m = " + m + ",n = " + n);
        // swap(m, n);
        // System.out.println("m = " + m + ",n = " + n);

        //2.
        int[] arr = new int[] {1,2,3,4,5};
        System.out.println(arr);//地址值

        char[] arr1 = new char[] {'a','b','c'};
        System.out.println(arr1);//abc
    }

    public static void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
    }

}

打断点进行调试：

强制进入print函数：

再次强制进入valueOf：

可以看到，直接调用toString：

这里可以跳出方法：

对于第二个也可以使用同样的方法进入调试：

2、方法断点

断点设置在方法的签名上，默认当进入时，断点可以被唤醒。
也可以设置在方法退出时，断点也被唤醒

在多态的场景下，在父类或接口的方法上打断点，会自动调入到子类或实现类的方法

【案例1】

package yuyi03.Debug;

/**
 * ClassName: Debug02
 * Package: com.atguigu.debug
 * Description: 演示2： 方法断点
 * @Version 1.0
 */
public class Debug02 {
    public static void main(String[] args) {

        //1.
        Son instance = new Son();
        instance.test();
        
//        //2.类的多态性
//        Father instance1 = new Son();
//        instance1.test();
//
//        //3.接口的多态性
//        Consumer con = new ConsumerImpl();
//        con.accept("atguigu");

        //4.
//        HashMap map = new HashMap();
//        map.put("Tom",12);
//        map.put("Jerry",11);
//        map.put("Tony",20);
        
    }
}

class Father{
    public void test(){
        System.out.println("Father : test1");
        System.out.println("Father : test2");
    }
}

class Son extends Father{
    @Override
    public void test(){
        System.out.println("Son : test1");
        System.out.println("Son : test2");
    }
}

interface Consumer{
    void accept(String str);
}

class ConsumerImpl implements Consumer{

    @Override
    public void accept(String str) {
        System.out.println("ConsumerImple:" + str);
    }
}

方法断点，比如在这个方法左边打上断点，可以看到是一个菱形：

右键点击菱形，可以看到它指明了在进入方法的时候，会停留一下。

然后开始调试：

可以看到它直接停留在方法这里了：

这是因为上面调用这个方法了：

一调用这个方法，它就停留在这里了。

给方法声明这里加断点，就是看这个方法什么时候调用，调用的时候就重点看方法的执行。

【案例2】

package yuyi03.Debug;

/**
 * ClassName: Debug02
 * Package: com.atguigu.debug
 * Description: 演示2： 方法断点
 * @Version 1.0
 */
public class Debug02 {
    public static void main(String[] args) {

        //1.
        // Son instance = new Son();
        // instance.test();
        
        //2.类的多态性
       Father instance1 = new Son();
       instance1.test();

        //3.接口的多态性
       Consumer con = new ConsumerImpl();
       con.accept("atguigu");

        //4.
//        HashMap map = new HashMap();
//        map.put("Tom",12);
//        map.put("Jerry",11);
//        map.put("Tony",20);
        
    }
}

class Father{
    public void test(){
        System.out.println("Father : test1");
        System.out.println("Father : test2");
    }
}

class Son extends Father{
    @Override
    public void test(){
        System.out.println("Son : test1");
        System.out.println("Son : test2");
    }
}

interface Consumer{
    void accept(String str);
}

class ConsumerImpl implements Consumer{

    @Override
    public void accept(String str) {
        System.out.println("ConsumerImple:" + str);
    }
}

在方法声明处打上断点：

编写的时候，会认为调用的是父类/接口中的方法，实际执行的时候是子类/实现类中的方法：

那么此时调试会做停留吗？

可以发现其实停留了，而且停留在了子类Son这里，如下：

刚才说了，实际运行的时候，执行的是子类重写父类的方法。

所以这里是真正运行了。

为什么在父类那里打的断点，跳到了子类这里？这是因为子类将父类的方法给覆盖了。

接下来看一下“下一个可能有断点的位置”：

可以看到跳到了Consumer实现类的地方：

通过Debug可以看到真正执行的是哪一个类的方法

现在可以查看一下当前代码中都有哪些位置有断点：

3、字段断点

在类的属性声明上打断点，默认对属性的修改操作进行监控

【案例1】

package com.atguigu.debug;

/**
 * ClassName: Debug03
 * Package: com.atguigu.debug
 * Description: 演示3：字段断点
 * @Version 1.0
 */
public class Debug03 {
    public static void main(String[] args) {
        Person p1 = new Person(3);
        System.out.println(p1.toString());
    }
}

class Person{
    private int id = 1;	//显示赋值
    private String name;
    private int age;

    public Person() {
    }
    {
        id = 2;	//代码块赋值
    }
    public Person(int id) {
        this.id = id;	//构造器赋值
    }



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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在属性前面加断点是一个小眼睛，比如：

右键可以看到，在修改当前属性的时候，会停留一下（相当于就是看一下哪些位置修改了）：

现在我们调试一下，凡是修改了属性的位置都会停下来。

可以看到这里显式赋值算修改了，因为默认值是0。

此时p1对象还没有创建，调用构造器之前先是显示赋值了，所以this里面的id是0，如下：

点击这里，找到下一个断点位置代码块：

此时this里面的id变为了1，说明显示赋值已经执行了。

再下一个位置就是构造器了，如下：

一共就这三个位置修改了id，再次寻找断点位置就会结束。

🎲拓展

若此时让它在访问的时候也停留一下。

右键点击小眼睛，将“字段访问”勾上：

那么在toString的时候也会停留一下：

4、条件断点

有的时候会想，在条件满足的情况下停留一下。

package com.atguigu.debug;

/**
 * ClassName: Debug04
 * Package: com.atguigu.debug
 * Description: 演示4：条件断点
 * @Version 1.0
 */
public class Debug04 {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10,11,12};

        for (int i = 0; i < arr.length; i++) {
            int target = arr[i];
            System.out.println(target);
        }
    }
}

针对上述代码，比如现在想在满足arr[i] % 3 == 0的条件下，执行断点。（若被3除不尽，就直接往后执行即可）

可以在这里加一个断点，然后右键：（在Condition里面添加条件）

若arr[i]除3可以除尽就停留一下。

现在做一个调试：

可以看见控制台已经输出了1和2，在3的位置停留了：

接下来看一下下一个断点的位置，可以发现在6的时候停留了：

以后需要在某个条件的情况下分析就可以使用条件断点，不需要让程序一步一步走

5、异常断点（暂略）

对异常进行跟踪。如果程序出现指定异常，程序就会执行断点，自动停住。

package com.atguigu.debug;

import java.util.Date;

/**
 * ClassName: Debug05
 * Package: com.atguigu.debug
 * Description: 演示5：异常断点
 * @Version 1.0
 */
public class Debug05 {
    public static void main(String[] args) {

        int m = 10;
        int n = 0;
        int result = m / n;
        System.out.println(result);


//        Person p1 = new Person(1001);
//        System.out.println(p1.getName().toUpperCase());


    }
}

通过下图的方式，对指定的异常进行监控：

6、线程调试（暂略）

package com.atguigu.debug;

/**
 * ClassName: Debug06
 * Package: com.atguigu.debug
 * Description: 演示6：线程调试
 * @Version 1.0
 */
public class Debug06 {

    public static void main(String[] args) {

        test("Thread1");
        test("Thread2");


    }

    public static void test(String threadName) {
        new Thread(
                () -> System.out.println(Thread.currentThread().getName()),
                threadName
        ).start();
    }

}

7、强制结束

package com.atguigu.debug;

/**
 * ClassName: Debug07
 * Package: com.atguigu.debug
 * Description: 演示7：强制结束
 * @Version 1.0
 */
public class Debug07 {
    public static void main(String[] args) {
        System.out.println("获取请求的数据");
        System.out.println("调用写入数据库的方法");
        insert();
        System.out.println("程序结束");
    }

    private static void insert() {
        System.out.println("进入insert()方法");
        System.out.println("获取数据库连接");
        System.out.println("将数据写入数据表中");
        System.out.println("写出操作完成");
        System.out.println("断开连接");
    }
}

比如在insert()的位置加了一个断点，然后调试：

然后进入insert()方法：

假设走到第二行已经知道是什么问题了，不想再往后执行了。

若此时强制停止，可以发现后面的代码也执行了：

那怎么办呢？

选中当前方法，右键“Force Return”：

然后可以看到，中间很多就没有做了：

4-自定义调试数据视图（暂略）

package com.atguigu.debug;

import java.util.HashMap;

/**
 * ClassName: Debug08
 * Package: com.atguigu.debug
 * Description: 演示8：用户自定义数据视图
 * @Version 1.0
 */
public class Debug08 {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>();
        map.put(1,"高铁");
        map.put(2,"网购");
        map.put(3,"支付宝");
        map.put(4,"共享单车");

        System.out.println(map);
    }
}

设置如下：

5-常见问题

问题：使用Step Into时，会出现无法进入源码的情况。如何解决？

方案1：使用 force step into 即可

方案2：点击Setting -> Build,Execution,Deployment -> Debugger -> Stepping

把Do not step into the classess中的java.*、javax.* 取消勾选即可。

小结：

经验：初学者对于在哪里加断点，缺乏经验，这也是调试程序最麻烦的地方，需要一定的经验。

简单来说，在可能发生错误的代码的前面加断点。如果不会判断，就在程序执行的起点处加断点。

四、IDEA常用插件

推荐1：Alibaba Java Coding Guidelines

阿里巴巴Java编码规范检查插件，检测代码是否存在问题，以及是否符合规范。

使用：在类中，右键，选择编码规约扫描，在下方显示扫描规约和提示。根据提示规范代码，提高代码质量。

推荐2：jclasslib bytecode viewer

可视化的字节码查看器。

使用：

在 IDEA 打开想研究的类。
编译该类或者直接编译整个项目（如果想研究的类在 jar 包中，此步可略过）。
打开“view” 菜单，选择“Show Bytecode With jclasslib” 选项。
选择上述菜单项后 IDEA 中会弹出 jclasslib 工具窗口。

英文设置：

在 Help -> Edit Custom VM Options …，加上

-Duser.language=en

推荐3：Translation

注册翻译服务（有道智云、百度翻译开放平台、阿里云机器翻译）帐号，开通翻译服务并获取其应用ID和密钥

绑定应用ID和密钥：偏好设置（设置） > 工具 > 翻译 > 常规 > 翻译引擎 > 配置…

使用：鼠标选中文本，点击右键即可自动翻译成多国语言。

注：请注意保管好你的应用密钥，防止其泄露。

推荐4：GenerateAllSetter

实际开发中还有一个非常常见的场景：我们创建一个对象后，想依次调用 Setter 函数对属性赋值，如果属性较多很容易遗漏或者重复。

可以使用这 GenerateAllSetter 提供的功能，快速生成对象的所有 Setter 函数（可填充默认值），然后自己再跟进实际需求设置属性值。

推荐5：Rainbow Brackets

给括号添加彩虹色，使开发者通过颜色区分括号嵌套层级，便于阅读。

推荐6：CodeGlance Pro

在编辑器右侧生成代码小地图，可以拖拽小地图光标快速定位代码，阅读行数很多的代码文件时非常实用。

推荐7：Statistic

代码统计工具。

推荐8：Presentation Assistant

显示快捷键操作的按键。

推荐9：Key Promoter X

快捷键提示插件。当你执行鼠标操作时，如果该操作可被快捷键代替，会给出提示，帮助你自然形成使用快捷键的习惯，告别死记硬背。

推荐10：JavaDoc

按alt+insert，执行操作：

推荐11： LeetCode Editor

在 IDEA 里刷力扣算法题

推荐12：GsonFormatPlus

根据 json 生成对象。

使用：使用alt + s 或 alt + insert调取。

举例：

{
    "name": "tom",
    "age": "18",
    "gender": "man",
    "hometown": {
        "province": "河北省",
        "city": "石家庄市",
        "county": "正定县"
    }
}