Master IntelliJ IDEA’s Extract Method & Interface Refactoring for Cleaner Java Code

Extract Method

IntelliJ IDEA can automatically extract a selected block of code into a new method, eliminating the need for manual copy‑paste refactoring. For example, a complex snippet that processes a list of Node objects can be turned into a reusable method called forEachExceptFirst:

<ol><li><code>liceEnv.defineFunction("run-later", ((metaData, nodes) -> {</code></li><li><code>Number time = (Number) nodes.get(0).eval();</code></li><li><code>Consumer<Node> nodeConsumer = Node::eval;</code></li><li><code>if (time != null) runLater(time.longValue(), () -> {</code></li><li><code>for (int i = 1; i < nodes.size(); i++) {</code></li><li><code>// ... (original loop body) ...</code></li><li><code>nodeConsumer.accept(nodes.get(i));</code></li><li><code>});</code></li><li><code>return new ValueNode(null, metaData);</code></li></ol>

After selecting the block and pressing Ctrl+Alt+M , the IDE presents a dialog where you name the method (e.g., forEachExceptFirst) and confirms the extraction. The resulting code replaces the original block with a single call: forEachExceptFirst(nodes, nodeConsumer); You can optionally add JetBrains annotations such as @NotNull to the generated method signature for better null‑safety:

private void forEachExceptFirst(@NotNull List<@NotNull ? extends Node> nodes, @NotNull Consumer<Node> nodeConsumer) { ... }

Extract Interface

When a class implements several related methods, you can extract an interface to decouple the contract from the implementation. Select the class, invoke Ctrl+Alt+Shift+I (or use the Refactor → Extract → Interface menu), and fill in the interface name, e.g., GensokyoManagement. Choose the methods to include, and IntelliJ generates the interface:

public interface GensokyoManagement {
    @NotNull ImageObject player();
    @NotNull List<@NotNull ImageObject> bullets();
    void dealWithBullet(@NotNull ImageObject bullet);
}

After extraction, you can replace the concrete class type with the new interface wherever it is used, for example changing LinkedList<Marisa> gensokyoManagements to List<GensokyoManagement> gensokyoManagements, thereby programming to an abstraction.

Sending Code Between Interface and Implementation

If you add a new method to a concrete class and want it to become part of the interface, use the "Push Members Up" refactoring. Right‑click the new method, choose Refactor → Push Members Up, select the target interface, and IntelliJ will add the method signature to the interface and insert an @Override annotation in the implementation class.

public @NotNull List<@NotNull ImageObject> spellCard() {
    return masterSpark();
}

After the interface is updated, you can let IntelliJ generate empty implementations in the concrete classes, ensuring all classes conform to the new contract.

These refactoring shortcuts dramatically reduce boilerplate, enforce clean architecture, and keep your Java codebase maintainable.