Składowe i metody statyczne

Witamy w kolejnej lekcji! W tej lekcji dowiedzą się Państwo, czym są składowe i metody statyczne w języku C#, jaki jest ich cel oraz jak skutecznie używać ich w programach. Zaczynajmy!

Czym są składowe statyczne?

Składowe statyczne należą do samej klasy, a nie do żadnej konkretnej jej instancji. Są współdzielone przez wszystkie instancje i można uzyskać do nich dostęp bez tworzenia obiektu tej klasy.

Najważniejsza informacja: Proszę używać składowych statycznych w przypadku wartości lub metod, które są takie same dla wszystkich instancji.

Definiowanie pól statycznych

Aby zdefiniować pole statyczne, należy użyć słowa kluczowego static. Przykład:

Najważniejsza informacja: Pola statyczne są współdzielone przez wszystkie instancje klasy.

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
    }
}

Czym są metody statyczne?

Metody statyczne można wywoływać na samej klasie bez konieczności tworzenia instancji. Należy ich używać do funkcji narzędziowych lub operacji, które nie zależą od danych instancji. Przykład:

Wskazówka: Proszę używać metod statycznych w przypadku funkcjonalności, która nie jest powiązana z konkretnymi obiektami.

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
    }
}

Właściwości statyczne

Właściwości statyczne umożliwiają kontrolowany dostęp do pól statycznych. Przykład:

Najważniejsze: Właściwości statyczne zapewniają przejrzysty sposób uzyskiwania dostępu do pól statycznych i ich modyfikowania.

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);
    }
}

Konstruktory statyczne

Konstruktor statyczny jest wywoływany automatycznie w celu zainicjowania pól statycznych lub wykonania innych jednorazowych zadań dla klasy. Przykład:

Wskazówka: Konstruktory statyczne nie mogą mieć modyfikatorów dostępu ani parametrów i są wywoływane tylko raz.

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);
    }
}

Zadanie praktyczne

Proszę utworzyć klasę TemperatureConverter ze statycznymi metodami CelsiusToFahrenheit() i FahrenheitToCelsius() do konwersji temperatury. Przykład:

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));
    }
}

Najlepsze praktyki dotyczące składników statycznych

Oto kilka najlepszych praktyk:

• Należy używać składników statycznych w przypadku funkcjonalności lub danych niezależnych od instancji klasy.
• Należy unikać nadmiernego używania pól statycznych, aby zachować modułowość i testowalność.
• Należy używać konstruktorów statycznych do jednokrotnego inicjowania danych statycznych w cyklu życia aplikacji.

Wskazówka: Składniki statyczne powinny być proste i ukierunkowane.

Świetna robota!

Gratulacje! Nauczyli się Państwo, jak używać składników, metod i konstruktorów statycznych do definiowania funkcjonalności na poziomie klasy w języku C#. W następnej lekcji poznają Państwo enumy i struktury służące do zarządzania stałymi zbiorami wartości i grupowania powiązanych danych. Kontynuujmy kodowanie!