---
title: "Reemplazar método con objeto-método"
type: "refactoring-technique"
slug: "replace-method-with-method-object"
url: "http://localhost:3000/es/replace-method-with-method-object.md"
category: "Composing Methods"
description: "Problema: Tienes un método largo en el que las variables locales están tan entrelazadas que no puedes aplicar Extraer método. Solución: Transforma el método en una clase separada de modo que las variables locales se conviertan en campos de la clase. Después podrás dividir el método en varios métodos dentro de la misma clase."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Reemplazar método con objeto-método

> Problema: Tienes un método largo en el que las variables locales están tan entrelazadas que no puedes aplicar Extraer método. Solución: Transforma el método en una clase separada de modo que las variables locales se conviertan en campos de la clase. Después podrás dividir el método en varios métodos dentro de la misma clase.

## Problem

Tienes un método largo en el que las variables locales están tan entrelazadas que no puedes aplicar _Extraer método_.

## Solution

Transforma el método en una clase separada de modo que las variables locales se conviertan en campos de la clase. Después podrás dividir el método en varios métodos dentro de la misma clase.

## Why Refactor

Un método es demasiado largo y no puedes separarlo debido a marañas de variables locales que resultan difíciles de aislar entre sí.

El primer paso es aislar todo el método en una clase separada y convertir sus variables locales en campos de la clase.

En primer lugar, esto permite aislar el problema a nivel de clase. En segundo lugar, allana el camino para dividir un método grande e inmanejable en otros más pequeños que, de todos modos, no encajarían con el propósito de la clase original.

## Benefits

* Aislar un método largo en su propia clase permite evitar que un método se hinche en tamaño. También permite dividirlo en submétodos dentro de la clase, sin contaminar la clase original con métodos de utilidad.

## How to Refactor

1. Crea una nueva clase. Nómbrala según el propósito del método que estás refactorizando.
2. En la nueva clase, crea un campo privado para almacenar una referencia a una instancia de la clase en la que se encontraba antes el método. Podría usarse para obtener de la clase original algunos datos necesarios si hiciera falta.
3. Crea un campo privado independiente para cada variable local del método.
4. Crea un constructor que acepte como parámetros los valores de todas las variables locales del método y que además inicialice los campos privados correspondientes.
5. Declara el método principal y copia en él el código del método original, sustituyendo las variables locales por campos privados.
6. Sustituye el cuerpo del método original en la clase original creando un objeto-método y llamando a su método principal.
## Relations

**Similar techniques**

- [Reemplazar valor de datos por objeto](/es/replace-data-value-with-object.md)

**Eliminates smells**

- [Método Largo](/es/smells/long-method.md)

## Code Examples

### java

```java
// Before
class Order {
  // ...
  public double price() {
    double primaryBasePrice;
    double secondaryBasePrice;
    double tertiaryBasePrice;
    // Realizar el cálculo largo.
  }
}

// After
class Order {
  // ...
  public double price() {
    return new PriceCalculator(this).compute();
  }
}

class PriceCalculator {
  private double primaryBasePrice;
  private double secondaryBasePrice;
  private double tertiaryBasePrice;
  
  public PriceCalculator(Order order) {
    // Copiar la información relevante del
    // objeto order.
  }
  
  public double compute() {
    // Realizar el cálculo largo.
  }
}
```

### csharp

```csharp
// Before
public class Order 
{
  // ...
  public double Price() 
  {
    double primaryBasePrice;
    double secondaryBasePrice;
    double tertiaryBasePrice;
    // Realizar el cálculo largo.
  }
}

// After
public class Order 
{
  // ...
  public double Price() 
  {
    return new PriceCalculator(this).Compute();
  }
}

public class PriceCalculator 
{
  private double primaryBasePrice;
  private double secondaryBasePrice;
  private double tertiaryBasePrice;
  
  public PriceCalculator(Order order) 
  {
    // Copiar la información relevante del
    // objeto order.
  }
  
  public double Compute() 
  {
    // Realizar el cálculo largo.
  }
}
```

### php

```php
// Before
class Order {
  // ...
  public function price() {
    $primaryBasePrice = 10;
    $secondaryBasePrice = 20;
    $tertiaryBasePrice = 30;
    // Realizar el cálculo largo.
  }
}

// After
class Order {
  // ...
  public function price() {
    return (new PriceCalculator($this))->compute();
  }
}

class PriceCalculator {
  private $primaryBasePrice;
  private $secondaryBasePrice;
  private $tertiaryBasePrice;
  
  public function __construct(Order $order) {
      // Copiar la información relevante del
      // objeto order.
  }
  
  public function compute() {
    // Realizar el cálculo largo.
  }
}
```

### python

```python
// Before
class Order:
    # ...
    def price(self):
        primaryBasePrice = 0
        secondaryBasePrice = 0
        tertiaryBasePrice = 0
        # Realizar el cálculo largo.

// After
class Order:
    # ...
    def price(self):
        return PriceCalculator(self).compute()


class PriceCalculator:
    def __init__(self, order):
        self._primaryBasePrice = 0
        self._secondaryBasePrice = 0
        self._tertiaryBasePrice = 0
        # Copiar la información relevante del
        # objeto order.

    def compute(self):
        # Realizar el cálculo largo.
```

### typescript

```typescript
// Before
class Order {
  // ...
  price(): number {
    let primaryBasePrice;
    let secondaryBasePrice;
    let tertiaryBasePrice;
    // Realizar el cálculo largo.
  }
}

// After
class Order {
  // ...
  price(): number {
    return new PriceCalculator(this).compute();
  }
}

class PriceCalculator {
  private _primaryBasePrice: number;
  private _secondaryBasePrice: number;
  private _tertiaryBasePrice: number;
  
  constructor(order: Order) {
    // Copiar la información relevante del
    // objeto order.
  }
  
  compute(): number {
    // Realizar el cálculo largo.
  }
}
```