Java statische modifier: methoden. Statische klassen, methoden, variabelen

21 antwoorden

Een vuistregel: stel jezelf de vraag: "Heeft het zin om deze methode aan te roepen, zelfs als de Obj nog niet is gebouwd?" Als dat zo is, zal het zeker statisch zijn.

Dus, in de Car-klasse, zou je een dubbele convertMpgToKpl(double mpg) methode kunnen hebben, die statisch zou zijn, omdat je zou kunnen weten naar welke 35mpg wordt geconverteerd, zelfs als niemand de auto ooit heeft gebouwd. Maar void setMileage (dubbele mpg) (die de efficiëntie van een bepaalde auto bepaalt) kan niet statisch zijn, omdat het ondenkbaar is om de methode aan te roepen voordat een auto is gebouwd.

(Btw, het omgekeerde is niet altijd waar: soms kun je een methode hebben die twee Car-objecten bevat en toch statisch wilt zijn. Bijvoorbeeld Car theMoreEfficientOf(Car c1, Car c2) . Hoewel dit kan worden geconverteerd naar niet - statisch versie, beweren sommigen dat aangezien er geen "bevoorrechte" keuze is welke auto belangrijker is, je de beller niet moet dwingen één auto te kiezen als het object waarnaar je verwijst (een vrij kleine fractie van alle statische methoden).

Definieer statische methoden alleen in de volgende scenario's:

Er zijn verschillende goede redenen om statische methoden te gebruiken:

Uitvoering: als u wilt dat een bepaalde code wordt uitgevoerd en u geen extra object wilt instantiëren om dit te doen, plaats het dan in een statische methode. De JVM kan ook veel statische methoden optimaliseren (ik denk dat ik ooit James Gosling heb gelezen waarin staat dat je geen speciale instructies in de JVM nodig hebt, omdat statische methoden net zo snel zullen zijn, maar de bron niet kunnen vinden - dus het kan volledig zijn vals). Ja, dit is een micro-optimalisatie en waarschijnlijk onnodig. En wij programmeurs doen nooit onnodige dingen alleen omdat ze cool zijn, toch?

praktisch: In plaats van het nieuwe Util().method(arg) aan te roepen, roept u Util.method(arg) of method(arg) aan met een statische import. Makkelijker, kortom.

Methoden toevoegen: u wilde echt dat de klasse String een instantiemethode removeSpecialChars() had, maar deze bestaat niet (en dat zou ook niet moeten, aangezien de speciale tekens van uw project kunnen verschillen van een ander project), en u kunt deze niet toevoegen ( omdat Java vrij normaal is), dus je maakt een utility-klasse en roept removeSpecialChars(s) aan in plaats van s.removeSpecialChars() . Zoet.

Zuiverheid: Als u enkele voorzorgsmaatregelen neemt, zal uw statische methode een pure functie zijn. Het enige waar het van afhangt, zijn de parameters. Gegevens, gegevens. Het is gemakkelijker te lezen en te debuggen, omdat u zich geen zorgen hoeft te maken over overerving. U kunt dit ook doen met instantiemethoden, maar de compiler zal u iets meer helpen met statische methoden (niet toestaan dat naar instantiekenmerken wordt verwezen, methoden worden overschreven, enz.).

Je zult ook een statische methode moeten maken als je een singleton wilt maken, maar...doe dat niet. Ik bedoel, denk twee keer na.

Nu, nog belangrijker, waarom wil je geen statische methode maken? Eigenlijk, polymorfisme gaat uit het raam. U kunt een methode niet overschrijven en niet declareren in een interface (pre-Java 8). Dit vraagt veel flexibiliteit van je ontwerp. Ook, als je nodig hebt voorwaarde, je zult er veel krijgen gelijktijdigheid fouten en/of knelpunten als je niet oppast.

Na het lezen van de Misko-artikelen, geloof ik dat statische methoden slecht zijn vanuit een teststandpunt. In plaats daarvan zou u dit moeten hebben (mogelijk met behulp van een injectienesthulpmiddel zoals Guice).

Hoe kan ik ervoor zorgen dat ik er maar één van heb?

er is maar één van de problemen "hoe kan ik ervoor zorgen dat ik slechts één van de" mooi "ontwijkt. Je bent slechts een enkele ApplicationFactory in je hoofd aan het instantiëren, en als gevolg daarvan maak je alleen de hele instantie van je singlets aan .

Het grootste probleem met statische methoden is procedurele code

Het grootste probleem met statische methoden is dat ze procedurele code zijn. Ik heb geen idee voor een unit test procedure. Unit testing gaat ervan uit dat ik een deel van mijn applicatie geïsoleerd kan instantiëren. Tijdens het bouwen neem ik afhankelijkheden op met mocks/friendlies die echte afhankelijkheden vervangen. Met procedureel programmeren valt er niets te "routeren" omdat er geen objecten zijn, code en gegevens zijn gescheiden.
Een statische methode is een type methode waarvoor geen object hoeft te worden geïnitialiseerd om het te kunnen aanroepen. Is het je opgevallen dat static wordt gebruikt in de hoofdfunctie in Java? De uitvoering van het programma begint vanaf daar zonder een object te maken.

Beschouw het volgende voorbeeld:
Class Languages ( public static void main(String args) ( display(); ) static void display() ( System.out.println("Java is mijn favoriete programmeertaal."); ))
Statische methoden in Java bevinden zich in een klasse (geen instantie). Ze gebruiken geen instantievariabelen en nemen doorgaans invoer van parameters, voeren er bewerkingen op uit en retourneren vervolgens een resultaat. Instantiemethoden zijn gekoppeld aan objecten en kunnen, zoals de naam al doet vermoeden, instantievariabelen gebruiken.
Als u het statische sleutelwoord met een methode gebruikt, staat dit bekend als een statische methode.

Een statische methode behoort tot een klasse, niet tot een object van de klasse.

Een statische methode die wordt aangeroepen zonder dat er een instantie van de klasse hoeft te worden gemaakt.

een statische methode heeft toegang tot een statisch gegevenslid en kan de waarde ervan wijzigen.

// Programma voor het wijzigen van de gemeenschappelijke eigenschap van alle objecten (statisch veld).
Class Student9( int rollno; String naam; static String college = "ITS"; static void change()( college = "BBDIT"; ) Student9(int r, String n)(rollno = r; naam = n; ) void display ()(System.out.println(rollno+" "+name+" "+college);) public static void main(String args)( Student9.change(); Student9 s1 = new Student9 (111,"Indian"); Student9 s2 = nieuwe Student9 (222,"Amerikaans"); Student9 s3 = nieuwe Student9 (333,"China"); s1.display(); s2.display(); s3.display(); ) )
O/P: 111 Indiase BBDIT 222 Amerikaanse BBDIT 333 China BBDIT
Statische methoden zijn niet gekoppeld aan een instantie, dus ze hebben geen toegang tot niet-statische velden in de klasse.

U zou een statische methode gebruiken als de methode geen velden (of alleen statische velden) van de klasse gebruikt.

Als er niet-statische klassenvelden worden gebruikt, moet u een niet-statische methode gebruiken.
In feite gebruiken we statische eigenschappen en methoden in een klasse wanneer we een deel van ons programma willen gebruiken dat daar moet bestaan totdat ons programma wordt uitgevoerd. En we weten dat we statische methoden nodig hebben om statische eigenschappen te beheren, omdat ze geen deel uitmaken van een instantievariabele. En zonder statische methoden kost het beheren van statische eigenschappen veel tijd.
Statische methoden en variabelen zijn de beheerde "algemene" versie van functies en variabelen in Java. Welke methoden toegankelijk zijn als classname.methodName() of classInstanceName.methodName() , d.w.z. statische methoden en variabelen zijn toegankelijk met zowel de klassenaam als klasse-instanties.

Een klasse kan niet statisch worden verklaard (omdat het niet logisch is. Als een klasse openbaar is verklaard, is deze overal toegankelijk), innerlijke klassen kunnen statisch worden verklaard.
Statische methoden kunnen worden gebruikt als:

Het is niet nodig om een actie uit te voeren op een instantie (utility-methoden)

Zoals vermeld in verschillende van de bovenstaande antwoorden in dit bericht, het converteren van mijlen naar kilometers, of het berekenen van temperaturen van Fahrenheit naar Celsius en vice versa. In deze voorbeelden, met behulp van een statische methode, hoeft er geen geheel nieuw object in heapgeheugen te worden geïnstantieerd. Overweeg hieronder:

1. nieuwe ABCClass(dubbele farenheit).convertFarenheitToCelcium() 2. ABCClass.convertFarenheitToCelcium(dubbele farenheit)

de eerste creëert een nieuwe klasse voor elke methode, Prestaties, Praktisch. Voorbeelden zijn de Math-klasse en Apache-Commons StringUtils hieronder:

Math.random() Math.sqrt(dubbel) Math.min(int, int) StringUtils.isEmpty(String) StringUtils.isBlank(String)
Men wil gebruiken als een eenvoudige functie. De invoer wordt expliciet doorgegeven en ontvangt de resultaatgegevens als de retourwaarde. Overerving, objectinstallatie vindt niet plaats. kort, leesbaar.

Opmerking: Weinig mensen hebben bezwaar tegen het testen van statische methoden, maar statische methoden kunnen ook worden getest! Met jMockit is het mogelijk om statische methoden te bespotten. Testbaarheid. Voorbeeld hieronder:
nieuwe mockup () ( @Mock public int doSomething(Input input1, Input input2)( return returnValue; ));
Ik vraag me af wanneer ik statische methoden moet gebruiken?

De gebruikelijke manier om statische methoden te gebruiken, is door toegang te krijgen tot statische velden.

Maar u kunt statische methoden gebruiken zonder naar statische variabelen te verwijzen. Hulpmethoden zonder een statische variabeleverwijzing zijn te vinden in sommige Java-klassen, zoals:

public static int min(int a, int b) ( return (a<= b) ? a: b; }

De andere manier waarop ik deze methoden in combinatie met de gesynchroniseerde methode kan bedenken, is de implementatie van vergrendeling op klasseniveau in een omgeving met meerdere threads.

Laten we zeggen dat als ik een klasse heb met meerdere getters en setters, een of twee methoden, en ik wil dat die methoden alleen kunnen worden aangeroepen voor een instantieobject van de klasse. Betekent dit dat ik een statische methode moet gebruiken?

De statische modifier in Java is direct gerelateerd aan de klasse, als het veld statisch is, dan behoort het tot de klasse, als de methode statisch is, behoort het op dezelfde manier tot de klasse. Op basis hiervan kunt u verwijzen naar een statische methode of veld met behulp van de klassenaam. Als het count-veld bijvoorbeeld statisch is in de klasse Counter, kunt u de variabele openen met een query als: Counter.count . Natuurlijk moeten toegangsmodificatoren worden overwogen. Privévelden zijn bijvoorbeeld alleen beschikbaar binnen de klasse waarin ze zijn gedeclareerd. Beveiligde velden zijn beschikbaar voor alle klassen binnen het pakket ( pakket), evenals alle afstammelingenklassen buiten het pakket. Zie voor meer informatie het artikel “privé vs beschermd vs openbaar”. Stel dat er een statische methode increment() in de klasse Counter is, wiens taak het is om de counter counter te verhogen. Om deze methode aan te roepen, kunt u een aanroep gebruiken zoals Counter.increment() . Het is niet nodig om een instantie van de klasse Counter te maken om toegang te krijgen tot een statisch veld of methode. Dit is het fundamentele verschil tussen statische en NIET-statische objecten (klasseleden). Belangrijke notitie. Vergeet niet dat statische klasleden rechtstreeks tot de klas behoren, niet tot een instantie ervan. Dat wil zeggen dat de waarde van het aantal statische variabelen hetzelfde zal zijn voor alle objecten van het type Teller . In dit artikel zullen we kijken naar de fundamentele aspecten van het gebruik van de statische modifier in Java, evenals naar enkele functies die u zullen helpen de belangrijkste programmeerconcepten te begrijpen.

Wat elke programmeur zou moeten weten over de statische modifier in Java.

In deze sectie behandelen we de belangrijkste punten van het gebruik van statische methoden, velden en klassen. Laten we beginnen met variabelen.

Je hebt GEEN toegang tot niet-statische leden van een klasse, binnen een statische context, zoals een methode of blok. Het compileren van de onderstaande code zal resulteren in een fout:

Dit is een van de meest voorkomende fouten van Java-programmeurs, vooral beginners. Aangezien de main-methode statisch is en de count-variabele niet, zal in dit geval de println-methode binnen de main-methode een "Compile time error" genereren.

In tegenstelling tot lokale variabelen zijn statische velden en methoden NIET thread-safe in Java. In de praktijk is dit een van de meest voorkomende redenen voor het ontstaan van problemen met betrekking tot de veiligheid van multithreaded programmeren. Aangezien elke klasse-instantie dezelfde kopie van een statische variabele heeft, moet een dergelijke variabele worden beschermd - "vergrendeld" door de klasse. Zorg er daarom bij het gebruik van statische variabelen voor dat ze goed zijn gesynchroniseerd om problemen zoals race-omstandigheden te voorkomen.

Statische methoden hebben een voordeel bij de toepassing, omdat. het is niet nodig om elke keer een nieuw object te maken om toegang te krijgen tot dergelijke methoden. Een statische methode kan worden aangeroepen met behulp van het klassetype waarin deze methoden zijn gedeclareerd. Daarom zijn dergelijke methoden het meest geschikt als fabrieksmethoden (fabriek) en gebruiksmethoden (utility). De klasse java.lang.Math is een goed voorbeeld waarbij bijna alle methoden statisch zijn, wat dezelfde reden is waarom Java-hulpprogrammaklassen worden voltooid.

Een ander belangrijk punt is dat u statische methoden NIET kunt overschrijven (Overschrijven). Als u dezelfde methode declareert in een subklasse, d.w.z. methode met dezelfde naam en handtekening, zult u de superklassemethode alleen "verbergen" in plaats van deze te overschrijven. Dit fenomeen staat bekend als verbergmethoden. Dit betekent dat bij toegang tot een statische methode die is gedeclareerd in zowel de ouder- als de kindklasse, de methode altijd wordt aangeroepen tijdens het compileren op basis van het type variabele. In tegenstelling tot overschrijven, worden dergelijke methoden niet uitgevoerd terwijl het programma draait. Overweeg een voorbeeld:

"Binnen bovenliggende klasse/statische methode"

"Binnen kindklasse/statische methode"

Console-uitgang:

Binnen bovenliggende klasse/statische methode

De code laat duidelijk zien dat ondanks dat het object van het type Car is, een statische methode uit de klasse Vehicle wordt aangeroepen, omdat de methode werd aangeroepen tijdens het compileren. En merk op dat er geen compile-time fout was!

U kunt een klasse ook statisch verklaren, behalve voor klassen op het hoogste niveau. Dergelijke klassen staan bekend als geneste statische klassen. Ze zijn handig voor het presenteren van verbeterde links. Een goed voorbeeld van een geneste statische klasse is HashMap.Entry, die een gegevensstructuur biedt binnen een HashMap. Het is vermeldenswaard dat, net als elke andere innerlijke klasse, geneste klassen zich in een apart .class-bestand bevinden. Dus als je vijf geneste klassen in je hoofdklasse hebt gedeclareerd, zou je 6 .class-bestanden hebben. Een andere use-case is het declareren van uw eigen Comparator, zoals de AgeComparator in de klasse Werknemer.

De statische modifier kan ook worden gedeclareerd in een statisch blok, beter bekend als een "Statisch initialisatieblok", dat wordt uitgevoerd tijdens het laden van de klas. Als u zo'n blok niet declareert, verzamelt Java alle statische velden in één lijst en voert deze uit tijdens het laden van de klasse. Een statisch blok kan echter GEEN gevangen uitzonderingen gooien, maar het kan niet-afgevangen uitzonderingen gooien. In een dergelijk geval zal een "Exception Initializer Error" optreden. In de praktijk wordt elke uitzondering die tijdens runtime en initialisatie van statische velden wordt gegenereerd, door Java in deze fout verpakt. Dit is ook de meest voorkomende oorzaak van de fout "No Class Def Found Error". de klasse was niet in het geheugen op het moment dat deze werd geopend.

Het is handig om te weten dat statische methoden gebonden zijn tijdens het compileren, in tegenstelling tot de binding van virtuele of niet-statische methoden, die tijdens runtime gebonden zijn aan het echte object. Daarom kunnen statische methoden niet worden overschreven in Java, zoals: runtime polymorfisme is niet op hen van toepassing. Dit is een belangrijke beperking om in gedachten te houden bij het declareren van een methode als statisch. Dit heeft alleen zin als het niet mogelijk of nodig is om een dergelijke methode te overschrijven door afstammelingenklassen. Fabrieksmethoden en hulpprogramma's zijn goede voorbeelden van de statische modifier. Joshua Bloch benadrukte verschillende voordelen van het gebruik van een statische fabrieksmethode ten opzichte van een constructor in Effective Java, een boek dat elke Java-programmeur moet lezen.

Een belangrijke eigenschap van een statisch blok is initialisatie. Statische velden of variabelen worden geïnitialiseerd nadat de klasse in het geheugen is geladen. De initialisatievolgorde is van boven naar beneden, in dezelfde volgorde als beschreven in het Java-klassebronbestand. Omdat statische velden op een threadveilige manier worden geïnitialiseerd, wordt deze eigenschap ook gebruikt om het Singleton-patroon te implementeren. Als je om de een of andere reden een Enum-lijst niet als Singleton gebruikt, dan is er een goed alternatief voor jou. Maar in dit geval moet er rekening mee worden gehouden dat dit geen "luie" initialisatie is. Dit betekent dat het statische veld zal worden geïnitialiseerd VOORDAT iemand erom "vraagt". Als het object veel resources nodig heeft of zelden wordt gebruikt, zal het initialiseren ervan in een statisch blok niet in uw voordeel werken.

Tijdens serialisatie worden statische velden, net als tijdelijke variabelen, niet geserialiseerd. Inderdaad, als u gegevens in een statisch veld opslaat, zal het nieuwe object na deserialisatie zijn primaire (standaard) waarde bevatten, bijvoorbeeld als het statische veld een variabele van het type int was, dan is de waarde na deserialisatie nul , als type float 0.0 is , als het type Object null is . Eerlijk gezegd is dit een van de meest gestelde vragen over serialisatie in Java-interviews. Bewaar de belangrijkste gegevens over een object niet in een statisch veld!

En tot slot, laten we het hebben over statische import . Deze modifier heeft veel gemeen met de standaard import-instructie, maar anders dan deze, kun je een of alle statische leden van de klasse importeren. Bij het importeren van statische methoden zijn ze toegankelijk alsof ze in dezelfde klasse zijn gedefinieerd, net zoals we bij het importeren van velden toegang hebben zonder de klassenaam op te geven. Deze functie is geïntroduceerd in Java versie 1.5 en verbetert bij correct gebruik de leesbaarheid van de code. Dit ontwerp wordt het vaakst gevonden in tests JUnit, omdat bijna alle testontwikkelaars gebruiken statische import voor assert-methoden zoals assertEquals() en hun overbelaste tegenhangers. Als niets duidelijk is - welkom voor meer informatie.

Dat is alles. Alle bovenstaande punten over de modifier statisch Elke programmeur zou Java moeten kennen. Dit artikel bevatte basisinformatie over statische variabelen, velden, methoden, initialisatieblokken en import. Inclusief enkele belangrijke eigenschappen, waarvan de kennis van cruciaal belang is bij het schrijven en begrijpen van Java-programma's. Ik hoop dat elke ontwikkelaar zijn vaardigheden zal perfectioneren om statische concepten tot in de perfectie te gebruiken. dit is erg belangrijk voor serieus programmeren."

De statische kan zijn:

Laten we eerst kijken naar statische variabelen en statische methoden.

Wat is een statische variabele in Java?

Statische variabele in Java is een variabele die tot de klasse behoort en slechts één keer wordt geïnitialiseerd aan het begin van de uitvoering.

Het is een variabele die tot de klasse behoort en niet tot object (instantie)
Statische variabelen worden slechts eenmaal geïnitialiseerd, aan het begin van de uitvoering. Deze variabelen worden eerst geïnitialiseerd, voordat eventuele instantievariabelen worden geïnitialiseerd
Een enkele kopie die door alle instanties van de klas moet worden gedeeld
Een statische variabele is direct toegankelijk via de klassenaam en heeft geen object nodig

<klasnaam>.

Wat is een statische methode in Java?

Statische methode in Java is een methode die bij de klasse hoort en niet bij het object. Een statische methode heeft alleen toegang tot statische gegevens.

Het is een methode die bij de klasse hoort en niet bij het object (instantie)
Een statische methode heeft alleen toegang tot statische gegevens. Het heeft geen toegang tot niet-statische gegevens (instantievariabelen)
Een statische methode kan alleen andere statische methoden aanroepen en kan er geen niet-statische methode van aanroepen.
Een statische methode is direct toegankelijk via de klassenaam en heeft geen object nodig
Een statische methode kan hoe dan ook niet verwijzen naar "dit" of "super" trefwoorden

<klasnaam>.

Opmerking: main methode is statisch, omdat het toegankelijk moet zijn voor een toepassing om te worden uitgevoerd, voordat er een instantie wordt gestart.

Laten we de nuances van de statische trefwoorden leren door enkele oefeningen te doen!

Voorbeeld: Hoe statische variabelen en methoden aan te roepen

Stap 1) Kopieer de volgende code naar een editor

