---
title: "Auto-encapsuler un champ"
type: "refactoring-technique"
slug: "self-encapsulate-field"
url: "http://localhost:3000/fr/self-encapsulate-field.md"
category: "Organizing Data"
description: "Problème : vous accédez directement aux champs privés à l'intérieur d'une classe. Solution : créez un getter et un setter pour le champ, et utilisez-les exclusivement pour accéder au champ."
languages: ["java", "csharp", "php", "typescript"]
---
# Auto-encapsuler un champ

> Problème : vous accédez directement aux champs privés à l'intérieur d'une classe. Solution : créez un getter et un setter pour le champ, et utilisez-les exclusivement pour accéder au champ.

## Problem

Vous accédez directement aux champs privés à l'intérieur d'une classe.

## Solution

Créez un getter et un setter pour le champ, et utilisez-les exclusivement pour accéder au champ.

## Why Refactor

Parfois, accéder directement à un champ privé à l'intérieur d'une classe n'est tout simplement pas assez flexible. Vous voulez pouvoir initialiser la valeur d'un champ lors de la première requête, ou effectuer certaines opérations sur les nouvelles valeurs du champ au moment de leur affectation, voire faire tout cela de différentes manières dans les sous-classes.

## Benefits

* L'_accès indirect aux champs_ consiste à agir sur un champ via des méthodes d'accès (getters et setters). Cette approche est bien plus flexible que l'_accès direct aux champs_.

  * Premièrement, vous pouvez effectuer des opérations complexes lorsque les données du champ sont définies ou récupérées. L'_initialisation paresseuse_ et la _validation des valeurs du champ_ s'implémentent facilement à l'intérieur des getters et setters du champ.
  * Deuxièmement, et c'est plus crucial, vous pouvez redéfinir les getters et setters dans les sous-classes.
* Vous avez la possibilité de ne pas implémenter de setter du tout pour un champ. La valeur du champ ne sera alors spécifiée que dans le constructeur, rendant ainsi le champ immuable pendant toute la durée de vie de l'objet.

## How to Refactor

1. Créez un getter (et éventuellement un setter) pour le champ. Ils doivent être soit `protected`, soit `public`.
2. Trouvez tous les accès directs au champ et remplacez-les par des appels au getter et au setter.
## Relations

**Helps you do**

- [Dupliquer les données observées](/fr/duplicate-observed-data.md)
- [Remplacer un code type par des sous-classes](/fr/replace-type-code-with-subclasses.md)
- [Remplacer le code de type par State/Strategy](/fr/replace-type-code-with-state-strategy.md)

**Similar techniques**

- [Encapsuler un champ](/fr/encapsulate-field.md)

## Code Examples

### java

```java
// Before
class Range {
  private int low, high;
  boolean includes(int arg) {
    return arg >= low && arg <= high;
  }
}

// After
class Range {
  private int low, high;
  boolean includes(int arg) {
    return arg >= getLow() && arg <= getHigh();
  }
  int getLow() {
    return low;
  }
  int getHigh() {
    return high;
  }
}
```

### csharp

```csharp
// Before
class Range 
{
  private int low, high;
  
  bool Includes(int arg) 
  {
    return arg >= low && arg <= high;
  }
}

// After
class Range 
{
  private int low, high;
  
  int Low {
    get { return low; }
  }
  int High {
    get { return high; }
  }
  
  bool Includes(int arg) 
  {
    return arg >= Low && arg <= High;
  }
}
```

### php

```php
// Before
private $low;
private $high;

function includes($arg) {
  return $arg >= $this->low && $arg <= $this->high;
}

// After
private $low;
private $high;

function includes($arg) {
  return $arg >= $this->getLow() && $arg <= $this->getHigh();
}
function getLow() {
  return $this->low;
}
function getHigh() {
  return $this->high;
}
```

### typescript

```typescript
// Before
class Range {
  private low: number
  private high: number;
  includes(arg: number): boolean {
    return arg >= low && arg <= high;
  }
}

// After
class Range {
  private low: number
  private high: number;
  includes(arg: number): boolean {
    return arg >= getLow() && arg <= getHigh();
  }
  getLow(): number {
    return low;
  }
  getHigh(): number {
    return high;
  }
}
```