Java Refactoring Extract Method

Java extract method refactoring

Analyze Java 17 methods for extractable responsibilities, then return behavior-preserving code that introduces focused helper methods with descriptive names while keeping the refactored method complete and compilable.

When to invoke

• "Refactor this Java method using Extract Method."
• "This Java method is too long; split it into helper methods."
• "Improve readability and testability of this Java 17 method."
• "Extract methods from high-complexity Java code without changing behavior."

Criteria

Refactor only methods that exceed at least one threshold, unless the user explicitly requests extraction for a smaller method.

Prefer extraction candidates that are cohesive and nameable: validation, conversion, lookup, branch-specific construction, collection copying, error handling, or object creation.

Extraction rules

Examples

Repository ID to domain ID extraction

Before

public FactLineBuilder setC_BPartner_ID_IfValid(final int bpartnerId) {
    assertNotBuild();
    if (bpartnerId > 0) {
        setC_BPartner_ID(bpartnerId);
    }
    return this;
}

After

// Applies the partner id when a valid domain id is available.
public FactLineBuilder bpartnerIdIfNotNull(final BPartnerId bpartnerId) {
    if (bpartnerId != null) {
        return bpartnerId(bpartnerId);
    } else {
        return this;
    }
}

public FactLineBuilder setC_BPartner_ID_IfValid(final int bpartnerRepoId) {
    return bpartnerIdIfNotNull(BPartnerId.ofRepoIdOrNull(bpartnerRepoId));
}

Factory seam extraction

Before

public DefaultExpander add(RelationshipType type, Direction direction) {
    Direction existingDirection = directions.get(type.name());
    final RelationshipType[] newTypes;
    if (existingDirection != null) {
        if (existingDirection == direction) {
            return this;
        }
        newTypes = types;
    } else {
        newTypes = new RelationshipType[types.length + 1];
        System.arraycopy(types, 0, newTypes, 0, types.length);
        newTypes[types.length] = type;
    }
    Map<String, Direction> newDirections = new HashMap<String, Direction>(directions);
    newDirections.put(type.name(), direction);
    return new DefaultExpander(newTypes, newDirections);
}

After

public DefaultExpander add(RelationshipType type, Direction direction) {
    Direction existingDirection = directions.get(type.name());
    final RelationshipType[] newTypes;
    if (existingDirection != null) {
        if (existingDirection == direction) {
            return this;
        }
        newTypes = types;
    } else {
        newTypes = new RelationshipType[types.length + 1];
        System.arraycopy(types, 0, newTypes, 0, types.length);
        newTypes[types.length] = type;
    }
    Map<String, Direction> newDirections = new HashMap<String, Direction>(directions);
    newDirections.put(type.name(), direction);
    return (DefaultExpander) newExpander(newTypes, newDirections);
}

// Creates the expander instance for the updated type and direction state.
protected RelationshipExpander newExpander(RelationshipType[] types,
        Map<String, Direction> directions) {
    return new DefaultExpander(types, directions);
}

Gotchas

• Do not extract across hidden side effects: preserve order when calls mutate state, validate builders, or depend on lazy initialization.
• Do not over-extract trivial one-liners: extraction should improve naming, reuse, testability, or complexity.
• Keep Java 17 compatibility: do not introduce APIs or syntax beyond Java 17.
• Do not remove functionality: every branch in the original method must still be reachable unless it was provably dead and the user asked for cleanup.

Output template

## Java extract-method result

**Status:** refactored | no qualifying method | blocked
**Thresholds checked:** LOC > 15, NOM > 10, CC > 10
**Methods changed:** <method names>

```java
<complete compilable refactored method and helper methods>
```

### Notes
- <behavior preservation or validation note>

Quality gate

• LOC, NOM, and CC thresholds were assessed before extraction.
• At least one cohesive helper method was extracted for each qualifying method, unless no method qualified.
• Each new helper has a descriptive name and a one-line purpose comment.
• The returned Java code is complete and compilable on Java 17 in its original class context.
• Original behavior, side effects, exceptions, and return values are preserved.
• The output follows ## Output template exactly.