Los miembros estáticos, tales como las variables y los métodos son miembros que se comparten a través de todas las instancias de una clase, los miembros estáticos se pueden acceder directamente desde una clase sin instanciar un objeto de la clase primero.

Normalmente las variables miembros son únicas para cada objeto de una clase, cada objeto de una clase tiene las mismas variables, cada uno tiene su propio valor.

No obstante, con las variables estáticas cada objeto de la clase tiene la misma variable con el mismo valor, por lo tanto cambiar el valor de una variable estática en un lugar resultará en un cambio de valor en todas las otras.

Cómo aplicarlo

Digamos que quieres saber cuántos objetos de una clase de enemigos han sido instanciados.

Una manera muy fácil de hacerlo sería usar una variable miembro estática llamada enemyCount.

Al poner la palabra reservada static en la declaración de un miembro, estás declarando que es estática y, por ende, pertenecerá a la clase misma y no a ninguna de las instancias de la clase.

public class Enemy
{
    // Modificador de acceso public
    // modificador static
    // tipo int
    // nombre de la variable miembro enemyCount
    public static int enemyCount = 0;
}

Luego, lo que necesitamos hacer es incrementar la variable cuando se cree un objeto enemigo.

public class Enemy
{
    public static int enemyCount = 0;

    // constructor
    public Enemy()
    {
        enemyCount++;
    }
}

Cada objeto incrementa la misma variable, esta variable contendrá el número total de todos los enemigos creados.

Acceder a esta variable estática también es algo muy simple.

Aquí tenemos una clase Game que crea unos cuantos enemigos. Para enterarnos de cuántos enemigos se han creado, simplemente necesitamos acceder a la variable estática enemyCount usando el nombre de la clase y el operador de acceso a miembros dot.

public class Game : MonoBehaviour
{
    private void Start()
    {
        Enemy enemy1 = new Enemy();
        Enemy enemy2 = new Enemy();
        Enemy enemy3 = new Enemy();

        int x = Enemy.enemyCount;
        // output 3
    }
}

En este caso, la variable enemyCount es igual a 3.

Este proceso sirve para los scripts que están destinados a ser componentes GameObjects también.

Por ejemplo, si queremos saber el número de jugadores creados en una Scene, podemos crear un componente Player. En este script podemos declarar una variable estática playerCount y en el método Start() podemos incrementarla.

public class Player : MonoBehaviour
{
    public static int playerCount = 0;

    private void Start()
    {
        playerCount++;
    }
}

Ahora, en cualquier momento que se cree un GameObject con este script anexado, el total de playerCount incrementa.

En otro script de componente podemos acceder a esta variable estática, usando el nombre del script y el operador de acceso dot.

public class PlayerManager : MonoBehaviour
{
    private void Start()
    {
        int x = Player.playerCount++;
    }
}

Clases y métodos estáticos

Al igual que las variables estáticas, los métodos estáticos son métodos que pertenecen a la clase y no a un objeto específico de la clase.

Un ejemplo muy sencillo de esto sería si tienes una clase llamada Utilities y dentro de la clase tienen un método estático llamado Add() que retorna el resultado de la suma de dos números.

public static class Utilities
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

Puedes ver que el método Add() es estático gracias a la palabra reservada static.

Ahora en otra clase, puedes invocar el método Add() al usar solo el nombre de la clase y el operador de acceso. No necesitas instanciar un objeto de la clase para usar sus miembros estáticos.

public class UtilitiesConsumer : MonoBehaviour
{
    private void Start()
    {
        int x = Utilities.Add(5, 7);
        // output 12
    }
}

Lo más probable es que ya hayas usado métodos estáticos

Piensa en todas las veces que has trabajado con Input en Unity. Los métodos como Input.GetAxis(), Input.GetKey() e Input.GetButton() son todos métodos estáticos.

public class Example : MonoBehaviour
{
    private void Update()
    {
        float horizontalAxis = Input.GetAxis("Horizontal");

        bool pressSpace = Input.GetKey(KeyCode.Space);

        bool jump = Input.GetButton("Jump");
    }
}

Puedes darte cuenta de que son estáticos porque no tuviste que instanciar un objeto de la clase Input para usarlos, de hecho, Unity tiene muchos métodos estáticos disponibles para ti que proveen una gran variedad de utilidades y herramientas.

Importante recordar

Es muy importante tomar en cuenta que no puedes usar variables miembros no estáticas dentro de métodos estáticos.

Recuerda que un método estático pertenece a la clase mientras que las variables no estáticas pertenecen a las instancias de esa clase.

También puedes hacer que una clase entera sea estática. Para hacerlo simplemente pon la palabra reservada static antes de la palabra reservada class (enfrente del nombre de la clase).

public static class Utilities
{
    // Utilities
}

El resultado es que la clase se vuelve estática y no puedes crear instancias de ella. Esto es muy útil si quieres hacer una clase constituida completamente de variables y métodos estáticos, como la clase Input.

Apoya el contenido de mi blog a través de:

Fuente:

• Microsoft Docs: Static C#
• Unity Learn: Junior Programer