IntelliJ IDEA 2021.1 Help

Extract Parameter

The Extract Parameter refactoring lets you extract a new parameter to a method.

You can also use the Extract Functional Parameter refactoring. In this case, IntelliJ IDEA analyzes the selected code, finds out what the method signature would be for the extracted fragment, finds all functional interfaces with this method signature and wraps the code fragment with a anonymous class based on the selected interface and uses this anonymous class as a parameter.

  1. In the editor, position the caret within the expression that you want to introduce as a parameter.

  2. Press Ctrl+Alt+P or from the main menu, select Refactor | Extract | Parameter. If you want to extract a functional parameter, press Ctrl+Alt+Shift+P or from the main menu, select Refactor | Extract | Functional Parameter.

  3. Specify a name of the parameter, select the necessary options in the Extract Parameter popup. For example, if you don't want to change the existing method calls, select the Delegate via overloading method checkbox.

  4. If you need, press Shift+Tab to change a type of the new parameter. (If, at this step, you want to return to editing the parameter name, press Tab .)

Extract parameter examples

When extracting a new parameter you can either introduce a parameter into the existing method or use the Delegate via overloading method option to save the original method and define a new method with your parameter.

Let's replace the string value "Hello, World!" in the method generateText () with the new parameter text. The value "Hello, World!" is passed to the method in the updated method call generateText("Hello, World!").

BeforeAfter
public class HelloWorldPrinter { public static void print() { System.out.println(generateText()); } private static String generateText() { return "Hello, World!".toUpperCase(); } }
public class HelloWorldPrinter { public static void print() { System.out.println(generateText("Hello, World!")); } private static String generateText(String text) { return text.toUpperCase(); } }
BeforeAfter
object HelloWorldPrinter { fun print() { println(generateText()) } private fun generateText(): String { return "Hello, World!".toUpperCase() } }
object HelloWorldPrinter { fun print() { println(generateText("Hello, World!")) } private fun generateText(text: String): String { return text.toUpperCase() } }

Now let's use Delegate via overloading method. In this case, a new overloading method is created and the new parameter is extracted in the definition of this method (the second of the generateText() methods). The signature of the existing generateText() method is not changed. However, the method itself has been modified. Now, it calls the new generateText() method and passes the value "Hello, World!" to it in this call. Note that the existing call of generateText() (in the method print()) is not changed.

BeforeAfter
public class HelloWorldPrinter { public static void print() { System.out.println(generateText()); } private static String generateText() { return "Hello, World!".toUpperCase(); } }
public class HelloWorldPrinter { public static void print() { System.out.println(generateText()); } private static String generateText() { return generateText("Hello, World!"); } private static String generateText(String text) { return text.toUpperCase(); } }
BeforeAfter
object HelloWorldPrinter { fun print() { println(generateText()) } private fun generateText(): String { return "Hello, World!".toUpperCase() } }
// if you selected the "Introduce default value" option object HelloWorldPrinter { fun print() { println(generateText()) } private fun generateText(text: String = "Hello, World!"): String { return text.toUpperCase() } }

Functional parameter examples

Let's perform the refactoring on System.out.println(s); within Hello.printHello().

IntelliJ IDEA finds all functional interfaces with the appropriate method signature (String) -> void and suggests that you select one of them. (In this example, the interface Person is selected.)

As a result, the selected fragment System.out.println(s); is wrapped with an anonymous class based on the interface Person. This anonymous class is passed as a parameter to the call to printHello() within printText().

Person is added as a parameter to printHello() and the initially selected code fragment is replaced with the call to the method of the interface sayHello().

BeforeAfter
@FunctionalInterface public interface Person { public void sayHello (String s); } public class Hello { private void printHello () { String s="Hello"; System.out.println(s); } private void printText () { printHello(); } }
@FunctionalInterface public interface Person { public void sayHello (String s); } public class Hello { private void printHello(Person person) { String s = "Hello"; person.sayHello(s); } private void printText () { printHello(new Person() { public void sayHello(String s) { System.out.println(s); } }); } }

Special notes for the Extract Parameter refactoring

  • If you want a field to be provided as a new parameter in the method declaration, in a method call this field will be presented as a field of a class instance.

  • If a class member is inaccessible (for instance, in the example above the field is private), it will be inserted in a method call but will be highlighted as an error making this file uncompilable.

  • If you use for the Extract Parameter refactoring a field with a getter, you will be prompted with an extended dialog. The dialog has an option group Replace fields used in expressions with their getters:
    • Do not replace: None of the fields will be replaced with calls to the getter.

    • Replace fields inaccessible in usage context: Only the fields that cannot be directly accessed from the usage context will be replaced with calls to the getter.

    • Replace all fields: All fields will be replaced with calls to the getter.

  • Applying the refactoring on a local variable will call the Extract Parameter dialog box with additional checkboxes:
    • Replace all occurrences (<number_of_occurrences> occurrences): If enabled, all occurrences of the selected variable will be replaced with a parameter and the Delete variable definition checkbox is enabled. Otherwise, only the selected variable usage will be replaced with a parameter.

    • Delete variable definition: If enabled, the variable definition will be deleted.

    • Use variable initializer to initialize parameter: If enabled, the variable initializer will be used to initialize the parameter in the method call.

Side effects

Using the Extract Parameter refactoring can have unexpected side effects if applied on class instances or expressions which are actual method parameters. For instance, in case of such code:

class AClass { int field; int method() { return field; } } class Usage { void method(List list) { int sum = 0; for(Iterator it = list.iterator(); it.hasNext(); ) { sum += ((AClass) it.next()).method(); } } }

The code after refactoring applied to the field field:

class AClass { int field; int method(int newfield) { return newfield; } } class Usage { void method(List list) { int sum = 0; for(Iterator it = list.iterator; it.hasNext(); ) { sum += ((AClass) it.next()).method(((AClass) it.next()).field); } } }

The iterator value is increased twice which is, actually, not the behavior you would expect.

However, IntelliJ IDEA can use a temporary variable successfully and resolve such cases as increment/decrement/assignment operations and the new keyword usage. For instance:

public int myMethod(List list) { return list.size(); } public void anotherMethod() { myMethod(new ArrayList()); }

Same code after refactoring looks as follows:

public int myMethod(List list, int newPar) { return list.size(); } public void anotherMethod() { final ArrayList list = new ArrayList(); myMethod(list, list.size()); }

The new variable list was created and all parameters used for the method call are provided using this variable.

Last modified: 08 March 2021