Qué son las variables y métodos de instancia

Las variables y métodos de instancia son elementos que pertenecen específicamente a cada instancia particular creada a partir de una clase.

En otras palabras, cada instancia que creemos a partir de una clase va a tener su propia copia única e independiente de estas variables y métodos.

Por ejemplo si tenemos una clase Persona, que contiene dos textos Nombre y Dni.

Cada instancia de persona que creemos con esta clase tendrá su propio Nombre y Dni. Serán suyos, propios e independientes de todos los demás.

Variables y métodos de instancia

Variables de instancia

Las variables de instancia, también llamados campos o características, se utilizan para almacenar el estado de una instancia.

Cada objeto creado a partir de la clase tendrá su propia copia de estas variables. Para lo cuál, cada uno tendrá su propio espacio en memoria para almacenar la información.

Métodos de instancia

Los métodos de instancia son funciones que actúan sobre una instancia. Estos pueden acceder y manipular las variables de la misma instancia. Además pueden invocar a otros métodos de instancia.

Por otro lado, a diferencia de las variables de instancia, los métodos de instancia no ocupan memoria por cada instancia. En general, el compilador lo sustituirá por una única funcion que reciba una referencia a la instancia.

Caso práctico

Retomemos nuestra clase Persona, que ahora contiene dos variables Nombre y Dni, así como dos método Saludar() o MandarEmail() . Es decir,

Ahora, creamos dos instancias de la clase Persona, que llamaremos juan y maria. Cada una de ellas dispone de diferentes valores para las variables Nombre y Edad.

Persona juan = new Persona();
juan.Nombre = "Luis";
juan.Dni = "000000000";

Persona maria = new Persona();
maria.Nombre = "Maria";
maria.Dni = "000000001";

Además, podríamos usar el método Saludar() para imprimir por pantalla la variable Nombre de cada instancia.

juan.Saludar()  // mostraria 'Luis' en pantalla
maria.Saludar()  // mostraria 'Maria' en pantalla

Esto es posible porque los métodos de instancia tienen acceso las variables y métodos de esta instancia.

Ejemplos en distintos lenguajes

Finalmente, vamos a ver cómo distintos lenguajes implementan las variables y métodos de instancia.

public class Contador
{
    // Variable de instancia
    public int Contador;

    // Método de instancia
    public void IncrementarContador()
    {
        Contador++;
    }
}

// Uso
var contador = new Contador();
contador.IncrementarContador();
Console.WriteLine(contador.Contador);

#include <iostream>

class Contador {
public:
    // Variable de instancia
    int Contador = 0;

    // Método de instancia
    void IncrementarContador() {
        Contador++;
    }
};

// Uso
Contador contador;
contador.IncrementarContador();
std::cout << contador.Contador << std::endl;  

class Contador {
    // Variable de instancia
    constructor() {
        this.contador = 0;
    }

    // Método de instancia
    incrementarContador() {
        this.contador++;
    }
}

// Uso
const contador = new Contador();
contador.incrementarContador();
console.log(contador.contador);

class Contador {
    // Variable de instancia
    contador: number = 0;

    // Método de instancia
    incrementarContador(): void {
        this.contador++;
    }
}

// Uso
const contador = new Contador();
contador.incrementarContador();
console.log(contador.contador);

class Contador:
    def __init__(self):
        # Variable de instancia
        self.contador = 0

    # Método de instancia
    def incrementar_contador(self):
        self.contador += 1

# Uso
contador = Contador()
contador.incrementar_contador()
print(contador.contador)