---
title: "Introduzir Objeto Nulo"
type: "refactoring-technique"
slug: "introduce-null-object"
url: "http://localhost:3000/pt-br/introduce-null-object.md"
category: "Simplifying Conditional Expressions"
description: "Problema: Como alguns métodos retornam null em vez de objetos reais, você tem muitas verificações de null no seu código. Solução: Em vez de null, retorne um objeto nulo que apresenta o comportamento padrão."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Introduzir Objeto Nulo

> Problema: Como alguns métodos retornam null em vez de objetos reais, você tem muitas verificações de null no seu código. Solução: Em vez de null, retorne um objeto nulo que apresenta o comportamento padrão.

## Problem

Como alguns métodos retornam `null` em vez de objetos reais, você tem muitas verificações de `null` no seu código.

## Solution

Em vez de `null`, retorne um objeto nulo que apresenta o comportamento padrão.

## Why Refactor

Dezenas de verificações de `null` deixam seu código mais longo e mais feio.

## How to Refactor

1. A partir da classe em questão, crie uma subclasse que desempenhará o papel de objeto nulo.
2. Em ambas as classes, crie o método `isNull()`, que retornará `true` para um objeto nulo e `false` para uma classe real.
3. Encontre todos os lugares onde o código pode retornar `null` em vez de um objeto real. Altere o código para que ele retorne um objeto nulo.
4. Encontre todos os lugares onde as variáveis da classe real são comparadas com `null`. Substitua essas verificações por uma chamada a `isNull()`.
5. * Se métodos da classe original forem executados nesses condicionais quando um valor não é igual a `null`, redefina esses métodos na classe nula e insira ali o código da parte `else` da condição. Então você pode excluir todo o condicional, e o comportamento divergente será implementado por meio de polimorfismo.
  * Se as coisas não forem tão simples e os métodos não puderem ser redefinidos, veja se você consegue simplesmente extrair os operadores que deveriam ser executados no caso de um valor `null` para novos métodos do objeto nulo. Chame esses métodos em vez do código antigo no `else` como as operações padrão.
## Relations

**Similar techniques**

- [Substituir Condicional por Polimorfismo](/pt-br/replace-conditional-with-polymorphism.md)

**Eliminates smells**

- [Comandos Switch](/pt-br/smells/switch-statements.md)
- [Campo Temporário](/pt-br/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();
  }
  // Alguma outra funcionalidade NULL.
}

// Substitui valores null por um Objeto-nulo.
customer = (order.customer != null) ?
  order.customer : new NullCustomer();

// Usa o Objeto-nulo como se fosse uma subclasse normal.
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();
  }
  // Alguma outra funcionalidade NULL.
}

// Substitui valores null por um Objeto-nulo.
customer = order.customer ?? new NullCustomer();

// Usa o Objeto-nulo como se fosse uma subclasse normal.
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();
  }
  // Alguma outra funcionalidade NULL.
}

// Substitui valores null por um Objeto-nulo.
$customer = ($order->customer !== null) ?
  $order->customer :
  new NullCustomer;

// Usa o Objeto-nulo como se fosse uma subclasse normal.
$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()

    # Alguma outra funcionalidade NULL.

# Substitui valores null por um Objeto-nulo.
customer = order.customer or NullCustomer()

# Usa o Objeto-nulo como se fosse uma subclasse normal.
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();
  }
  // Alguma outra funcionalidade NULL.
}

// Substitui valores null por um Objeto-nulo.
let customer = (order.customer != null) ?
  order.customer : new NullCustomer();

// Usa o Objeto-nulo como se fosse uma subclasse normal.
plan = customer.getPlan();
```