---
title: "Remplacer un constructeur par une méthode de fabrique"
type: "refactoring-technique"
slug: "replace-constructor-with-factory-method"
url: "http://localhost:3000/fr/replace-constructor-with-factory-method.md"
category: "Simplifying Method Calls"
description: "Problème : vous avez un constructeur complexe qui fait autre chose que simplement affecter les valeurs des paramètres aux champs de l'objet. Solution : créez une méthode de fabrique et utilisez-la pour remplacer les appels au constructeur."
languages: ["java", "csharp", "php", "typescript"]
---
# Remplacer un constructeur par une méthode de fabrique

> Problème : vous avez un constructeur complexe qui fait autre chose que simplement affecter les valeurs des paramètres aux champs de l'objet. Solution : créez une méthode de fabrique et utilisez-la pour remplacer les appels au constructeur.

## Problem

Vous avez un constructeur complexe qui fait autre chose que simplement affecter les valeurs des paramètres aux champs de l'objet.

## Solution

Créez une méthode de fabrique et utilisez-la pour remplacer les appels au constructeur.

## Why Refactor

La raison la plus évidente d'utiliser cette technique de refactorisation est liée à [Remplacer un code de type par des sous-classes](/fr/replace-type-code-with-subclasses).

Vous avez du code dans lequel un objet était auparavant créé et où la valeur du type codé lui était transmise. Après application de la méthode de refactorisation, plusieurs sous-classes sont apparues et vous devez en créer les objets en fonction de la valeur du type codé. Modifier le constructeur d'origine pour qu'il renvoie des objets de sous-classe est impossible ; à la place, nous créons donc une méthode de fabrique statique qui renverra les objets des classes nécessaires, puis remplace tous les appels au constructeur d'origine.

Les méthodes de fabrique peuvent aussi être utilisées dans d'autres situations, lorsque les constructeurs ne sont pas à la hauteur de la tâche. Elles peuvent être importantes lorsqu'on tente de [Transformer une valeur en référence](/fr/change-value-to-reference). On peut également les utiliser pour définir divers modes de création qui vont au-delà du nombre et des types de paramètres.

## Benefits

* Une méthode de fabrique ne renvoie pas nécessairement un objet de la classe dans laquelle elle a été appelée. Il s'agit souvent de ses sous-classes, sélectionnées en fonction des arguments fournis à la méthode.
* Une méthode de fabrique peut porter un meilleur nom qui décrit ce qu'elle renvoie et comment, par exemple `Troops::GetCrew(myTank)`.
* Une méthode de fabrique peut renvoyer un objet déjà créé, contrairement à un constructeur, qui crée toujours une nouvelle instance.

## How to Refactor

1. Créez une méthode de fabrique. Placez-y un appel au constructeur actuel.
2. Remplacez tous les appels au constructeur par des appels à la méthode de fabrique.
3. Déclarez le constructeur privé.
4. Examinez le code du constructeur et essayez d'isoler le code qui n'est pas directement lié à la construction d'un objet de la classe actuelle, en le déplaçant vers la méthode de fabrique.
## Relations

**Helps you do**

- [Transformer une valeur en référence](/fr/change-value-to-reference.md)
- [Remplacer un code type par des sous-classes](/fr/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);
    // effectue un traitement lourd.
    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);
    // Effectue un traitement lourd.
    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);
    // effectue un traitement lourd.
    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);
    // Effectue un traitement lourd.
    return employee;
  }
  // ...
}
```