Public class Demo( public static void main(String args)( Student s1 = new Student(); s1.showData(); Student s2 = new Student(); s2.showData(); //Student.b++; //s1 .showData(); ) ) class Student ( int a; // geïnitialiseerd naar nul static int b; // alleen geïnitialiseerd naar nul wanneer klasse wordt geladen, niet voor elk gemaakt object. Student()( //Constructor die statische variabele b b++ verhoogt ; ) public void showData()( System.out.println("Waarde van a = "+a); System.out.println("Waarde van b = "+b); ) //public static void increment()( //a++; //) )

Stap 2) Bewaar en compileer de code. voer de code uit als java-demo.

Stap 3) Verwachte output toon hieronder:

Het volgende diagram laat zien hoe referentievariabelen en objecten worden gemaakt en statische variabelen worden benaderd door de verschillende instanties.

Stap 4) Het is mogelijk om toegang te krijgen tot een statische variabele van buiten de klasse met behulp van de syntaxis ClassName.Variable_Name. Uncomment regel # 7 & 8 . Opslaan, compileren en uitvoeren. de uitvoer observeren.

Waarde van a = 0 Waarde van b = 1 Waarde van a = 0 Waarde van b = 2 Waarde van a = 0 Waarde van b = 3 Stap 5) Uncomment regel 25,26 & 27. Opslaan, compileren en uitvoeren.
fout: niet-statische variabele a kan niet worden verwezen vanuit een statische context a++;

