# 内联

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

> **TL;DR**
> `重构 | 内联`
>
>
>
> `Ctrl+Alt+N` (Windows), `⌘ ⌥ N` (macOS), `⌘ ⌥ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ N` (macOS System Shortcuts), `Ctrl+Alt+N` (XWin), `Ctrl+Alt+N` (GNOME), `Ctrl+Alt+N` (KDE), `Ctrl+Alt+N` (Emacs), `Ctrl+Alt+N` (Sublime Text), `⌘ ⌥ N` (Sublime Text (macOS)), `Ctrl+R, I` (Visual Studio), `⌘ R, I` (Visual Studio (macOS)), `Ctrl+Alt+N` (NetBeans), `Alt+Shift+I` (Eclipse), `⌘ ⌥ I` (Eclipse (macOS))

内联 重构允许您对方法、构造函数、参数、超类、匿名类和闭包（适用于 Swift）执行反向重构   提取  。

从 Java 14 版本起，您可以内联 [pattern variable](extract-variable.html)。 在这种情况下，所有出现位置都将被替换为旧式强制类型转换表达式。

Procedure:

1. 将文本光标放在您要内联的代码片段处。

2. 按下 `Ctrl+Alt+N` (Windows), `⌘ ⌥ N` (macOS), `⌘ ⌥ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ N` (macOS System Shortcuts), `Ctrl+Alt+N` (XWin), `Ctrl+Alt+N` (GNOME), `Ctrl+Alt+N` (KDE), `Ctrl+Alt+N` (Emacs), `Ctrl+Alt+N` (Sublime Text), `⌘ ⌥ N` (Sublime Text (macOS)), `Ctrl+R, I` (Visual Studio), `⌘ R, I` (Visual Studio (macOS)), `Ctrl+Alt+N` (NetBeans), `Alt+Shift+I` (Eclipse), `⌘ ⌥ I` (Eclipse (macOS))。 或者，右键点击代码段，然后从  `重构`  菜单中选择所需的内联重构。

3. 在   内联  对话框中，指定选项。

4. （可选）选择   预览   以预览更改。

5. 预览并应用更改。

目前，IntelliJ IDEA 提供  内联函数  重构，其与 [提取方法](extract-method.html) 重构相反。

## 示例

### 内联变量

内联变量 重构用其初始化器替换冗余变量的使用。

> **Note:**
> 变量必须在声明时初始化。 如果初始值在代码的某处被修改，只有在修改之前的出现将被内联。

示例 1

之前:

```JAVA
public void method() {
    int number = anotherClass.intValue();
    int b = a + number;
}


```

之后:

```JAVA
public void method() {
    int b = a + anotherClass.intValue();
}

```

示例 2

之前:

```JAVA
public void method() {
    AnotherClass.InnerClass aClass = anotherClass.innerClass;
    int a = aClass.i;
}

```

之后:

```JAVA
public void method() {
    int a = anotherClass.innerClass.i;
}


```

### 内联方法

内联方法  会将该方法的方法体放入其调用方的方法体中。

示例 1

之前:

```JAVA
public void method() {
    int c=add(a,b);
    int d=add(a,c);
}

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

```

之后:

```JAVA
public void method() {
    int c= a + b;
    int d= a + c;
}

```

示例 2

之前:

```JAVA
public ArrayList method() {
    String[] strings = {"a","b","c"};
    ArrayList list=add(strings);
    return list;
}

private ArrayList add(String[] strings) {
    ArrayList list = new ArrayList();
    for (int i=0; i< strings.length; i++)
    {list.add(strings[i]);}
    return list;
}

```

之后:

```JAVA
public ArrayList method() {
    String[] strings = {"a","ab","abc"};
    ArrayList list1 = new ArrayList();
    for (int i=0; i< strings.length; i++)
    {list.add(strings[i]);}
    ArrayList list = list1;
    return list;
}
 
```

### 内联抽象方法

内联一个只有一个实现的抽象方法，会将对该方法的调用替换为具体实现的代码，并移除对方法声明及其调用的需要。

之前:

```JAVA
public interface AnInterface {
    int readValue();
}

class AClass implements AnInterface {
    public int readValue() {
        return 1;
    }
}

class UserClass{
    void doSmth(){
        AnInterface a = new AClass();
        int i = a.readValue();
    }
}

```

之后:

```JAVA
public interface AnInterface {
    int readValue();
}

class AClass implements AnInterface {
    public int readValue() {
        return 1;
    }
}

class UserClass{
    void doSmth(){
        AnInterface a = new AClass();
        int i =1;
    }
}

```

### 内联构造函数

内联构造函数  可在某个构造函数是另一个构造函数的特例时压缩构造函数链。

之前:

```JAVA
public class Class {
    public int varInt;
    public Class() {
        this(0);
    }

    public Class(int i) {
        varInt=i;
    }

    public void method() {
        Class aClass=new Class();
    }
}

```

之后:

```JAVA
public class Class {
    public int varInt;
    public Class(int i) {
        varInt=i;
    }
    public void method() {
        Class aClass=new Class(0);
    }
}

```

### 内联超类

内联超类  重构会将超类的方法移入使用它们的类中，并移除该超类。

之前:

```JAVA
              public class Bar {
...
                  int calculations1() { ... }
                  int calculations2() { ... }
              }

              class Foo extends Bar {
                  int someMethod() {
    ...
                      if (something > calculations1()) {
        ...
                          return calculations2();
                      }
    ...
                  }
              }
              
```

之后:

```JAVA
               public class Bar {
...
                   int calculations1() { ... }
                   int calculations2() { ... }
               }

               class Foo extends Bar {
                   int someMethod() {
    ...
                       if (something > calculations1()) {
        ...
                           return calculations2();
                       }
    ...
                   }
               }
              
```

### 内联到匿名类

内联到匿名类  重构允许用其内容替换冗余的类。 从 Java 8 开始，内联匿名类可以自动转换为 lambda。

之前:

```JAVA
import java.util.*;

public class Main {
    public class MyComparator implements Comparator<String> {
        @Override
        public int compare(String s1, String s2) {
            return 0;
        }
    }

    void sort(List<String> scores) {
        scores.sort(new MyComparator());
    }
}

```

之后:

```JAVA
import java.util.*;

public class Main {

    void sort(List<String> scores) {
        scores.sort((s1, s2) -> 0);
    }
}
  
```

### 内联形参

内联参数 重构允许您将参数的用法替换为方法调用参数的值。

之前:

```JAVA
public class HelloWorld {
      public static void main(String[] args) {
          int score = getScore(5);
          System.out.println("Score: " + score);
      }

      public static int getScore(int base) {
          return base * 10;
      }
}

```

之后:

```JAVA
public class HelloWorld {
      public static void main(String[] args) {
          int score = getScore();
          System.out.println("Score: " + score);
      }

      public static int getScore() {
          return 5 * 10;
      }
}

```

## See also

### 过程

[代码重构](refactoring-source-code.html)

### 过程

[内联对话框](inline-dialogs.html) [提取/引入变量](extract-variable.html) [Extracting variables in Style Sheets](null)

