IntelliJ IDEA 2018.1 Help

Inline

The Inline refactoring lets you reverse the extract refactoring for method, constructor, parameter, superclass, anonymous class, and variable.

  1. Place a cursor within the code fragment you want to inline.
  2. Press Ctrl+Alt+N or from the main menu, select Refactor | Inline.
  3. In the Inline dialog that corresponds to the selected symbol, specify the inlining options. Preview and apply changes. (When inlining a variable, simply confirm the inline refactoring.)

    Examples

    Inline Variable

    Inline Variable refactoring replaces redundant variable usage with its initializer.

    BeforeAfter
    public void method() { int number = anotherClass.intValue(); int b = a + number; }
    public void method() { int b = a + anotherClass.intValue(); }
    public void method() { AnotherClass.InnerClass aClass = anotherClass.innerClass; int a = aClass.i; }
    public void method() { int a = anotherClass.innerClass.i; }

    Inline Method

    Inline Method results in placing method's body into the body of its caller(s).

    BeforeAfter
    public void method() { int c=add(a,b); int d=add(a,c); } private int add(int a, int b) { return a+b; }
    public void method() { int c= a + b; int d= a + c; }
    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; }
    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; }

    Inline Constructor

    Inline Constructor allows compressing a chain of constructors, if one of them is a special case of another.

    BeforeAfter
    public class Class { public int varInt; public Class() { this(0); } public Class(int i) { varInt=i; } public void method() { Class aClass=new Class(); ... } }
    public class Class { public int varInt; public Class(int i) { varInt=i; } public void method() { Class aClass=new Class(0); ... } }

    Inline Superclass

    The Inline Superclass refactoring results in pushing superclass' methods into the class where they are used, and removing the superclass.

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

    Inline to Anonymous Class

    Inline to Anonymous Class refactoring allows replacing redundant class with its contents.
    Starting with Java 8, the inlined anonymous classes can be converted to lambdas automatically.

    BeforeAfter
    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()); } }
    import java.util.*; public class Main { void sort(List<String> scores) { scores.sort((s1, s2) -> 0); } }
    Last modified: 26 June 2018

    See Also