# 代码样式。 Java

> For the complete documentation index, see [llms.txt](https://www.jetbrains.com.cn/help/idea/llms.txt).

> **TL;DR**
> `文件 | 设置 | 编辑器 | 代码样式 | Java`  适用于 Windows 和 Linux
>
>
>
> `%instance% | 设置 | 编辑器 | 代码样式 | Java`  适用于 macOS
>
>
>
> `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)) !["设置"图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.settings.svg)

使用此页面配置 Java 文件的格式选项。 当您更改这些设置时，   预览   面板将显示这将如何影响您的代码。

## 制表符和缩进

|  条目  |  描述  |
| --- | --- |
|    使用制表符    |     使用 `Tab` (Windows), `⇥` (macOS), `⇥` (IntelliJ IDEA Classic (macOS)), `⇥` (macOS System Shortcuts), `Tab` (XWin), `Tab` (GNOME), `Tab` (KDE), `Tab` (Emacs), `Tab` (Sublime Text), `⇥` (Sublime Text (macOS)), `Tab` (Visual Studio), `⇥` (Visual Studio (macOS)), `Tab` (NetBeans), `Tab` (Eclipse), `⇥` (Eclipse (macOS)) 密钥进行缩进。 当复选框未勾选时， IntelliJ IDEA 使用空格而非制表符。     |
|    智能制表符    |      * 如果选中此复选框，嵌套代码块的缩进将根据需要使用制表符和 Space，而对齐缩进将仅使用 Space。    * 如果此复选框未选中，将只使用选项卡。 这意味着一组符合指定制表符大小的空格将自动替换为一个制表符，这可能会导致精细对齐的破坏。        智能制表符   复选框在启用   使用制表符   选项时可用。     |
|    选项卡大小    |  在此字段中，指定一个制表符包含的 Space 数。  |
|    缩进    |  在此字段中，指定为每个缩进级别插入的空格数量。  |
|    连续缩进    |     指定从上一行延续的行的缩进，以明确它们属于同一语句或代码块。 当单个语句过长而无法放在一行时，将使用连续缩进。     |
|    保持空行的缩进    |     如果选中此复选框，IntelliJ IDEA 将会保持空行的缩进，就像它们包含了一些代码一样。       如果取消勾选此复选框，IntelliJ IDEA 将删除制表符和空格。     |
|    标签缩进    |  在此字段中，指定在下一行的选项卡语句之前插入的空格数量。  |
|    绝对标签缩进    |  如果选中此复选框，选项卡缩进将被视为绝对空格数。 否则，选项卡缩进将相对于先前的缩进级别进行计数。  |
|    不缩进顶层类成员    |  选择此复选框，可以让顶级类成员位于类声明的缩进级别。  |
|    相对于表达开始使用缩进    |     使用此复选框在两种可能的缩进行为之间切换：        * 如果禁用此选项，代码块将与从新行开始的最近祖先块对齐。    * 如果启用此选项，代码块将按列进行格式设置。    |

## 空格

选中或清除复选框，以在各种上下文中插入、不插入或移除 Space。

### 括号前的空格

|  条目  |  示例  |
| --- | --- |
|    方法声明括号    |     如果选中，将在方法声明中的左圆括号前插入 Space。 否则，不插入空格。      已选择:  ```JAVA public void foo (int x, int y) {}  ```   未选择:  ```JAVA public void foo(int x, int y) {}  ```     |
|    方法调用括号    |     如果选中，将在方法调用中的左圆括号前插入 Space。       否则，不插入空格。      已选择:  ```JAVA System.out.print (a);  ```   未选择:  ```JAVA System.out.print(a);  ```     |
|    "if" 括号    |  如果选中，将在  `if`  声明中的开头括号之前插入一个空格。 否则，不插入空格。   已选择:  ```JAVA if (0 < x && x < 10) {}  ```   未选择:  ```JAVA if(0 < x && x < 10) {}  ```     |
|    "for" 括号    |     如果选中，将在  `for`  循环中的开括号前插入一个空格。 否则，不插入空格。      已选择:  ```JAVA for (int i = 0; i < x; i++) {}  ```   未选择:  ```JAVA for(int i = 0; i < x; i++) {}  ```     |
|    "while" 括号    |     如果选中，将在  `while`  循环中的开括号前插入一个空格。 否则，不插入空格。      已选择:  ```JAVA while (x != y) {}  ```   未选择:  ```JAVA while(x != y) {}  ```     |
|    "switch" 括号    |     如果选中，将在  `switch`  声明中的开头括号之前插入一个空格。 否则，不插入空格。      已选择:  ```JAVA switch (e.getCode()) {}  ```   未选择:  ```JAVA switch(e.getCode()) {}  ```     |
|    "try" 括号    |  如果选中，将在  `try`  声明中的开头括号之前插入一个空格。 否则，不插入空格。   已选择:  ```JAVA try (Res r1 = getResource(); Res r2 = null) {}  ```   未选择:  ```JAVA try(Res r1 = getResource(); Res r2 = null) {}  ```     |
|    "catch" 括号    |     如果选中，将在  `catch`  块中的左圆括号前插入 Space。 否则，不插入空格。      已选择:  ```JAVA catch (MyException e) {}  ```   未选择:  ```JAVA catch(MyException e) {}  ```     |
|    "synchronized" 括号    |     如果选中，将在  `synchronized`  块中的左圆括号前插入 Space。 否则，不插入空格。      已选择:  ```JAVA synchronized (this) {}  ```   未选择:  ```JAVA synchronized(this) {}  ```     |
|    注解参数    |     如果选中，将在注解形参的左圆括号前插入 Space。 否则，不插入空格。      已选择:  ```JAVA @SuppressWarnings ({"ALL"})  ```   未选择:  ```JAVA @SuppressWarnings({"ALL"})  ```     |
|    析构列表    |     如果选中，将在析构模式中的左圆括号前插入 Space。 否则，不插入空格。      已选择:  ```JAVA case Rec (String s, int i) r -> {}  ```   未选择:  ``` case Rec(String s, int i) r -> {}  ```     |

### 围绕操作符

|  条目  |  示例  |
| --- | --- |
|    赋值运算符(=、+=、…)    |     如果选中，将在赋值表达式中的赋值操作符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA int[] empty = new int[]{};  ```   未选择:  ```JAVA int[] empty=new int[]{};  ```     |
|    逻辑运算符（&&, \|\|）    |     如果选中，逻辑表达式中的逻辑运算符周围会插入空格。 否则，不会插入空格。      已选择:  ```JAVA public void checkValue() {     if (0 < x && x < 10) {     } }  ```   未选择:  ```JAVA public void checkValue() {     if (0 < x && x < 10) {     } }  ```     |
|    相等运算符（==，!=）    |     如果选择，比较表达式中的等号运算符周围将插入空格。 否则，不会插入空格。      已选择:  ```JAVA while (x != y) {}  ```   未选择:  ```JAVA while (x!=y) {}  ```     |
|    关系运算符（<、>、<=、>=）    |     如果被选中，关系运算符在比较表达式中会插入空格。 否则，不会插入空格。      已选择:  ```JAVA if (0 < x && x < 10) {}  ```   未选择:  ```JAVA if (0<x &&x< 10) {}  ```     |
|    按位运算符（&, \|, ^）    |     如果选中，将在位运算符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA y += (y ^ 0x123) << 2;  ```   未选择:  ```JAVA y += (y^0x123) << 2;  ```     |
|    加法运算符（+，-）    |     如果选中，将在加法运算符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA x = f(x * 3 + 5);  ```   未选择:  ```JAVA x = f(x * 3+5);  ```     |
|    乘法运算符（*, /, %）    |     如果选中，将在乘法运算符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA x = f(x * 3 + 5);  ```   未选择:  ```JAVA x = f(x*3 + 5);  ```     |
|    Shift 运算符（<<，>>，>>>）    |     如果选中，将在位移运算符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA y += (y ^ 0x123) << 2;  ```   未选择:  ```JAVA y += (y ^ 0x123)<<2;  ```     |
|    一元运算符（!,-,+,++,--）    |     如果选中，将在一元运算符周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA x = y >= 0 ? arr[y] : - 1;  ```   未选择:  ```JAVA x = y >= 0 ? arr[y] : -1;  ```     |
|    Lambda 箭头    |     如果选中，将在 lambda 箭头周围插入空格。 否则，不会插入空格。      已选择:  ```JAVA Runnable r = () -> {};  ```   未选择:  ```JAVA Runnable r = ()->{};  ```     |
|    方法引用双冒号    |     如果选中，将在方法引用的双冒号周围插入 Space。 否则，不插入空格。      已选择:  ```JAVA Runnable r1 = this :: bar;  ```   未选择:  ```JAVA Runnable r1 = this::bar;  ```     |

### 在左大括号之前

|  条目  |  示例  |
| --- | --- |
|    类左大括号    |     如果选中，类声明中的类名和左大括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA public class Main { }  ```   未选择:  ```JAVA public class Main{ }  ```       选择或清除复选框只在   大括号的位置   为   在类声明中   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|       方法左大括号       |     如果选中，将在方法声明中方法形参列表的右圆括号与左大括号之间插入一个 Space。 否则，不插入空格。      已选择:  ```JAVA public int add(int a, int b) { }  ```   未选择:  ```JAVA public int add(int a, int b){ }  ```       选择或清除复选框只在   大括号的位置   为   在方法声明中   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'if'左大括号    |     如果选中，条件表达式的闭括号和  `if`  语句的开括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA if (0 < x && x < 10) { }  ```   未选择:  ```JAVA if (0 < x && x < 10){ }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'else'左大括号    |     如果选中，  `else`  关键字和  `if-else`  语句中的开括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA if (x) {     System.out.println("Hello from x!"); } else {     System.out.println(y); }  ```   未选择:  ```JAVA if (x) {     System.out.println("Hello from x!"); } else{     System.out.println(y); }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'for'左大括号    |     如果选中，条件表达式的结束括号和  `for`  循环的开始大括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA for (int a : X) {     System.out.print(a); }  ```   未选择:  ```JAVA for (int a : X){     System.out.print(a); }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'while'左大括号    |     如果选中，条件表达式的结束括号和  `while`  循环的开始大括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA while (x != y) {     x = f(x * 3 + 5); }  ```   未选择:  ```JAVA while (x != y){     x = f(x * 3 + 5); }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'do'左大括号    |     如果选中，将在  `do`  关键字和  `do-while`  循环中的开启大括号之间插入空格。 否则，不插入空格。      已选择:  ```JAVA do {     System.out.println("Count is: " + count);     count++; } while (count <= 3);  ```   未选择:  ```JAVA do{     System.out.println("Count is: " + count);     count++; } while (count <= 3);  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'switch'左大括号    |     如果选中，条件表达式的闭括号和  `switch`  语句的开括号之间将插入一个空格。 否则，不插入空格。      已选择:  ```JAVA switch (e.getCode()) { }  ```   未选择:  ```JAVA switch (e.getCode()){ }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'try'左大括号    |     如果选中，将在  `try`  关键词和  `try`  块的开括号之间插入一个空格。 否则，不插入空格。      已选择:  ```JAVA try {     get("x"); } catch (Exception e) { }  ```   未选择:  ```JAVA try{     get("x"); } catch (Exception e) { }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'catch'左大括号    |     如果选中，将在  `catch`  语句参数列表和  `catch`  块的开括号之间插入一个空格。 否则，不插入空格。      已选择:  ```JAVA try {     get("x"); } catch (Exception e) { }  ```   未选择:  ```JAVA try {     get("x"); } catch (Exception e){ }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'finally'左大括号    |     如果选中，将在  `finally`  关键词和  `finally`  块的开括号之间插入一个空格。 否则，不插入空格。      已选择:  ```JAVA try {     get("x"); } catch (Exception e) { } finally { }  ```   未选择:  ```JAVA try {     get("x"); } catch (Exception e) { } finally{ }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    'synchronized'左大括号    |     如果选中，将在  `synchronized`  关键词和  `synchronized`  块的开括号之间插入一个空格。 否则，不插入空格。      已选择:  ```JAVA synchronized (this) {     switch (e.getCode()) { }  ```   未选择:  ```JAVA synchronized (this){     switch (e.getCode()) { }  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    数组初始值设定项左大括号    |     如果选中，将在数组初始化器的左大括号前插入一个空格。 否则，不插入空格。      已选择:  ```JAVA int[] empty = new int[] {};  ```   未选择:  ```JAVA int[] empty = new int[]{};  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |
|    注解数组初始值设定项左大括号    |     如果选中，将在数组初始化器的左大括号前插入一个空格。 否则，不插入空格。      已选择:  ```JAVA @SuppressWarnings( {"ALL"})  ```   未选择:  ```JAVA @SuppressWarnings({"ALL"})  ```       选择或清除复选框只在   大括号的位置   为   其他   设置为   行尾   时，在   换行和大括号   选项卡上才相关。     |

### 在关键词之前

|  条目  |  描述  |
| --- | --- |
|    'else'关键字    |     如果选中，将在  `if`  块的闭合括号和  `else` /  `elseif`  关键字之间插入一个空格。 否则，不插入空格。      已选择:  ```JAVA if (x) {     System.out.println("Hello from x!"); } else {     System.out.println(y); }  ```   未选择:  ```JAVA if (x) {     System.out.println("Hello from x!"); }else {     System.out.println(y); }  ```     |
|    'while'关键字    |     如果选中，一个空格会被插入在  `do`  块的关闭括号和  `while`  关键字之间，在  `do-while`  循环中。 否则，不插入空格。      已选择:  ```JAVA do {     System.out.println("Count is: " + count);     count++; } while (count <= 3);  ```   未选择:  ```JAVA do {     System.out.println("Count is: " + count);     count++; }while (count <= 3);  ```     |
|    'catch'关键字    |     如果选中，一个空格将会在  `try`  块的闭合括号和  `catch`  关键字之间插入。 否则，不插入空格。      已选择:  ```JAVA try {     get("x"); } catch (Exception e) { }  ```   未选择:  ```JAVA try {     get("x"); }catch (Exception e) { }  ```     |
|    'finally'关键字    |     如果选中，一个空格将会在  `catch`  块的闭合括号和  `finally`  关键字之间插入。 否则，不插入空格。      已选择:  ```JAVA try {     get("x"); } catch (Exception e) { } finally { }  ```   未选择:  ```JAVA try {     get("x"); } catch (Exception e) { }finally { }  ```     |

### 在

|  条目  |  描述  |
| --- | --- |
|    代码大括号    |     如果选中，将始终在代码大括号内插入空格。 否则，永远不会插入空格。     |
|    中括号    |     如果选中，括号内总是会插入空格。 否则，永远不会插入空格。      已选择:  ```JAVA x = y >= 0 ? arr[ y ] : -1;  ```   未选择:  ```JAVA x = y >= 0 ? arr[y] : -1;  ```     |
|    数组初始化大括号    |     如果选中，数组初始化表达式中的括号内总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA int[] numbers = { 1, 2, 3, 4, 5 };  ```   未选择:  ```JAVA int[] numbers = {1, 2, 3, 4, 5};  ```     |
|    空数组初始化大括号    |     如果选中，将在空数组初始化器  `{ }`  的大括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA int[] empty = new int[]{ };  ```   未选择:  ```JAVA int[] empty = new int[]{};  ```     |
|    分组括号    |     如果选中，复杂表达式中分组括号内的空格将始终插入。 否则，不会插入空格。      已选择:  ```JAVA y += ( y ^ 0x123 ) << 2;  ```   未选择:  ```JAVA y += (y ^ 0x123) << 2;  ```     |
|    方法声明括号    |     如果选中，将在方法声明的括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA public void foo( int x, int y ){ }  ```   未选择:  ```JAVA public void foo(int x, int y){ }  ```     |
|    空方法声明括号    |     如果选中，将在空方法声明的括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA Runnable r = ( ) -> { };  ```   未选择:  ```JAVA Runnable r = () -> { };  ```     |
|    方法调用括号    |     如果选中，将在方法调用的括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA System.out.println( "Hello, World!" );  ```   未选择:  ```JAVA System.out.println("Hello, World!");  ```     |
|    空方法调用括号    |     如果选中，将在空方法调用的括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA switch (e.getCode( )) { }  ```   未选择:  ```JAVA switch (e.getCode()) { }  ```     |
|    "if" 括号    |     如果选中，那么在  `if`  声明中的括号内部总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA for (int num : numbers) {     if ( x ) {         System.out.println("Hello from x!");     } else {         System.out.println(y);     } }  ```   未选择:  ```JAVA for (int num : numbers) {     if (x) {         System.out.println("Hello from x!");     } else {         System.out.println(y);     } }  ```     |
|    "for" 括号    |     如果选中，  `for`  循环中的括号内总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA for ( int a : X ) {     System.out.print(a); }  ```   未选择:  ```JAVA for (int a : X) {     System.out.print(a); }  ```     |
|    "while" 括号    |     如果选中，  `while`  循环中的括号内总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA while ( x != y ) {     x = f(x * 3 + 5); }  ```   未选择:  ```JAVA while (x != y){     x = f(x * 3 + 5); }  ```     |
|    "switch" 括号    |     如果选中，那么在  `switch`  声明中的括号内部总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA switch ( e.getCode() ) { }  ```   未选择:  ```JAVA switch (e.getCode()){ }  ```     |
|    "try" 括号    |     如果选中，那么在  `try`  声明中的括号内部总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA try ( MyRes r1 = getRes(); MyRes r2 = null ) { }  ```   未选择:  ```JAVA try (MyRes r1 = getRes(); MyRes r2 = null) { }  ```     |
|    "catch" 括号    |     如果选中，  `catch`  结构中括号内的空格将始终被插入。 否则，不会插入空格。      已选择:  ```JAVA try {     get("x"); } catch ( Exception e ) { }  ```   未选择:  ```JAVA try{     get("x"); } catch (Exception e) { }  ```     |
|    "synchronized" 括号    |     如果选中，那么在  `synchronized`  声明中的括号内部总是会插入空格。 否则，不会插入空格。      已选择:  ```JAVA synchronized ( this ) {     switch ( e.getCode() ) { }  ```   未选择:  ```JAVA synchronized (this) {     switch ( e.getCode() ) { }  ```     |
|    类型转换括号    |     如果选中，将始终在类型转换括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA int[] arr = ( int[] )g(y);  ```   未选择:  ```JAVA int[] arr = (int[])g(y);  ```     |
|    注解括号    |     如果选中，将始终在注解括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA @SuppressWarnings( {"ALL"} )  ```   未选择:  ```JAVA @SuppressWarnings({"ALL"})  ```     |
|    尖括号    |     如果选中，将始终在尖括号内插入空格。 否则，不会插入空格。      已选择:  ```JAVA class Bar{     static < U, T > U mess(T t){         return null;     } }  ```   未选择:  ```JAVA class Bar{     static <U, T> U mess(T t){         return null; } }  ```     |
|    记录头    |     如果选中，将始终在记录头内插入空格。 否则，不会插入空格。      已选择:  ```JAVA record Rec( String s, int i ){ }  ```   未选择:  ```JAVA record Rec(String s, int i){ }  ```     |
|    析构列表    |     如果选中，将始终在解构列表内插入空格。 否则，不会插入空格。      已选择:  ```JAVA switch ( o ) {     case Rec( String s, int i ) r -> {     } }  ```   未选择:  ```JAVA switch ( o ) {     case Rec(String s, int i) r -> {     } }  ```     |
|    存在主体时在块大括号内    |     如果选中，将始终在解构列表内插入空格。 否则，不会插入空格。      已选择:  ```JAVA if (true) {     System.out.println( "Condition is true" ); }  ```   未选择:  ```JAVA if (true){     System.out.println( "Condition is true" ); }  ```     |

### 在三元运算符 (?:) 中

|  条目  |  描述  |
| --- | --- |
|       在'?'之前           在'?'之后           在':'之前           在':'之后           在“?”与“:”之间       |     选中本节中的复选框，以便在  `?`  周围、  `:`  周围以及在三元运算符中  `?`  和  `:`  之间自动插入空格。       例如，如果选中了   在'?'之前   和   在':'之后   ， IntelliJ IDEA 会在三元条件表达式中的  `?`  前和  `:`  后自动插入空格。 否则，不会插入空格。      已选择:  ```JAVA x=y>=0 ?arr[y]: -1;  ```   未选择:  ```PHP x=y>=0?arr[y]:-1;  ```     |

### 类型参数

|  条目  |  描述  |
| --- | --- |
|    逗号后    |     如果选中，将在包含多个类型的类型实参中的逗号后插入 Space。 否则，不会插入空格。      已选择:  ```JAVA Bar.<String, Integer>mess(null);  ```   未选择:  ```JAVA Bar.<String,Integer>mess(null);  ```     |
|    在打开尖括号之前    |     如果选中，将在类型参数的左尖括号前插入空格。 否则，不会插入空格。      已选择:  ```JAVA Bar. <String,Integer>mess(null);  ```   未选择:  ```JAVA Bar.<String,Integer>mess(null);  ```     |
|    在关闭尖括号之后    |     如果选中，将在类型参数的右尖括号后插入空格。 否则，不会插入空格。      已选择:  ```JAVA Bar.<String,Integer>mess(null);  ```   未选择:  ```JAVA Bar.<String,Integer> mess(null);  ```     |

### 其他

|  条目  |  描述  |
| --- | --- |
|    逗号前    |     如果选中，将在形参列表、实参列表、数组声明等中的逗号前自动插入 Space。 否则，不会插入空格。      已选择:  ```JAVA public void foo(int x ,int y){ }  ```   未选择:  ```JAVA public void foo(int x,int y){ }  ```     |
|    逗号后    |     如果选中，将在形参列表、实参列表、数组声明等中的逗号后自动插入 Space。 否则，不会插入空格。      已选择:  ```JAVA public void foo(int x,int y){ }  ```   未选择:  ```JAVA public void foo(int x, int y){ }  ```     |
|    在 'for' 分号之前    |     如果选中，将在  `for`  循环中的分号前自动插入空格。 否则，不会插入空格。      已选择:  ```JAVA for(int i=0 ;i<x ;i++){     y+=(y^0x123)<<2; }  ```   未选择:  ```JAVA for(int i=0;i<x;i++){     y+=(y^0x123)<<2; }  ```     |
|    在 'for' 分号之后    |     如果选中，将在  `for`  循环中的分号后自动插入空格。 否则，不会插入空格。      已选择:  ```JAVA for(int i=0; i<x; i++){     y+=(y^0x123)<<2; }  ```   未选择:  ```JAVA for(int i=0;i<x;i++){     y+=(y^0x123)<<2; }  ```     |
|    在类型转换之后    |     如果选中，将在类型转换的右括号后自动插入一个空格。 否则，不插入空格，强制转换后的变量会粘附到强制转换上。      已选择:  ```JAVA int[] arr=(int[]) g(y);  ```   未选择:  ```JAVA int[] arr=(int[])g(y);  ```     |
|    注解值对中的 '=' 周围    |     如果选中，将在注解值对中的  `=`  运算符周围自动插入空格。 否则，不会插入空格。      已选择:  ```JAVA @Annotation(param1 = "value1", param2 = "value2")  ```   未选择:  ```JAVA @Annotation(param1="value1", param2="value2")  ```     |
|    在 foreach 中冒号之前    |     如果选中，将在  `foreach`  循环中的冒号前自动插入一个空格。 否则，不插入空格。      已选择:  ```JAVA for(int a : X){     System.out.print(a); }  ```   未选择:  ```JAVA for(int a: X){     System.out.print(a); }  ```     |
|    单行枚举大括号内    |     如果选中，将在单行枚举的常量列表的大括号内自动插入空格。 否则，不会插入空格。      已选择:  ```JAVA public enum Day{ MONDAY,TUESDAY,WEDNESDAY }  ```   未选择:  ```JAVA public enum Day{MONDAY,TUESDAY,WEDNESDAY}  ```     |

### 类型参数

|  条目  |  描述  |
| --- | --- |
|    在打开尖括号之前    |     如果选中，将在类型参数的左尖括号前自动插入一个空格。 否则，不插入空格。      已选择:  ```JAVA public class Foo <T extends Bar&Abba,U>{  ```   未选择:  ```JAVA public class Foo<T extends Bar&Abba,U>{  ```     |
|    类型界限周围    |     如果选中，将在类型参数的类型边界周围自动插入空格。 否则，不插入空格。      已选择:  ```JAVA public class Foo <T extends Bar&Abba,U>{  ```   未选择:  ```JAVA public class Foo<T extends Bar&Abba,U>{  ```     |

## 换行和大括号

在此选项卡中，自定义代码样式选项，IntelliJ IDEA 将在 [重新格式化源代码](reformat-and-rearrange-code.html) 时应用。 左侧窗格包含异常列表（   重新格式化时保留  ），以及各种代码结构（列表、语句、操作、注解等）的放置和对齐选项。 右侧窗格显示预览。

> **Tip:**
> 对齐设置优先于缩进选项。

### 硬换行位置

使用   硬换行位置   字段指定元素右侧所需的边距空间。 如果您选择了   默认  选项，那么将使用 [全局设置](settings-code-style.html#rightMargin)中的右边距值。

### 在输入时换行

使用   在输入时换行   设置来指定如何将编辑的文本适应到指定的   硬换行位置   中：

* 默认 ：在这种情况下，IntelliJ IDEA 使用 在输入时换行 选项，该选项在 [全局设置](settings-code-style.html#wrapOnTyping) 中指定。

* 是 ：在这个例子中，IntelliJ IDEA 使用了在 右边距 字段里指定的值。

* 否 ：在这种情况下，此选项被关闭，一行可以超过右侧边距指定的值。

### 可视化参考线

使用   可视化参考线   字段来指定多个右边距。 您可以保留默认值，或者输入您的边距所需的空格数。 如果您想要指定多个边距，请输入由顿号分隔的数字。

### 重新格式化时保留

使用复选框配置 IntelliJ IDEA 在重新格式化源代码时的例外情况。 例如，默认情况下，   换行   复选框被选中。 如果您的代码包含的行数比标准规范短，您可以在   换行   多选框前取消选中，然后您再 [重新格式化源代码](reformat-and-rearrange-code.html)以转换它们。

### 包装选项

换行样式应用于左侧窗格中指定的各种代码构造（例如，方法调用参数、方法声明参数或赋值语句）。

|  条目  |  描述  |
| --- | --- |
|  包装风格  |     从这个列表中，选择您想要的换行样式：        * 不换行 ：选择此选项后，不会应用任何特殊的包装样式。 选择此选项后，将忽略嵌套对齐和大括号设置。    * 过长时换行 ：选择此选项可以让超出右边界的行以正确的缩进进行折叠。    * 始终换行 ：选择此选项以包装所有列表中的元素，使每行只有一个元素，并具有适当的缩进。    * 过长时分行 ：选择此选项可将超出右边距的列表中的元素进行换行，以便每行一个元素并带有适当的缩进。    |

### 对齐选项

|  条目  |  描述  |
| --- | --- |
|  多行时对齐  |  如果选中此复选框，代码构造将在每一行的同一列开始。 否则，代码结构的位置由当前的缩进级别确定。  |
|   `<character(s)>`  在下一行  |  选中此复选框，可在行已换行时将指定的一个或多个字符移动到下一行。  |
|  'else' 在新行  |  使用此复选框，将相应的语句或字符移至下一行。  |
|  在  `<character>`  之后换行  |  选择此复选框，可以将指定字符后的代码移至新行。  |
|  特别的 'else if' 处理  |     如果选中此复选框，  `else if`  语句会位于同一行。       否则，  `else if`  语句将移动到下一行的相应缩进级别。     |
|  缩进 'case' 分支  |  如果选中此复选框，  `case`  语句将位于相应的缩进级别。 否则，  `case`  语句会与  `switch`  放置在同一缩进级别。  |

### 大括号放置选项

|  条目  |  描述  |
| --- | --- |
|  大括号放置风格  |     使用此列表指定  类声明 、  方法声明 及其他类型声明中左大括号的位置。 可用选项包括：        * 行尾 ：选择此选项将在声明行末放置开括号。    * 下一行如果换行 ：选择此选项，可以在多行声明行之后的行首放置开始大括号。    * 下一行 ：选择此选项可将左大括号放置在声明行之后一行的行首。    * 下一行已移动 ：选择此选项可将左大括号放在声明行之后的一行，并 Shift 到对应的缩进级别。    * 下一行，每行 Shift 缩进。 ：选择此选项可以使开括号放在声明行的下一行，并且相应地移到相应的缩进级别，并且将下一行移到下一个缩进级别。    |
|  强制使用大括号  |     从这个列表中，为  `if` ，  `for` ，  `while`  和  `do () while`  语句选择大括号介绍方法。 可用选项包括：        * 不要强迫 ：选择此选项以禁止自动引入大括号。    * 在多行时 ：如果语句占用多行，则选择此选项以自动引入括号。 请注意，IntelliJ IDEA 分析的是整个声明中的行数，而非仅其条件。 IntelliJ IDEA 将自动插入大括号：    * 始终 ：勾选此复选框，使大括号始终自动添加。    |

### 链式方法调用

使用以下选项来格式化链接的方法调用，使其更易于阅读。 请注意，无论链式调用的设置如何，构建器方法的调用总是被包装的。

|  条目  |  描述  |
| --- | --- |
|  首个调用换行  |  允许在链式方法中包装第一个方法调用。  |
|  多行时对齐  |  对几个方法调用进行对齐。  |
|  构建器方法  |     指定您希望被视为构建器方法的方法名称（标识符），用逗号分隔。       例如：  `withTitle,withYear,addAuthor,withName,withLastName,end,build`      |
|  保留构建器方法的缩进  |  在重新格式化代码时，保持手动插入的额外缩进不变。  |

## 空行

使用此选项卡定义在重新格式化后，您希望 IntelliJ IDEA 保留并在您的代码中插入多少空行以及在何处插入。 对于每种类型的位置，请指定要插入的空行数量。 结果将在预览窗格中显示。

|  条目  |  描述  |
| --- | --- |
|    保留最大空白行数    |  在此区域，指定在指定位置重新格式化后要保留的空行数。  |
|    最小空白行数    |     在此区域，指定在指定位置应存在的最少空行数。      > **Warning:** > 这些设置并不影响第一项之前和最后一项之后的空行数量。    |

## JavaDoc

|  条目  |  描述  |
| --- | --- |
|  对齐​样式​  |     定义 Javadoc 注释的对齐方式。        * 对齐形参说明 ：将形参描述与最长的形参名称对齐。 否则，描述与相应的参数名称之间以单个空格分隔。    * 对齐抛出异常说明 ：将抛出异常的描述与最长的异常名称对齐。 否则，描述与异常名称之间由一个空格分隔。    |
|  空行  |     定义应在 Javadoc 注释中的哪些位置插入空行。        * 描述后 ：在 Javadoc 注释的描述部分之后自动插入一个空行。    * 形参说明后 ：在 `@param` 标记组之后自动插入一个空行。    * 返回标记后 ：在 `@return` 标记之后自动插入一个空行。    |
|  无效标记​​.  |     在此区域内，定义是否应保留无效的选项卡。        * 保留无效标记 ：保留 `@invalidTag` 。    * 保留空 @param 标记 ：保留没有描述的 `@param` 标记。    * 保留空 @return 标记 ：保留没有描述的 `@return` 标记。    * 保留空 @throws 标记 ：保留没有描述的 `@throws` 标记。    |
|  其他  |     在此区域中，为 Javadoc 注释指定附加格式化选项。        * 启用前导星号 ：每行 Javadoc 注释都应以星号开头。    * 使用 @throws 而不是 @exception ：使用 `@throws` 选项卡。    * 在右边界已包装 ：将超出右边距的文本换行到下一行。    * 在空行生成"<p>" ：在空行上自动插入 `</p>` 选项卡。    * 保留空行 ：选中此复选框以保留手动添加的空行。    * 不已包装单行注释 ：请将简短的注释保持在一行中，并与开头和结尾的选项卡一起使用。    * 保留换行符 ：如果未选中此复选框（默认情况下），在重新格式化时不会保留换行符。 当需要将注释格式化在段落的边界内，以占用最小的空间时，这是非常方便的。 如果选中此复选框，将保留换行符。    * 形参说明新起一行 ：将 Javadoc 参数的描述（如果有）放到新的一行。 它使用基于连续缩进值的缩进。    * 连续缩进 ：在多行注释中缩进后续行。    |

## 排列

这个选项卡允许您根据您的偏好定义一套重新排列您的代码的规则。

> **Note:**
> 代码排列并非代码重排的一部分。 要重新排列您的代码，请运行 [专用操作](rearrange-code.html#rearrange_code) ，或配置 IDE 以在保存时自动 [重新排列代码](rearrange-code.html#rearrange-on-save)。

|  条目  |  描述  |
| --- | --- |
|  分组规则  |     使用此区域来设置分组规则。        * 将 getter 和 setter 放在一起 选择此复选框，以维持 getter 和 setter 方法一起。 默认情况下，此复选框已被选中。    * 将重写的方法放在一起 选择此复选框以按类和接口将重写的方法分组。 在 订单 列表中，选择 保持顺序 或 按名称排序 选项。    * 将依赖方法放在一起 选中此复选框以将依赖方法组合在一起。 在 订单 列表中，选择 深度优先顺序 或 广度优先顺序 选项。 前者会按照嵌套层次结构来排列方法；后者会将来自同一嵌套级别的兄弟方法组合在一起。 深度优先: ```PHP class foo { public function parent() { $this->child1(); $this->child2(); } private function child1() { $this->nested1(); } private function nested1() { $this->nested2(); } private function nested2() { } private function child2() { } } ``` 广度优先: ```PHP class foo { public function parent() { $this->child1(); $this->child2(); } private function child1() { $this->nested1(); } private function child2() { } private function nested1() { $this->nested2(); } private function nested2() { } } ```    |
|  匹配规则  |     使用此区域将元素顺序定义为规则列表，其中每条规则都有一个匹配项设置，例如修饰符或类型。        * !["添加"按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.add.svg)：使用此按钮来添加规则。 空规则 区域已打开。    * ![“添加区段规则”按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.codeStyle.AddNewSectionRule.svg)：使用此按钮来添加一个段落规则。 部分规则允许您将方法或变量移动到您定义的部分中。 例如，您可以创建以下节规则： ![一条匹配规则](https://resources.jetbrains.com.cn/help/img/idea/2026.3/matching_rule.png) 安排后，类中的方法将按照创建的部分规则重新排列，并被注释所包围： ```JAVA //methods start public void test() {} private int a() { return 1; } static void r() {} //methods end ```    * !["移除"按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.remove.svg)：使用此按钮从列表中移除规则。    * ![编辑按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.edit.svg)：使用此按钮编辑现有规则。 要查看此按钮，请导航至您想要编辑的规则并点击按钮。 在弹出的窗口中，修改规则字段。    * ![上移按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.moveUp.svg) ![下移按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.moveDown.svg)：使用这些按钮将选定的规则上移或下移。    * ![配置匹配规则](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.expui.general.settings.svg)：使用此按钮为匹配规则配置别名。 在这种情况下，当您创建一个排列规则时，您可以定义一个包含不同规则序列的自定义规则（别名），并将别名应用到您现在的规则。    |
|  空规则  |     使用此区域创建新的匹配规则或编辑现有规则。 您可以从以下筛选器中选择：        * 类型 ：使用此筛选器为规则选择类或方法。 请注意，双击类型关键字将否定条件。    * 修饰符 ：使用此筛选器选择规则的修饰符类型。 请注意，点击两次修饰符关键字会否定该条件。    * 名称 ：使用此字段来在规则中指定条目名称。 此筛选器仅匹配条目名称，例如字段名称、方法名称、类名称等。 该过滤器支持正则表达式，并使用 [标准语法](http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html)。 匹配是针对整个名称进行的。    * 订单 ：使用此列表来选择规则的排序顺序。 当多个元素使用相同的匹配规则时，此选项非常有用。 在这种情况下，选择 保持顺序 将保持在重排之前设置的相同顺序，选择 按名称排序 将按照它们的名称对相同匹配规则的元素进行排序。    * 别名 ：此选项显示在 规则别名定义 对话框中定义的别名。 您可以删除不需要的部分。    |
|  ![按字母顺序排序" 按钮](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app.objectBrowser.sorted.svg)  |  当从   订单   列表中选择  按名称排序  时，会显示此图标。 图标表示此规则中的项目按字母顺序排序。  |

## 导入

这个表格列出了优化导入时需要执行的操作。

|  条目  |  描述  |
| --- | --- |
|  常规  |     在此区域，配置通用导入选项。       选项：        * 使用单类导入 ：在代码生成或 [导入优化](creating-and-optimizing-imports.html)过程中，仅导入包中的特定类。 否则，将插入导入整个包的语句。    * 使用完全限定类名 ：在代码生成或 [导入优化](creating-and-optimizing-imports.html)期间，使用要导入的类的完全限定名。 否则，将插入一条常规的导入语句。    * 为内部类插入导入语句 ：为代码中引用的内部类创建导入。    * 在 JavaDoc 中使用完全限定名称 ：在 Javadocs 中使用完全限定的类名。 否则，将导入一个类。    * 使用 '*' 导入时的类计数 ：请指定从一个包中导入的类的数量，直到所有导入单一类的声明被替换为一个导入整个包的声明。    * 使用 '*' 进行静态导入时的名称计数 ：在此字段中，指定需要从单个类中导入的成员数量，直到所有导入单个成员的声明被替换为导入整个类的声明。    |
|  JSP 导入布局  |     在此区域中，配置您的代码中 JSP 导入语句应如何组织。 引入的更改将在下面的   预览   面板中显示。       选项：        * 优先选择逗号分隔的导入列表 ：选择此选项可以将语句组织为逗号分隔的列表。    * 每页指令优先使用一个导入语句 ：选择此选项可为每行创建一个导入语句。    |
|  使用 '*' 导入的软件包  |     在此区域中，配置一份始终完整导入的包和类的列表。       选项：        * Static ：如果您想为所选类声明 static 导入，请选择此复选框。    * Package ：在此列的文本字段中，指定始终完全导入的包和类。 请注意，IntelliJ IDEA 会在您输入完毕后自动在包名的末尾添加 `.*` 。    * 选择子包 ：勾选此复选框将完全导入所选包的所有子包。    * 添加包 ：点击此按钮以在包和类的列表中添加新条目。    * 添加空格 ：点击此按钮在包和类的列表中添加一个空的分隔符。    * 删除 ：点击此按钮以从列表中删除所选的包或类。    |
|  导入布局  |     在此区域，配置您的代码中应如何组织 import 语句。 您可以设置某些类别，使其被放置在最前方，或者最后，或者依次排列。 导入的类将按照其包进行分组，并在包内按字母顺序排序。       选项：        * 单独排列静态导入 ：如果勾选此复选框，所有静态导入将会保持在一个独立的部分中。 否则，所有的导入声明将按照指定的布局规则进行排序。    * Static ：如果您想为所选包声明静态导入，请选择此复选框。    * Package ：在此列的文本字段中，指定要导入的包。    * 带有子包 ：选中此复选框，IntelliJ IDEA 将对所选包的所有子包应用布局规则。    * 添加包 ：点击此按钮，向包列表中添加新条目。    * 添加空白 ：点击此按钮，在选定的条目后插入一个空行，这表示应在相应的导入语句之间插入一个空行。    * 向上移动 / 向下移动 ：点击这些按钮，可以在列表中上下移动包或空行，从而定义导入语句的顺序。    * 移除 ：点击此按钮以从列表中删除所选包。    |

## 代码生成

|  条目  |  描述  |
| --- | --- |
|  命名  |      * 推荐使用较长名称 ：高亮显示代码补全查找列表中最长的名称。 如果禁用，高亮显示最短的名称。    * 名称前缀 和 名称后缀 ：使用 IntelliJ IDEA 代码生成特性来指定生成新符号命名建议的前缀和后缀。 对于空白字段，将使用没有前缀或后缀的默认名称建议。 当您添加一个前缀值时，IntelliJ IDEA 会自动将建议的基本名称的第一个字母转换为大写。 例如，如果静态字段的前缀定义为 `秒` ，并且字段的类型是 `Counter` ，那么建议的静态字段名称将是 `sCounter` 。 > **Note:** > 这个前缀不影响 getter 和 setter 方法名的生成。 所以，在这种情况下，访问器的名称将是 `getCounter` 和 `setCounter` 。    |
|  默认可见性  |     选择生成的字段和方法的默认访问级别。       您可以直接明确指定，或选择   升级   自动提升到必要的级别。     |
|  变量声明  |  请指定默认情况下是否希望生成带有  `final`  修饰符的本地变量和参数。  |
|  评论代码  |     在此区域配置生成注释的代码样式（行 `Ctrl+/` (Windows), `⌘ /` (macOS), `⌘ /` (IntelliJ IDEA Classic (macOS)), `⌘ /` (macOS System Shortcuts), `Ctrl+/` (XWin), `Ctrl+/` (GNOME), `Ctrl+/` (KDE), `Alt+;` (Emacs), `Ctrl+/` (Sublime Text), `⌘ /` (Sublime Text (macOS)), `Ctrl+Alt+/` (Visual Studio), `⌘ ⌥ /` (Visual Studio (macOS)), `Ctrl+/` (NetBeans), `Ctrl+/` (Eclipse), `⌘ /` (Eclipse (macOS)) 和块 `Ctrl+Shift+/` (Windows), `⌘ ⌥ /` (macOS), `⌃ ⇧ /` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ /` (macOS System Shortcuts), `Ctrl+Shift+/` (XWin), `Ctrl+Shift+/` (GNOME), `Ctrl+Shift+/` (KDE), `Ctrl+Shift+/` (Emacs), `Ctrl+Shift+/` (Sublime Text), `⌘ ⌥ /` (Sublime Text (macOS)), `Ctrl+Shift+/` (Visual Studio), `⌘ ⌃ /` (Visual Studio (macOS)), `Ctrl+Shift+/` (NetBeans), `Ctrl+Shift+/` (Eclipse), `⌘ ⇧ /` (Eclipse (macOS))）：        * 行注释位于首列 ：在第一列开始行注释（ `Ctrl+/` (Windows), `⌘ /` (macOS), `⌘ /` (IntelliJ IDEA Classic (macOS)), `⌘ /` (macOS System Shortcuts), `Ctrl+/` (XWin), `Ctrl+/` (GNOME), `Ctrl+/` (KDE), `Alt+;` (Emacs), `Ctrl+/` (Sublime Text), `⌘ /` (Sublime Text (macOS)), `Ctrl+Alt+/` (Visual Studio), `⌘ ⌥ /` (Visual Studio (macOS)), `Ctrl+/` (NetBeans), `Ctrl+/` (Eclipse), `⌘ /` (Eclipse (macOS))）。 如果您禁用此选项，注释将与您的代码对齐。    * 在注释开头添加一个空格 ：在行注释字符和被注释行的第一个字符之间插入一个空格。    * 重新设置格式时强制 ：在现有评论中，当您正在 [重新格式化代码](reformat-and-rearrange-code.html)时，将空格插入行注释字符和被注释行的第一个字符之间。 请注意，第一个字符必须是字母数字符号，否则不会插入空格。 例如，reformatter 将会忽略 `//&Lorem ipsum` 的评论。 当 在注释开头添加一个空格 被启动时，此选项变为可用。    * 块注释位于首列 ：在第一列开始块注释（ `Ctrl+Shift+/` (Windows), `⌘ ⌥ /` (macOS), `⌃ ⇧ /` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ /` (macOS System Shortcuts), `Ctrl+Shift+/` (XWin), `Ctrl+Shift+/` (GNOME), `Ctrl+Shift+/` (KDE), `Ctrl+Shift+/` (Emacs), `Ctrl+Shift+/` (Sublime Text), `⌘ ⌥ /` (Sublime Text (macOS)), `Ctrl+Shift+/` (Visual Studio), `⌘ ⌃ /` (Visual Studio (macOS)), `Ctrl+Shift+/` (NetBeans), `Ctrl+Shift+/` (Eclipse), `⌘ ⇧ /` (Eclipse (macOS))）。 如果您禁用此选项，注释将与您的代码对齐。    * 在块注释周围添加 Space ：在块注释字符和被注释文本的第一个字符之间插入一个空格。    * 首选文档行注释 ：使用 Markdown 注释风格，而不是传统风格，在使用快速操作插入 [Javadoc](javadocs.html) 注释时。 > **Note:** > Markdown 文档注释仅适用于使用 Java 23 或更高版本的项目。    |
|  重写方法签名  |      * 插入 @Override 重写注解 ：重写方法时插入 `@Override` 注解。    * 重复 synchronized 修饰符 ：重写方法（该方法是同步的）时，添加 `synchronized` 关键字。    * 要复制的注解 ：指定哪些注解应复制到您覆盖的方法中。    * 使用外部注解 ：提示您是希望将 [注解](annotating-source-code.html)存储在源代码中，还是 [外部](annotating-source-code.html#external-annotations)。 如果禁用，注解将默认添加到源代码中。    |
|  Lambda 本体  |     如果一个 lambda 表达式调用了一个已存在的方法，最好通过方法引用来按名称引用该方法。 这些复选框影响  Lambda 可以被方法引用替换  的检查。 如果启用，相应的 lambda 表达式将作为警告高亮显示，并提供相关的快速修复。 如果禁用，代码将不会被高亮显示，但仍然可以使用意图来替换 lambda 表达式为方法引用。        * 尽可能使用 Class::isInstance 和 Class::转换 例如，将 `obj1 -> obj1 instanceof Foo` 替换为 `Foo.class::isInstance` ，将 `obj -> (Foo)obj` 替换为 `Foo.class::cast` 。    * 用对象::nonNull 或对象::isNull 替换空检查 例如，将 `x -> x != null` 替换为 `Objects::nonNull` 。    * 尽可能使用 Integer::sum 等。 尽可能 例如，将 `(a, b) -> a + b` 替换为 `Integer::sum` 。    |

## See also

### 过程

[代码样式方案](configuring-code-style.html)