---
title: "Introduire un objet Null"
type: "refactoring-technique"
slug: "introduce-null-object"
url: "http://localhost:3000/fr/introduce-null-object.md"
category: "Simplifying Conditional Expressions"
description: "Problème : comme certaines méthodes renvoient null au lieu d’objets réels, votre code comporte de nombreuses vérifications de null. Solution : au lieu de null, renvoyez un objet Null qui présente le comportement par défaut."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Introduire un objet Null

> Problème : comme certaines méthodes renvoient null au lieu d’objets réels, votre code comporte de nombreuses vérifications de null. Solution : au lieu de null, renvoyez un objet Null qui présente le comportement par défaut.

## Problem

Comme certaines méthodes renvoient `null` au lieu d’objets réels, votre code comporte de nombreuses vérifications de `null`.

## Solution

Au lieu de `null`, renvoyez un objet Null qui présente le comportement par défaut.

## Why Refactor

Des dizaines de vérifications de `null` rendent votre code plus long et plus laid.

## How to Refactor

1. À partir de la classe concernée, créez une sous-classe qui jouera le rôle d’objet Null.
2. Dans les deux classes, créez la méthode `isNull()`, qui renverra `true` pour un objet Null et `false` pour une classe réelle.
3. Repérez tous les endroits où le code peut renvoyer `null` au lieu d’un objet réel. Modifiez le code pour qu’il renvoie un objet Null.
4. Repérez tous les endroits où les variables de la classe réelle sont comparées à `null`. Remplacez ces vérifications par un appel à `isNull()`.
5. * Si des méthodes de la classe d’origine sont exécutées dans ces conditions lorsqu’une valeur n’est pas égale à `null`, redéfinissez ces méthodes dans la classe Null et insérez-y le code de la partie `else` de la condition. Vous pouvez alors supprimer toute la condition, et le comportement différent sera mis en œuvre via le polymorphisme.
  * Si les choses ne sont pas si simples et que les méthodes ne peuvent pas être redéfinies, voyez si vous pouvez simplement extraire les instructions qui devaient être exécutées dans le cas d’une valeur `null` vers de nouvelles méthodes de l’objet Null. Appelez ces méthodes à la place de l’ancien code dans `else`, comme opérations par défaut.
## Relations

**Similar techniques**

- [Remplacer le conditionnel par du polymorphisme](/fr/replace-conditional-with-polymorphism.md)

**Eliminates smells**

- [Instructions switch](/fr/smells/switch-statements.md)
- [Champ temporaire](/fr/smells/temporary-field.md)

## Code Examples

### java

```java
// Before
if (customer == null) {
  plan = BillingPlan.basic();
}
else {
  plan = customer.getPlan();
}

// After
class NullCustomer extends Customer {
  boolean isNull() {
    return true;
  }
  Plan getPlan() {
    return new NullPlan();
  }
  // Autres fonctionnalités NULL.
}

// Remplacer les valeurs null par l'objet Null.
customer = (order.customer != null) ?
  order.customer : new NullCustomer();

// Utiliser l'objet Null comme s'il s'agissait d'une sous-classe normale.
plan = customer.getPlan();
```

### csharp

```csharp
// Before
if (customer == null) 
{
  plan = BillingPlan.Basic();
}
else 
{
  plan = customer.GetPlan();
}

// After
public sealed class NullCustomer: Customer 
{
  public override bool IsNull 
  {
    get { return true; }
  }
  
  public override Plan GetPlan() 
  {
    return new NullPlan();
  }
  // Autres fonctionnalités NULL.
}

// Remplacer les valeurs null par l'objet Null.
customer = order.customer ?? new NullCustomer();

// Utiliser l'objet Null comme s'il s'agissait d'une sous-classe normale.
plan = customer.GetPlan();
```

### php

```php
// Before
if ($customer === null) {
  $plan = BillingPlan::basic();
} else {
  $plan = $customer->getPlan();
}

// After
class NullCustomer extends Customer {
  public function isNull() {
    return true;
  }
  public function getPlan() {
    return new NullPlan();
  }
  // Autres fonctionnalités NULL.
}

// Remplacer les valeurs null par l'objet Null.
$customer = ($order->customer !== null) ?
  $order->customer :
  new NullCustomer;

// Utiliser l'objet Null comme s'il s'agissait d'une sous-classe normale.
$plan = $customer->getPlan();
```

### python

```python
// Before
if customer is None:
    plan = BillingPlan.basic()
else:
    plan = customer.getPlan()

// After
class NullCustomer(Customer):

    def isNull(self):
        return True

    def getPlan(self):
        return self.NullPlan()

    # Autres fonctionnalités NULL.

# Remplacer les valeurs null par l'objet Null.
customer = order.customer or NullCustomer()

# Utiliser l'objet Null comme s'il s'agissait d'une sous-classe normale.
plan = customer.getPlan()
```

### typescript

```typescript
// Before
if (customer == null) {
  plan = BillingPlan.basic();
}
else {
  plan = customer.getPlan();
}

// After
class NullCustomer extends Customer {
  isNull(): boolean {
    return true;
  }
  getPlan(): Plan {
    return new NullPlan();
  }
  // Autres fonctionnalités NULL.
}

// Remplacer les valeurs null par l'objet Null.
let customer = (order.customer != null) ?
  order.customer : new NullCustomer();

// Utiliser l'objet Null comme s'il s'agissait d'une sous-classe normale.
plan = customer.getPlan();
```