Refactoring 007 - Extract Class

Refactoring 007 - Extract Class

Leader posted 8 min read

Behavior is repeated across the system. But you are missing a concept

TL;DR: Put together what belongs together

Problems Addressed

  • Code Duplication

  • Missing Abstraction

  • Low Cohesion

https://maximilianocontieri.com/code-smell-124-divergent-change

https://maximilianocontieri.com/code-smell-143-data-clumps

https://maximilianocontieri.com/code-smell-147-too-many-methods

Context

When a class starts doing work that should be delegated to others, it suffers from Low Cohesion.

You often see this through "Data Clumps"—groups of variables that always travel together—or methods that seem unrelated to the class's primary responsibility.

This bloat makes the code harder to understand and creates a "God Object" that changes for too many different reasons.

You need to extract these related behaviors and properties into a new, dedicated class, you give a name to a previously hidden concept.

This not only promotes code reuse across the system but also ensures that each class has a single, well-defined reason to change.

You are not just moving code; you are discovering the missing abstractions in your domain model.

Steps

  1. Extract the methods (and accidentally the properties) coupled into a new concept

  2. Use the new concept

Sample Code

Before

final class Person {
 
      private String name;
   
      // Below cohesive properties
      private String homeAreaCode;
      private String homeNumber;
      
      public String name() {
          return name;
      }
   
      // Below cohesive behavior
      public String telephoneNumber() {
          return ("(" + homeAreaCode + ") " + homeNumber);
      }
      String areaCode() {
          return homeAreaCode;
      }
      String officeNumber() {
          return officeNumber;
      } 
 }

After

// 1. Extract the methods (and accidentally the properties) 
// coupled into a new concept      
   public class TelephoneNumber {
   
      private String number;
      private String areaCode;
   
      public String telephoneNumber() {
          return ("(" + areaCode + ") " + number);
      }
      public String areaCode() {
          return areaCode;
      }
      public String number() {
          return number;
      }
   }
   
final class Person {

      private String name;
  
      // 2. Use the new concept
      private TelephoneNumber officeTelephone = new TelephoneNumber();
      
      public String name() {
          return name;
      }
      public String telephoneNumber() {
          return officeTelephone.getTelephoneNumber();
      }
     
  }

Type

[X] Automatic

Most IDEs implement this safe refactor.

Safety ️

This is a safe refactoring.

Why is the Code Better? ✨

Logic code is in just one place together with its rules.

How Does it Improve the Bijection? ️

In many software models, you often leave concepts homeless, scattering their behavior and data across unrelated classes.

This creates a gap between the Real World (where a concept clearly exists) and the MAPPER (where it is missing).

When you extract a class, you reify a concept.

You give a name and a physical place to an idea that was previously hidden in the implementation details.

This direct 1:1 Bijection between a real-world entity and a software object reduces cognitive load.

You no longer need to mental map data clumps back to their original meaning.

You are not just organizing code; you are making the software more "real."

Tags ️

  • Hierarchies

Level

[X] Intermediate

https://maximilianocontieri.com/refactoring-002-extract-method

https://maximilianocontieri.com/refactoring-019-reify-email-addresses

https://maximilianocontieri.com/refactoring-013-remove-repeated-code

https://maximilianocontieri.com/refactoring-023-replace-inheritance-with-delegation

https://maximilianocontieri.com/refactoring-018-replace-singleton

https://maximilianocontieri.com/refactoring-020-transform-static-functions

Refactor with AI

Suggested Prompt: 1. Identify classes with low cohesion and unrelated methods.2. Extract related behaviors and properties into new classes.3. Refactor the original class to use the new extracted classes

Without Proper Instructions With Specific Instructions
ChatGPT ChatGPT
Claude Claude
Perplexity Perplexity
Copilot Copilot
You You
Gemini Gemini
DeepSeek DeepSeek
Meta AI Meta AI
Grok Grok
Qwen Qwen

See also

https://refactoring.com/catalog/extractClass.html

https://refactoring.guru/extract-class

Credits

Image from drpepperscott230 on Pixabay


This article is part of the Refactoring Series

https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings

More Posts

Refactoring 009 - Protect Public Attributes

Maxi Contieri - Apr 2

Refactoring 008 - Convert Variables to Constant

Maxi Contieri - Mar 28

Refactoring 038 - Reify Collection

Maxi Contieri - Feb 5

Refactoring 037 - Testing Private Methods

Maxi Contieri - Dec 8, 2025

How to Improve Your Code With Easy Refactorings

Maxi Contieri - Apr 3
chevron_left

Related Jobs

View all jobs →

Commenters (This Week)

4 comments
4 comments
1 comment

Contribute meaningful comments to climb the leaderboard and earn badges!