stap 6) fout = ? Dit komt omdat het niet mogelijk is om toegang te krijgen tot instantievariabele " een" van java statische klassenmethode " increment".

Statisch Java-blok

Het statische blok is een instructieblok binnen een Java-klasse die wordt uitgevoerd wanneer een klasse voor het eerst in de JVM wordt geladen

Class Test (statisch (//Code komt hier))

EEN statisch blok helpt bij het initialiseren van de statische gegevensleden, net zoals constructors helpen om instantieleden te initialiseren

Statische typemethoden is een taalomgevingstool die is geïmplementeerd om met statische gegevensleden te werken. Dergelijke methoden kunnen voorwaardelijk in twee typen worden verdeeld:

statische methoden in statische klassen;

statische methoden in niet-statische klassen.

Als een programmeur een klasse als statisch verklaart, worden alle leden van die klasse statisch, inclusief methoden. Dit zijn methoden van klassen - containers met instructies, ze accepteren objecten van andere typen voor verwerking en geven de waarde aan van het type dat de programmeur nodig heeft.

Het meest voorkomende geval is wanneer de programmeur een instructieblok moet implementeren dat onafhankelijk is van het typeobject. Dit instructieblok is een statische methode, omdat het wordt aangeroepen voordat een instantie van het type wordt gemaakt.

Een statische methode declareren en aanroepen

Een methode wordt statisch verklaard door het statische sleutelwoord te gebruiken voor het retourtype in de class-scoped methodedefinitie:

Public class Somenonstaticclass ( // Declare static fields. static int firststaticfield; static string secondstaticfield; // Declare non-static fields. double firstnonstaticfield; float secondnonstaticfield; // Declareer een statische methode. static void FirstStaticMethod() ( // Implementatie van een statische methode.Console.WriteLine(firststaticfield);Console.WriteLine(secondstaticfield);) )

De programmeur kan een statische methode aanroepen via de naam van het type waarin deze is gedefinieerd:

Klasse UseStaticMethods ( static void Main() ( // Roep een statische methode aan via de typenaam. Somenonstaticclass.FirstStaticMethod(); ) )

Gebruiksbeperkingen

Statische methoden nemen niet deel aan overerving. Ze zijn verzegeld. Ze kunnen alleen worden overbelast, niet overschreven. De beperking komt tot uiting in het feit dat statische methoden behoren tot de klasse waarin ze zijn gedefinieerd, niet-statische methoden - tot het klasseobject.

Public class Somenonstaticclass ( // Declareer de statische velden van de klasse. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Declareer een statische methode. static void FirstStaticMethod() ( // Implementatie van de statische methode. Console .WriteLine(firststaticfield);Console.WriteLine(secondstaticfield); ) // Overschrijf de methode FirstStaticMethod() static int FirstStaticMethod(string a) (Console.WriteLine("Het ingevoerde methodeargument is output: "+a); ) )

Alleen statische leden zijn beschikbaar voor statische methoden van een niet-statische klasse in het implementatieblok. U kunt geen niet-statische leden gebruiken in statische methoden:

Public class Somenonstaticclass ( // Declareer de statische velden van de klasse. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Declareer een statische methode. static void FirstStaticMethod() ( // Implementatie van de statische methode. Console .WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); Console.WriteLine(firstnonstaticfield); // De regel veroorzaakt een compilatiefout omdat een niet-statisch lid binnen een statisch lid wordt gebruikt. ) )

Methode verklaring.

Onderwerp 9. Methoden

Zoals eerder opgemerkt, ondersteunt C# een groot aantal lidfuncties die verschillende namen hebben en verschillende doelen dienen. Ze bevatten echter allemaal blokken met instructies die worden uitgevoerd wanneer ze worden aangeroepen op precies dezelfde manier als voor een standaardmethode.

Methoden kunnen worden onderverdeeld in twee hoofdgroepen: instantie methoden(gedefinieerd zonder trefwoord statisch) die behoren tot de instantiefunctiegroep en statische methoden met het trefwoord statisch, die behoren tot de groep van statische functies.

Een instantiemethode wordt uitgevoerd op een bepaald object, terwijl een statische methode wordt uitgevoerd op een klasse, dus wanneer deze laatste wordt aangeroepen, wordt de naam van de klasse gebruikt, niet het object. Alle objecten van dezelfde klasse delen dezelfde kopie van een instantie methode.

Een methodedefinitie bestaat uit een koptekst en een methodelichaam. De header specificeert belangrijke attributen die bepalen hoe andere delen van het programma toegang krijgen tot de methode. De body van een methode bestaat uit instructies die worden uitgevoerd wanneer deze wordt aangeroepen.

Het toegangsniveau van een methode wordt bepaald door een optionele specificatie in de kop.

Twee van de mogelijke specificaties zijn tot nu toe gebruikt: openbaar En privaat, public geeft aan dat elk deel van het programma toegang heeft tot de methode, a privaat beperkt het gebruik ervan buiten de klas.

Laten we een syntactisch blok geven van de methodetoepassing.

Methode::=

<3аголовок_метода>

<Тело_метода>

<3аголовок_метода>::=[<Спецификаторы_метода>] <Тип_возвращаемого_значения> <Идентификатор метода> ([<Список_формальных_параметров>])

< Тело_метода>: :=

<Операторы>

<Спецификаторы_метода>

::=<Спецификатор_доступности>

<Спецификатор_доступности>

::= openbaar

::= privaat

<Тип_возвращаемого_значения>

::= <Тип>

Een methodeaanroep bestaat uit de naam gevolgd door een paar haakjes met een lijst van argumenten, de laatste moet overeenkomen met de lijst met formele parameters die in de methodekop is gedefinieerd.

Geef een voorbeeld.

Het is bekend dat de uitvoering van een programma in de .NET-omgeving begint met een aanroep van de Main()-methode. De runtime maakt geen objecten, dus Main() moet onafhankelijk van hen worden aangeroepen. Het declareren van de methode Main() als statisch geeft aan dat deze tot de klasse behoort. Dus de runtime roept Main() rechtstreeks aan via de klassenaam.

Een statische methode kan op drie manieren worden aangeroepen:

1. Van het object van de klasse waartoe het behoort. In dit geval is het voorvoegsel (klasse- of objectnaam) niet nodig.

openbare statische leegte Gemiddeld(...)

2. Van buiten de gegeven klas.

In dit geval zijn er twee mogelijkheden:

1. Als er een object is van de klasse waarin de methode is gedefinieerd, bestaat de aanroep naar de laatste uit de naam van het object, de verfijningsbewerking en de naam van de methode:

mijnKlasse A = nieuwe mijnKlasse();

2. Ongeacht het bestaan van objecten van de klasse waarin de methode is gedefinieerd, wordt deze voor de klasse aangeroepen via de verfijningsbewerking:

MijnKlasse.Gemiddeld(...)...

In de methodeaanroep verdient het de voorkeur om de klassenaam (myClass.Average(...)) te gebruiken in plaats van het object A.Average(...) omdat de eerste optie duidelijk aangeeft dat er een statische methode wordt aangeroepen.