Statische Methoden in Java (statische Methoden). Statische Mitglieder und der statische Modifikator Ein Beispiel für die Verwendung der statischen Methode in C
Klassenmitglieder können mit dem Schlüsselwort static verwendet werden. In diesem Zusammenhang ähnelt seine Bedeutung der in C. Wenn ein Klassenmitglied als statisch deklariert wird, wird der Compiler dadurch angewiesen, dass nur eine Kopie dieses Mitglieds existieren sollte, unabhängig davon, wie viele Objekte dieser Klasse erstellt werden . Ein statisches Mitglied wird von allen Objekten einer bestimmten Klasse gemeinsam genutzt. Alle statischen Daten werden bei der Erstellung des ersten Objekts auf Null initialisiert und es wird keine weitere Initialisierung bereitgestellt.
Wenn Sie ein statisches Datenmitglied einer Klasse deklarieren, ist das Mitglied nicht definiert. Stattdessen müssen Sie eine globale Definition für sie außerhalb der Klasse bereitstellen. Dazu wird die statische Variable erneut deklariert und mithilfe des Bereichsoperators die Klasse identifiziert, zu der die Variable gehört. Dies ist notwendig, damit Speicher für die statische Variable reserviert wird.
Betrachten Sie als Beispiel das folgende Programm:
#enthalten
Klassenzähler (
static int count;
öffentlich:
void setcount(int i) (count = i;);
void showcount()(cout<< count << " "; }
};
int counter::count; // Definition von count
int main() (
Zähler a, b;
a.showcount(); // gibt 0 aus
b.showcount(); // gibt 0 aus
a.setcount(10); // Statische Anzahl auf 10 setzen
a.showcount(); // gibt 10 aus
b.showcount(); // gibt auch 10 aus
0 zurückgeben;
}
Achten wir zunächst darauf, dass die statische Variable vom Typ Integer count an zwei Stellen deklariert wird: in der Zählerklasse und dann als globale Variable. Borland C++ initialisiert die Anzahl auf Null. Aus diesem Grund gibt der erste Aufruf von showcount() Null zurück. Dann setzt Objekt a count auf 10. Dann zeigen beide Objekte a und b mit der Funktion showcount() denselben Wert an, 10. Da es nur eine Kopie von count gibt, die von den Objekten a und b gemeinsam genutzt wird, ist die Ausgabe in beiden Fällen der Wert ist 10.
Es ist auch möglich, statische Memberfunktionen zu haben. Statische Memberfunktionen können nicht direkt auf nicht statische Daten oder nicht statische Funktionen verweisen, die in ihrer Klasse deklariert sind. Der Grund dafür ist, dass es für sie keinen Zeiger gibt und es daher keine Möglichkeit gibt, zu wissen, mit welchen nicht statischen Daten gearbeitet werden soll. Wenn es beispielsweise zwei Objekte einer Klasse gibt, die eine statische Funktion f() enthalten, und wenn f() versucht, auf eine nicht statische Variable var zuzugreifen, die von dieser Klasse definiert wird, wie kann man dann bestimmen, welche Kopie von var verwendet werden soll? ? Der Compiler kann ein solches Problem nicht lösen. Aus diesem Grund können statische Funktionen nur auf andere statische Funktionen oder statische Daten zugreifen. Außerdem können statische Funktionen nicht virtuell sein oder mit den Modifikatoren const oder volatile deklariert werden. Eine statische Funktion kann entweder über ein Klassenobjekt oder über den Klassennamen und einen Bereichsoperator aufgerufen werden. Allerdings dürfen wir nicht vergessen, dass selbst beim Aufruf einer statischen Funktion über ein Objekt dieser nicht der Zeiger this übergeben wird.
Das folgende kurze Programm veranschaulicht eine der vielen Möglichkeiten, statische Funktionen zu verwenden. Eine recht häufige Situation besteht darin, dass Sie Zugriff auf eine begrenzte Ressource gewähren müssen, beispielsweise auf eine freigegebene Datei in einem Netzwerk. Wie dieses Programm zeigt, bietet die Verwendung statischer Daten und Funktionen eine Methode, mit der ein Objekt den Status einer Ressource überprüfen und nach Möglichkeit darauf zugreifen kann.
#enthalten
Klassenzugriff (
statische Aufzählung access_t acs;
// ...
öffentlich:
{
Rückkehr acs;
}
// ...
};
int main()
{
Zugriff auf obj1, obj2;
access::set_access(locked); // Aufruf mit Klassennamen
// ... Code
if (obj2.get_access()==unlocked) ( // Aufruf mit Objekt
cout<< "Access resource.\n";
}
sonst cout<< "Locked out.\n";
// ...
0 zurückgeben;
}
Wenn Sie dieses Programm ausführen, wird „gesperrt“ auf dem Bildschirm angezeigt. Beachten Sie, dass die Funktion set_access() mit dem Klassennamen und dem Bereichsoperator aufgerufen wird. Die Funktion get_access() wird mit einem Objekt und dem Punktoperator aufgerufen. Beim Aufruf einer statischen Funktion kann jede dieser Formen verwendet werden und beide haben den gleichen Effekt. Es lohnt sich, ein wenig mit diesem Programm zu experimentieren, um sicherzustellen, dass Sie verstehen, wie es funktioniert.
Wie bereits erwähnt, haben statische Funktionen nur direkten Zugriff auf andere statische Funktionen oder statische Daten innerhalb derselben Klasse. Um dies zu überprüfen, versuchen wir, die folgende Version des Programms zu kompilieren:
// Dieses Programm enthält einen Fehler und lässt sich nicht kompilieren
#enthalten
enum access_t (shared, in_use, gesperrt, entsperrt);
// Klasse steuert seltene Ressource
Klassenzugriff (
statische Aufzählung access_t acs;
int i; // nicht statisch
// ...
öffentlich:
static void set_access (enum access_t a) (acs = a;)
statische Aufzählung access_t get_access()
{
ich = 100; // wird nicht kompiliert
Rückkehr acs;
}
// ...
};
enum access_t access::acs; // ACS-Definition
int main()
{
Zugriff auf obj1, obj2;
access::set_access(locked); // Aufruf mit Klassennamen
// ... Code
// kann obj2 auf die Ressource zugreifen
if(obj2.get_access()==unlocked) ( // Aufruf mit Objekt
access::set_access(in_use); // Aufruf mit Klassennamen
cout<< "Access resource.\n";
}
sonst cout<< "Locked out.\n";
// ...
}
Dieses Programm lässt sich nicht kompilieren, da die Funktion get_access() versucht, auf eine nicht statische Variable zuzugreifen.
Zunächst verspüren Sie möglicherweise nicht sofort das Bedürfnis, statische Elemente zu verwenden, aber wenn Sie mehr Erfahrung mit der C++-Programmierung sammeln, werden sie in bestimmten Situationen sehr nützlich, da sie die Verwendung globaler Variablen vermeiden.
Letzte Aktualisierung: 08.10.2017
Zusätzlich zu Variablen und Methoden, die sich direkt auf ein Objekt beziehen, können Sie in C++ Variablen und Methoden definieren, die sich direkt auf eine Klasse oder andere statische Mitglieder einer Klasse beziehen. Statische Variablen und Methoden gelten für die gesamte Klasse. Zur Definition wird das Schlüsselwort static verwendet.
Beispielsweise kann eine Bank viele verschiedene Einlagen haben, aber alle Einlagen haben bestimmte gemeinsame Zinssätze. Um ein Bankkonto zu beschreiben, definieren und verwenden wir die folgende Klasse:
#enthalten
Die Account-Klasse definiert einen statischen variablen Zinssatz und zwei statische Funktionen zur Steuerung dieser Variablen. Bei der Definition statischer Funktionen ist zu berücksichtigen, dass wir in ihnen nur statische Klassenvariablen wie die Ratenvariable verwenden können. Nicht statische Variablen können nicht in statischen Funktionen verwendet werden.
Darüber hinaus können Sie den Zeiger this nicht in statischen Funktionen verwenden, was im Prinzip offensichtlich ist, da dieser auf das aktuelle Objekt zeigt und statische Funktionen auf die gesamte Klasse verweisen.
Wichtig ist auch, dass, wenn eine Klasse statische Variablen enthält, diese zusätzlich außerhalb der Klasse definiert werden müssen:
Int Account::rate = 8;
Das Zuweisen eines Anfangswerts zu einer Variablen ist optional.
Es ist auch erwähnenswert, dass statische Mitglieder auf die gesamte Klasse verweisen und daher der Klassenname gefolgt vom ::-Operator verwendet wird, um auf statische Mitglieder zu verweisen. Oder wir können auch über Variablen dieser Klasse auf öffentliche Mitglieder einer Klasse zugreifen:
Account::getRate() account1.getRate()
Konsolenausgabe des Programms:
Rate: 5 Rate: 5 Einkommen: 21000 Rate: 5 Einkommen: 52500
Es ist auch üblich, in Klassen statische Konstanten zu verwenden. Machen wir zum Beispiel die Rate-Variable in der Account-Klasse zu einer Konstanten:
#enthalten
Im Gegensatz zu statischen Variablen müssen statische Konstanten außerhalb der Klasse nicht weiter definiert werden.
Die meisten C++-Schlüsselwörter bewirken eine Sache. Sie verwenden int, um eine Ganzzahlvariable zu deklarieren, entweder wenn eine Funktion einen Ganzzahlwert zurückgibt oder eine Ganzzahl als Argument akzeptiert. Sie verwenden den neuen Operator, um Speicher zu reservieren, und den Löschoperator, um ihn freizugeben. Mit const können Sie angeben, dass der Wert einer Variablen nicht geändert werden kann. Ironischerweise hat das Schlüsselwort static, obwohl es „unveränderlich“ bedeutet, mehrere (und scheinbar unabhängige) Verwendungsmöglichkeiten. Das Schlüsselwort static kann in drei Hauptkontexten verwendet werden:
- innerhalb einer Funktion;
- innerhalb einer Klassendefinition;
- vor einer globalen Variablen in einer Datei, aus der ein Programm mit mehreren Dateien besteht.
Die Verwendung von static innerhalb einer Funktion ist am einfachsten. Dies bedeutet einfach, dass eine einmal initialisierte Variable bis zum Ende des Programms im Speicher verbleibt. Sie können es sich als eine Variable vorstellen, die ihren Wert behält, bis das Programm abgeschlossen ist. Sie können beispielsweise eine statische Variable verwenden, um die Anzahl der Aufrufe einer Funktion aufzuzeichnen, indem Sie einfach die Zeilen static int count = 0; hinzufügen. und count++; in eine Funktion umwandeln. Da count eine statische Variable ist, ist die Zeile static int count = 0; wird nur einmal ausgeführt. Immer wenn die Funktion aufgerufen wird, erhält count den zuletzt zugewiesenen Wert.
Sie können static auch so verwenden, dass verhindert wird, dass die Variable innerhalb der Schleife erneut initialisiert wird. Im folgenden Code ist beispielsweise die Variable „number_of_times“ gleich 100, obwohl die Zeile static int number_of_times = 0; befindet sich innerhalb einer Schleife und scheint jedes Mal ausgeführt zu werden, wenn das Programm die Schleife erreicht. Der Trick besteht darin, dass das Schlüsselwort static verhindert, dass die Variable neu initialisiert wird. Eines der Dinge bei der Verwendung des Schlüsselworts static ist, dass es die Variable für Sie automatisch auf null setzt – aber verlassen Sie sich nicht darauf (es macht Ihre Absichten unklar).
For(int ix=0; ix< 10; ix++) { for(int iy = 0; iy < 10; iy++) { static int number_of_times = 0; number_of_times++; } }
Sie können statische Variablen verwenden, um Informationen über den letzten von einer Funktion zurückgegebenen Wert zu speichern, beispielsweise wenn Sie den von einer Funktion berechneten Maximalwert speichern möchten. Wenn Sie eine Zeichenfolge analysieren, können Sie auch das letzte von der Funktion zurückgegebene Zeichen speichern, sodass Sie sie mit einem Argument aufrufen können, das angibt, dass das letzte Zeichen zurückgegeben werden soll.
Die zweite Verwendung von static erfolgt innerhalb einer Klassendefinition. Obwohl die meisten innerhalb einer Klasse deklarierten Variablen in jeder Instanz der Klasse einen anderen Wert haben können, haben die statischen Felder einer Klasse für alle Instanzen einer bestimmten Klasse dieselbe Bedeutung und es muss nicht einmal eine Instanz dieser Klasse erstellt werden. Es ist sinnvoll, sich statische Klassenvariablen so vorzustellen, dass sie die Informationen enthalten, die zum Erstellen neuer Objekte erforderlich sind (z. B. in einer Klassenfabrik). Wenn Sie beispielsweise Instanzen einer Klasse nummerieren möchten, können Sie eine statische Variable verwenden, um die zuletzt verwendete Nummer zu verfolgen. Es ist wichtig zu beachten, dass es sich bei der Verwendung statischer Klassenvariablen bewährt hat, class_name::x; , nicht „instance_of_class.x“; . Dadurch wird der Programmierer daran erinnert, dass statische Variablen nicht zu einer einzelnen Instanz einer Klasse gehören und dass Sie keine Instanz dieser Klasse erstellen müssen. Wie Sie vielleicht bemerkt haben, können Sie den Bereichsoperator :: verwenden, um auf statisch zuzugreifen, wenn Sie über den Klassennamen darauf zugreifen.
Beachten Sie beim Debuggen oder Implementieren eines Programms mithilfe von Static, dass Sie es nicht innerhalb einer Klasse initialisieren können. Wenn Sie sich tatsächlich dafür entscheiden, den gesamten Klassencode in eine Header-Datei zu schreiben, können Sie nicht einmal eine statische Variable in der Header-Datei initialisieren; Tun Sie dies in der .cpp-Datei. Darüber hinaus müssen Sie die statischen Mitglieder der Klasse initialisieren, da sie sonst nicht im Gültigkeitsbereich liegen. (Die Syntax ist etwas seltsam: Geben Sie class_name::static_variable = value ein.)
Sie können auch statische Klassenfunktionen haben. Statische Funktionen sind Funktionen, die keine Instanz einer Klasse benötigen und analog zu statischen Variablen auf die gleiche Weise mit dem Namen der Klasse und nicht mit dem Namen des Objekts aufgerufen werden. Beispiel: a_class::static_function(); , nicht an_instance.function(); . Statische Funktionen können nur auf statischen Mitgliedern einer Klasse ausgeführt werden, da sie sich nicht auf bestimmte Instanzen der Klasse beziehen. Statische Funktionen können verwendet werden, um statische Variablen zu ändern und deren Werte zu verfolgen. Sie können beispielsweise eine statische Funktion verwenden, wenn Sie sich für die Verwendung eines Zählers entscheiden, um jeder Instanz einer Klasse eine eindeutige Kennung zu geben.
Sie können beispielsweise den folgenden Code verwenden:
Klasse user ( private: int id; static int next_id; public: static int next_user_id() ( next_id++; return next_id; ) // andere Methoden für die Benutzerklasse user() // Klassenkonstruktor ( id = user::next_id++; / / oder Methodenaufruf, id = user.next_user_id(); int user::next_id = 0;
Beachten Sie, dass Sie beim Festlegen den Typ der statischen Variablen angeben müssen!
Benutzer a_user;
setzt die ID auf die nächste ID-Nummer, die von keinem anderen Benutzerobjekt verwendet wird. Beachten Sie, dass es sinnvoll ist, einen Bezeichner als Konstante zu deklarieren.
Die letzte Verwendung von static erfolgt als globale Variable in einer Codedatei. In diesem Fall bedeutet die Verwendung von static, dass der Quellcode in anderen Dateien, die Teil des Projekts sind, nicht auf die Variable zugreifen kann. Nur Code innerhalb derselben Datei kann die Variable sehen (ihr Gültigkeitsbereich ist auf die Datei beschränkt). Diese Technik kann zur Modellierung von objektorientiertem Code verwendet werden, da sie die Sichtbarkeit von Variablen einschränkt und so Namenskonflikte vermeidet. Diese Art der statischen Verwendung ist ein Relikt von C.
Dann können wir direkt über den Klassennamen und den Bereichsauflösungsoperator darauf zugreifen. Was aber, wenn statische Mitgliedsvariablen privat sind? Betrachten Sie den folgenden Code:
In diesem Fall können wir von main() aus nicht direkt auf Anything::s_value zugreifen, da dieses Mitglied privat ist. Normalerweise erfolgt der Zugriff auf private Mitglieder einer Klasse über öffentliche Methoden. Während wir eine reguläre Methode erstellen könnten, um auf s_value zuzugreifen, müssten wir dann ein Objekt dieser Klasse erstellen, um die Methode zu verwenden! Es gibt eine bessere Option: Wir können die Methode statisch machen.
Ähnlich wie bei statischen Mitgliedsvariablen, statische Methoden sind nicht an ein Klassenobjekt gebunden. Hier ist das obige Beispiel, jedoch mit einer statischen Methode:
class Anything ( private: static int s_value; public: static int getValue() ( return s_value; ) // static method ); int Anything::s_value = 3; // Definition einer statischen Mitgliedsvariablen der Klasse int main() ( std::cout<< Anything::getValue() << "\n"; }
Da statische Methoden nicht an ein bestimmtes Objekt gebunden sind, können sie direkt über den Klassennamen und den Bereichsauflösungsoperator sowie über Klassenobjekte aufgerufen werden (dies wird jedoch nicht empfohlen).
Statische Methoden haben keinen *this-Zeiger
Statische Methoden haben zwei interessante Funktionen. Erstens: Da statische Methoden nicht an ein Objekt gebunden sind, haben sie keine ! Dies ist sinnvoll, da der *this-Zeiger immer auf das Objekt zeigt, auf das die Methode angewendet wird. Statische Methoden funktionieren möglicherweise nicht über ein Objekt, daher ist der *this-Zeiger nicht erforderlich.
Zweitens können statische Methoden direkt auf andere statische Elemente (Variablen oder Funktionen) zugreifen, jedoch nicht auf nicht statische Elemente. Dies liegt daran, dass nicht statische Mitglieder zum Klassenobjekt gehören, statische Methoden jedoch nicht!
Noch ein Beispiel
Statische Methoden können außerhalb des Klassenkörpers definiert werden. Dies funktioniert genauso wie bei regulären Methoden. Zum Beispiel:
#enthalten
#enthalten Klasse IDGenerator Privat : static int s_nextID ; // Deklaration einer statischen Mitgliedsvariablen öffentlich: static int getNextID(); // Deklaration einer statischen Methode // Beginnen Sie mit der Generierung der ID ab 1 int IDGenerator::s_nextID = 1; int IDGenerator::getNextID() (return s_nextID++;) int main() for (int count = 0 ; count< 4 ; ++ count ) std::cout<< "The next ID is: " << IDGenerator :: getNextID () << "\n" ; return 0 ; |
Das Ergebnis der Ausführung des obigen Programms:
Die nächste ID ist: 1
Die nächste ID ist: 2
Die nächste ID ist: 3
Die nächste ID ist: 4
Bitte beachten Sie, dass wir kein Objekt dieser Klasse erstellen müssen, um damit zu arbeiten, da alle Variablen und Funktionen dieser Klasse statisch sind! Eine statische Mitgliedsvariable wird verwendet, um den Wert des nächsten Bezeichners zu speichern, der ihr zugewiesen werden soll, und eine statische Methode wird verwendet, um den Bezeichner zurückzugeben und ihn zu erhöhen.
Eine Warnung zu Klassen mit allen statischen Mitgliedern
Seien Sie vorsichtig, wenn Sie Klassen mit allen statischen Mitgliedern schreiben. Während solche „rein statischen Klassen“ nützlich sein können, haben sie auch ihre Nachteile.
Erstens: Da alle statischen Mitglieder nur einmal erstellt werden, kann es nicht mehrere Kopien einer „rein statischen Klasse“ geben (ohne die Klasse zu klonen und dann umzubenennen). Benötigen wir beispielsweise zwei unabhängige Objekte der Klasse IDGenerator, dann wird dies durch eine „rein statische“ Klasse nicht möglich sein.
C++ unterstützt keine statischen Konstruktoren
Wenn Sie eine reguläre Mitgliedsvariable über initialisieren können, sollten Sie logischerweise auch in der Lage sein, statische Mitgliedsvariablen über einen statischen Konstruktor zu initialisieren. Und während einige moderne Sprachen genau zu diesem Zweck statische Konstruktoren unterstützen, gehört C++ leider nicht dazu.
Wenn Ihre statische Variable direkt initialisiert werden kann, ist kein Konstruktor erforderlich: Sie können eine statische Mitgliedsvariable definieren, auch wenn diese privat ist. Dies machen wir im obigen Beispiel mit s_nextID. Hier ist ein weiteres Beispiel:
Klasse Etwas ( public: static std::vector
Klasse Etwas öffentlich: statischer std::vector< char >s_mychars ; std::vector< char >Etwas :: s_mychars = ( "o" , "a" , "u" , "i" , "e" ); // Definiere eine statische Mitgliedsvariable |
Wenn die Initialisierung Ihrer statischen Mitgliedsvariablen die Ausführung von Code (z. B. einer Schleife) erfordert, gibt es verschiedene Möglichkeiten, dies zu tun. Die folgende Methode ist die beste:
#enthalten
#enthalten #enthalten Klasse Etwas Privat : statischer std::vector< char >s_mychars ; öffentlich: class_nested // Definiere eine verschachtelte Klasse mit dem Namen _nested öffentlich: verschachtelt() // Der _nested-Konstruktor initialisiert unsere statische Mitgliedsvariable s_mychars. push_back("o"); s_mychars. push_back("a"); s_mychars. push_back("u"); s_mychars. push_back("i"); s_mychars. push_back("e"); |
Stichwort statisch
Manchmal müssen Sie ein Mitglied einer Klasse definieren, das unabhängig von allen anderen Objekten dieser Klasse verwendet wird. In der Regel wird der Zugriff auf ein Klassenmitglied über ein Objekt dieser Klasse organisiert, Sie können jedoch gleichzeitig ein Klassenmitglied zur unabhängigen Verwendung erstellen, ohne auf eine bestimmte Instanz des Objekts zu verweisen. Um ein solches Klassenmitglied zu erstellen, reicht es aus, es ganz am Anfang seiner Deklaration anzugeben statisches Schlüsselwort.
Wenn ein Klassenmitglied als statisch deklariert ist, wird es verfügbar, bevor Objekte seiner Klasse erstellt werden und ohne einen Verweis auf ein Objekt. Sie können sowohl Variablen als auch Methoden mit dem Schlüsselwort static deklarieren. Das häufigste Beispiel für ein statisches Mitglied ist die Main()-Methode, die als solche deklariert wird, da sie vom Betriebssystem ganz am Anfang des ausführenden Programms aufgerufen werden muss.
Um ein Mitglied vom Typ static außerhalb einer Klasse zu verwenden, reicht es aus, den Namen dieser Klasse mit dem Punktoperator anzugeben. Dafür müssen Sie jedoch kein Objekt erstellen. In Wirklichkeit ist ein Member vom Typ static nicht über einen Verweis auf ein Objekt, sondern über den Namen seiner Klasse zugänglich.
Als statisch deklarierte Variablen sind im Wesentlichen global. Wenn Objekte in einer eigenen Klasse deklariert werden, wird keine Kopie einer statischen Variablen erstellt. Stattdessen nutzen alle Instanzen einer Klasse dieselbe statische Variable. Eine solche Variable wird initialisiert, bevor sie in der Klasse verwendet wird.
Ein Beispiel für die Verwendung des Schlüsselworts static:
Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; Verwenden von System.Text; Namespace ConsoleApplication1 ( class myCircle ( // 2 Methoden, die die Fläche und Länge eines Kreises zurückgeben public static double SqrCircle(int radius) ( return Math.PI * radius * radius; ) public static double LongCircle(int radius) ( return 2 * Math.PI * radius; ) ) class Program ( static void Main(string args) ( int r = 10; // Methoden aus einer anderen Klasse aufrufen // ohne eine Instanz eines Objekts dieser Klasse zu erstellen Console.WriteLine("Area of ein Kreis mit Radius (0) = (1 :#.##)",r,myCircle.SqrCircle(r)); Console.WriteLine("Die Länge des Kreises ist (0:#.##)" ,myCircle.LongCircle(r)); Console.ReadLine(); )
Für die Verwendung statischer Methoden gelten folgende Einschränkungen:
Eine Methode vom Typ static darf keine this-Referenz haben, da eine solche Methode nicht relativ zu einem Objekt ausgeführt wird
Eine Methode vom Typ static kann nur andere Methoden vom Typ static direkt aufrufen, nicht jedoch eine Instanzmethode derselben Klasse. Der Punkt ist, dass Instanzmethoden auf bestimmte Objekte angewendet werden und eine Methode vom Typ static nicht für ein Objekt aufgerufen wird. Daher verfügt eine solche Methode nicht über Objekte, mit denen sie arbeiten könnte.
Ähnliche Einschränkungen gelten für Daten des statischen Typs. Bei einer Methode vom Typ static kann nur auf andere in ihrer Klasse definierte Daten vom Typ static direkt zugegriffen werden. Insbesondere kann er keine Instanzvariablen seiner Klasse bearbeiten, da er keine Objekte hat, mit denen er operieren könnte
Statische Konstruktoren
Der Konstruktor kann auch als statisch deklariert werden. Ein statischer Konstruktor wird normalerweise zum Initialisieren von Komponenten verwendet, die für eine gesamte Klasse und nicht für eine einzelne Instanz eines Objekts dieser Klasse gelten. Daher werden Klassenmitglieder von einem statischen Konstruktor initialisiert, bevor Objekte dieser Klasse erstellt werden:
Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; Verwenden von System.Text; Namespace ConsoleApplication1 ( class MyClass ( public static int a; public int b; // Statischer Konstruktor static MyClass() ( a = 10; ) // Regulärer Konstruktor public MyClass() ( b = 12; ) ) class Program ( static void Main (string args) ( Console.WriteLine("Zugriff auf eine Instanz der Klasse a: " + MyClass.a); MyClass obj = new MyClass(); Console.WriteLine("Zugriff auf eine Instanz der Klasse b: " + obj. b); Konsole .ReadLine(); ) )
Beachten Sie, dass der statische Typkonstruktor automatisch aufgerufen wird, wenn die Klasse zum ersten Mal geladen wird, und vor dem Instanzkonstruktor. Eine allgemeinere Schlussfolgerung daraus ist, dass ein statischer Konstruktor vor jedem Instanzkonstruktor ausgeführt werden muss. Darüber hinaus haben statische Konstruktoren keine Zugriffsmodifikatoren – sie verfügen über Standardzugriff und können daher nicht von einem Programm aufgerufen werden.
Statische Klassen
Die Klasse kann als statisch deklariert werden. Eine statische Klasse hat zwei Haupteigenschaften. Erstellen Sie zunächst Objekte einer statischen Klasse es ist verboten. Und zweitens sollte eine statische Klasse nur statische Mitglieder enthalten. Eine statische Klasse wird mit der folgenden Form der Klassendeklaration erstellt und mit dem Schlüsselwort static geändert.
statische Klasse Klassenname ( // ...
Statische Klassen werden hauptsächlich in zwei Fällen verwendet. Erstens ist beim Erstellen eine statische Klasse erforderlich Erweiterungsmethode. Erweiterungsmethoden sind hauptsächlich mit der LINQ-Sprache verbunden. Und zweitens wird eine statische Klasse verwendet, um eine Sammlung miteinander in Beziehung stehender statischer Methoden zu speichern.
