---
title: "Autoencapsular Campo"
type: "refactoring-technique"
slug: "self-encapsulate-field"
url: "http://localhost:3000/es/self-encapsulate-field.md"
category: "Organizing Data"
description: "Problema: Usas acceso directo a campos privados dentro de una clase. Solución: Crea un getter y un setter para el campo, y úsalos únicamente a ellos para acceder al campo."
languages: ["java", "csharp", "php", "typescript"]
---
# Autoencapsular Campo

> Problema: Usas acceso directo a campos privados dentro de una clase. Solución: Crea un getter y un setter para el campo, y úsalos únicamente a ellos para acceder al campo.

## Problem

Usas acceso directo a campos privados dentro de una clase.

## Solution

Crea un getter y un setter para el campo, y úsalos únicamente a ellos para acceder al campo.

## Why Refactor

A veces, acceder directamente a un campo privado dentro de una clase simplemente no es lo bastante flexible. Quieres poder iniciar el valor de un campo cuando se hace la primera consulta, o realizar determinadas operaciones sobre los nuevos valores del campo cuando se asignan, o quizá hacer todo esto de diversas maneras en las subclases.

## Benefits

* El _acceso indirecto a los campos_ es cuando se actúa sobre un campo a través de métodos de acceso (getters y setters). Este enfoque es mucho más flexible que el _acceso directo a los campos_.

  * Primero, puedes realizar operaciones complejas cuando los datos del campo se asignan o se reciben. La _inicialización perezosa_ y la _validación de los valores del campo_ se implementan fácilmente dentro de los getters y setters del campo.
  * Segundo y más crucial, puedes redefinir los getters y setters en las subclases.
* Tienes la opción de no implementar ningún setter para un campo. El valor del campo se especificará solo en el constructor, haciendo así que el campo sea inmutable durante toda la vida del objeto.

## How to Refactor

1. Crea un getter (y, opcionalmente, un setter) para el campo. Deberían ser `protected` o `public`.
2. Encuentra todas las invocaciones directas del campo y reemplázalas con llamadas al getter y al setter.
## Relations

**Helps you do**

- [Duplicar datos observados](/es/duplicate-observed-data.md)
- [Reemplazar código de tipo con subclases](/es/replace-type-code-with-subclasses.md)
- [Reemplazar código de tipo con estado/estrategia](/es/replace-type-code-with-state-strategy.md)

**Similar techniques**

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