C# Academy · Lección

Métodos y campos estáticos

Defina miembros que pertenezcan al propio tipo.

Métodos y campos estáticos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Estático frente a instancia

Un miembro de instancia pertenece a cada objeto; un miembro estático pertenece a la propia clase. Existe exactamente una copia de un miembro estático, compartida por todos.

using System;

class Counter
{
    public static int Total;   // shared
    public int Id;             // per instance
}

class Program
{
    static void Main()
    {
        Counter.Total = 5;
        Console.WriteLine("Shared Total: " + Counter.Total);
    }
}

Declaración de campos estáticos

Se accede a un campo static mediante el nombre de la clase, no mediante una instancia: ClassName.Field.

using System;

class Bank
{
    public static decimal InterestRate = 0.05m;
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Rate: " + Bank.InterestRate);
    }
}

Métodos estáticos

Un método static se ejecuta sin una instancia. Se llama mediante la clase. No puede usar campos de instancia porque no existe this.

using System;

class MathUtil
{
    public static int Square(int x)
    {
        return x * x;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(MathUtil.Square(7));
    }
}

Estado compartido entre instancias

Como un campo estático tiene una sola copia, todas las instancias ven el mismo valor. Esto resulta útil para contadores y configuraciones compartidas.

using System;

class Robot
{
    public static int Count;

    public Robot()
    {
        Count++;
    }
}

class Program
{
    static void Main()
    {
        new Robot();
        new Robot();
        new Robot();
        Console.WriteLine("Robots created: " + Robot.Count);
    }
}

Los métodos estáticos no pueden usar datos de instancia

Un método estático no tiene this, por lo que solo puede usar parámetros, variables locales y otros miembros estáticos.

using System;

class Calculator
{
    public static int Add(int a, int b) => a + b;
    public static int Multiply(int a, int b) => a * b;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Calculator.Add(2, 3));
        Console.WriteLine(Calculator.Multiply(4, 5));
    }
}

Combinación de miembros estáticos y de instancia

Una clase puede contener ambos tipos. Los métodos de instancia pueden leer miembros estáticos, pero los métodos estáticos no pueden leer miembros de instancia.

using System;

class Account
{
    public static decimal Fee = 2m;
    public decimal Balance;

    public decimal NetBalance()
    {
        return Balance - Fee;   // instance method can read static
    }
}

class Program
{
    static void Main()
    {
        var a = new Account { Balance = 100m };
        Console.WriteLine("Net: " + a.NetBalance());
    }
}

Patrón de contadores estáticos

Asignar a cada objeto nuevo un id obtenido de un contador estático es un uso clásico de los campos estáticos.

using System;

class Ticket
{
    private static int _next = 1;
    public int Number;

    public Ticket()
    {
        Number = _next++;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(new Ticket().Number);
        Console.WriteLine(new Ticket().Number);
        Console.WriteLine(new Ticket().Number);
    }
}

Métodos auxiliares estáticos

Los métodos estáticos son ideales para operaciones sin estado que dependen únicamente de sus entradas, como formateadores y convertidores.

using System;

class Format
{
    public static string Money(decimal amount)
    {
        return "$" + amount.ToString("0.00");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Format.Money(12.5m));
    }
}

Llamadas estáticas desde métodos estáticos

Los métodos estáticos pueden llamar libremente a otros métodos estáticos de la misma clase sin ninguna instancia.

using System;

class Geometry
{
    public static double CircleArea(double r) => Math.PI * Square(r);
    private static double Square(double x) => x * x;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Geometry.CircleArea(2).ToString("0.00"));
    }
}

Los campos estáticos persisten

Un campo estático conserva su valor durante toda la vida del programa, no solo durante la de un objeto. Úselo para cachés o totales acumulados.

using System;

class Logger
{
    public static int MessageCount;

    public static void Log(string msg)
    {
        MessageCount++;
        Console.WriteLine("[" + MessageCount + "] " + msg);
    }
}

class Program
{
    static void Main()
    {
        Logger.Log("start");
        Logger.Log("working");
        Logger.Log("done");
    }
}

Integración

Los miembros estáticos representan conceptos de ámbito de clase: tarifas compartidas, contadores y auxiliares sin estado, mientras que los miembros de instancia contienen datos propios de cada objeto.

using System;

class Order
{
    public static decimal TaxRate = 0.10m;
    public decimal Subtotal;

    public decimal Total() => Subtotal + Subtotal * TaxRate;
}

class Program
{
    static void Main()
    {
        var o = new Order { Subtotal = 200m };
        Console.WriteLine("Total: " + o.Total());
    }
}

Comprobación rápida

Compruebe cuánto comprende sobre los miembros estáticos.

Recapitulación

Los miembros estáticos pertenecen a la clase y tienen una única copia compartida; los miembros de instancia pertenecen a cada objeto. Los métodos estáticos no tienen this y no pueden acceder a datos de instancia, pero el código de instancia puede leer miembros estáticos. Use miembros estáticos para contadores, configuraciones compartidas y auxiliares sin estado.

using System;

class Demo
{
    public static int Shared;
    public int Own;
    public static void Bump() => Shared++;
}

class Program
{
    static void Main()
    {
        Demo.Bump();
        Demo.Bump();
        Console.WriteLine(Demo.Shared);
    }
}

Preguntas frecuentes

¿La lección «Métodos y campos estáticos» es gratis?

Sí — el texto completo de «Métodos y campos estáticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos y campos estáticos»?

Defina miembros que pertenezcan al propio tipo. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Métodos y campos estáticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Métodos y campos estáticos
Clases estáticas para utilidades
Constantes y campos readonly
Diseño estático frente a diseño de instancia

← Volver a C# Academy