---
title: "Substituir Construtor por Método de Fábrica"
type: "refactoring-technique"
slug: "replace-constructor-with-factory-method"
url: "http://localhost:3000/pt-br/replace-constructor-with-factory-method.md"
category: "Simplifying Method Calls"
description: "Problema: você tem um construtor complexo que faz algo mais do que apenas atribuir valores de parâmetros a campos do objeto. Solução: crie um método de fábrica e use-o para substituir as chamadas ao construtor."
languages: ["java", "csharp", "php", "typescript"]
---
# Substituir Construtor por Método de Fábrica

> Problema: você tem um construtor complexo que faz algo mais do que apenas atribuir valores de parâmetros a campos do objeto. Solução: crie um método de fábrica e use-o para substituir as chamadas ao construtor.

## Problem

Você tem um construtor complexo que faz algo mais do que apenas atribuir valores de parâmetros a campos do objeto.

## Solution

Crie um método de fábrica e use-o para substituir as chamadas ao construtor.

## Why Refactor

A razão mais óbvia para usar esta técnica de refatoração está relacionada a [Substituir Código de Tipo por Subclasses](/pt-br/replace-type-code-with-subclasses).

Você tem um código no qual um objeto era criado anteriormente e o valor do tipo codificado era passado a ele. Após o uso do método de refatoração, surgiram várias subclasses e, a partir delas, você precisa criar objetos dependendo do valor do tipo codificado. Alterar o construtor original para fazê-lo retornar objetos de subclasse é impossível, então, em vez disso, criamos um método de fábrica estático que retornará objetos das classes necessárias, depois do que ele substitui todas as chamadas ao construtor original.

Métodos de fábrica também podem ser usados em outras situações, quando os construtores não dão conta da tarefa. Eles podem ser importantes ao tentar [Mudar Valor para Referência](/pt-br/change-value-to-reference). Também podem ser usados para definir vários modos de criação que vão além do número e dos tipos de parâmetros.

## Benefits

* Um método de fábrica não necessariamente retorna um objeto da classe na qual foi chamado. Muitas vezes podem ser suas subclasses, selecionadas com base nos argumentos passados ao método.
* Um método de fábrica pode ter um nome melhor que descreva o que ele retorna e como, por exemplo `Troops::GetCrew(myTank)`.
* Um método de fábrica pode retornar um objeto já criado, ao contrário de um construtor, que sempre cria uma nova instância.

## How to Refactor

1. Crie um método de fábrica. Coloque nele uma chamada ao construtor atual.
2. Substitua todas as chamadas ao construtor por chamadas ao método de fábrica.
3. Declare o construtor como privado.
4. Investigue o código do construtor e tente isolar o código que não está diretamente relacionado à construção de um objeto da classe atual, movendo esse código para o método de fábrica.
## Relations

**Helps you do**

- [Mudar Valor para Referência](/pt-br/change-value-to-reference.md)
- [Substituir Código de Tipo por Subclasses](/pt-br/replace-type-code-with-subclasses.md)

## Code Examples

### java

```java
// Before
class Employee {
  Employee(int type) {
    this.type = type;
  }
  // ...
}

// After
class Employee {
  static Employee create(int type) {
    employee = new Employee(type);
    // faz um trabalho pesado.
    return employee;
  }
  // ...
}
```

### csharp

```csharp
// Before
public class Employee 
{
  public Employee(int type) 
  {
    this.type = type;
  }
  // ...
}

// After
public class Employee
{
  public static Employee Create(int type)
  {
    employee = new Employee(type);
    // Faz um trabalho pesado.
    return employee;
  }
  // ...
}
```

### php

```php
// Before
class Employee {
  // ...
  public function __construct($type) {
   $this->type = $type;
  }
  // ...
}

// After
class Employee {
  // ...
  static public function create($type) {
    $employee = new Employee($type);
    // faz um trabalho pesado.
    return $employee;
  }
  // ...
}
```

### typescript

```typescript
// Before
class Employee {
  constructor(type: number) {
    this.type = type;
  }
  // ...
}

// After
class Employee {
  static create(type: number): Employee {
    let employee = new Employee(type);
    // Faz um trabalho pesado.
    return employee;
  }
  // ...
}
```