---
title: "Autoencapsular Campo"
type: "refactoring-technique"
slug: "self-encapsulate-field"
url: "http://localhost:3000/pt-br/self-encapsulate-field.md"
category: "Organizing Data"
description: "Problema: Você usa acesso direto a campos privados dentro de uma classe. Solução: Crie um getter e um setter para o campo e use apenas eles para acessar o campo."
languages: ["java", "csharp", "php", "typescript"]
---
# Autoencapsular Campo

> Problema: Você usa acesso direto a campos privados dentro de uma classe. Solução: Crie um getter e um setter para o campo e use apenas eles para acessar o campo.

## Problem

Você usa acesso direto a campos privados dentro de uma classe.

## Solution

Crie um getter e um setter para o campo e use apenas eles para acessar o campo.

## Why Refactor

Às vezes, acessar diretamente um campo privado dentro de uma classe simplesmente não é flexível o suficiente. Você quer poder inicializar o valor de um campo na primeira vez que ele é consultado, ou realizar certas operações sobre os novos valores do campo quando são atribuídos, ou talvez fazer tudo isso de maneiras diferentes em subclasses.

## Benefits

* _O acesso indireto a campos_ ocorre quando um campo é manipulado por meio de métodos de acesso (getters e setters). Essa abordagem é muito mais flexível do que o _acesso direto a campos_.

  * Primeiro, você pode realizar operações complexas quando os dados do campo são definidos ou obtidos. A _inicialização tardia (lazy initialization)_ e a _validação dos valores do campo_ são facilmente implementadas dentro dos getters e setters do campo.
  * Segundo, e mais importante, você pode redefinir getters e setters em subclasses.
* Você tem a opção de não implementar nenhum setter para um campo. O valor do campo será especificado apenas no construtor, tornando o campo imutável durante toda a vida do objeto.

## How to Refactor

1. Crie um getter (e, opcionalmente, um setter) para o campo. Eles devem ser `protected` ou `public`.
2. Encontre todas as invocações diretas do campo e substitua-as por chamadas ao getter e ao setter.
## Relations

**Helps you do**

- [Duplicar Dados Observados](/pt-br/duplicate-observed-data.md)
- [Substituir Código de Tipo por Subclasses](/pt-br/replace-type-code-with-subclasses.md)
- [Substituir Código de Tipo por Estado/Estratégia](/pt-br/replace-type-code-with-state-strategy.md)

**Similar techniques**

- [Encapsular Campo](/pt-br/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;
  }
}
```