Membros e métodos estáticos

Bem-vindo à próxima lição! Nesta lição, você aprenderá sobre membros e métodos estáticos em C#, sua finalidade e como usá-los de maneira eficaz em seus programas. Vamos começar!

O que são membros estáticos?

Os membros estáticos pertencem à própria classe, e não a uma instância específica da classe. Eles são compartilhados por todas as instâncias e podem ser acessados sem criar um objeto da classe.

Ponto-chave: Use membros estáticos para valores ou métodos que sejam iguais para todas as instâncias.

Definindo campos estáticos

Para definir um campo estático, use a palavra-chave static. Exemplo:

Ponto-chave: Os campos estáticos são compartilhados entre todas as instâncias da classe.

using System;

class Counter {
    public static int Count = 0; // Static field

    public Counter() {
        Count++; // Increment count for each object created
    }
}

class Program {
    static void Main() {
        new Counter(); // Create first object
        new Counter(); // Create second object

        Console.WriteLine("Total Count: " + Counter.Count); // Outputs: Total Count: 2
    }
}

O que são métodos estáticos?

Os métodos estáticos podem ser chamados na própria classe sem exigir uma instância. Use-os para funções utilitárias ou operações que não dependam dos dados da instância. Exemplo:

Dica: Use métodos estáticos para funcionalidades que não estejam vinculadas a objetos específicos.

using System;

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

class Program {
    static void Main() {
        int result = MathUtils.Add(5, 3); // Call static method
        Console.WriteLine("Sum: " + result); // Outputs: Sum: 8
    }
}

Propriedades estáticas

As propriedades estáticas permitem controlar o acesso aos campos estáticos. Exemplo:

Ponto principal: As propriedades estáticas oferecem uma maneira organizada de acessar e modificar campos estáticos.

using System;

class Configuration {
    private static string appName = "MyApp"; // Static field

    public static string AppName { // Static property
        get { return appName; }
        set { appName = value; }
    }
}

class Program {
    static void Main() {
        Console.WriteLine("App Name: " + Configuration.AppName); // Get static property
        Configuration.AppName = "SuperApp"; // Set static property
        Console.WriteLine("Updated App Name: " + Configuration.AppName);
    }
}

Construtores estáticos

Um construtor estático é chamado automaticamente para inicializar campos estáticos ou realizar outras tarefas pontuais de uma classe. Exemplo:

Dica: Os construtores estáticos não podem ter modificadores de acesso nem parâmetros e são chamados apenas uma vez.

using System;

class Logger {
    public static string LogFilePath;

    // Static constructor
    static Logger() {
        LogFilePath = "logs.txt"; // Initialize static field
        Console.WriteLine("Static constructor called.");
    }
}

class Program {
    static void Main() {
        Console.WriteLine("Log File Path: " + Logger.LogFilePath);
    }
}

Desafio prático

Crie uma classe TemperatureConverter com os métodos estáticos CelsiusToFahrenheit() e FahrenheitToCelsius() para conversão de temperatura. Exemplo:

using System;

class TemperatureConverter {
    public static double CelsiusToFahrenheit(double celsius) {
        return (celsius * 9 / 5) + 32;
    }

    public static double FahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5 / 9;
    }
}

class Program {
    static void Main() {
        Console.WriteLine("25°C to Fahrenheit: " + TemperatureConverter.CelsiusToFahrenheit(25));
        Console.WriteLine("77°F to Celsius: " + TemperatureConverter.FahrenheitToCelsius(77));
    }
}

Práticas recomendadas para membros estáticos

Veja algumas práticas recomendadas:

• Use membros estáticos para funcionalidades ou dados independentes das instâncias da classe.
• Evite o uso excessivo de campos estáticos para manter a modularidade e a testabilidade.
• Use construtores estáticos para inicializar dados estáticos uma vez por ciclo de vida da aplicação.

Dica: Mantenha os membros estáticos simples e bem definidos.

Muito bem!

Parabéns! Você aprendeu a usar membros, métodos e construtores estáticos para definir funcionalidades no nível da classe em C#. Na próxima lição, exploraremos enumerações e estruturas para gerenciar conjuntos fixos de valores e agrupar dados relacionados. Vamos continuar programando!