10 dingen die u moet weten over de statische modifier in Java

In Java betekent de statische modifier dat iets direct gerelateerd is aan een klasse: als een veld statisch is, dan behoort het tot de klasse; als een methode statisch is, behoort deze tot de klasse. Hierdoor kunt u de naam van de klasse gebruiken om een ​​statische methode aan te roepen of naar een statisch veld te verwijzen. Als het countveld bijvoorbeeld statisch is in de Counterklasse, betekent dit dat u naar de variabele kunt verwijzen met de volgende uitdrukking: Counter.count. Natuurlijk moet er rekening worden gehouden met toegangsmodificatoren. Velden zijn bijvoorbeeld privatealleen beschikbaar binnen de klasse waarin ze zijn gedeclareerd. En protectedvelden zijn beschikbaar voor alle klassen binnen een pakket, evenals voor al hun subklassen buiten het pakket. Stel dat de Counterklasse een statische increment()methode heeft waarvan het de taak is om decountveld. Om deze methode aan te roepen, kunt u Counter.increment(). Het is niet nodig om een ​​instantie van de Counterklasse te maken om toegang te krijgen tot een statisch veld of een statische methode. Dit is het fundamentele verschil tussen statische (klasse) variabelen en methoden en NIET-statische (instance) variabelen en methoden. Een belangrijke opmerking. Vergeet niet dat de statische leden van de klasse rechtstreeks tot de klasse behoren, niet tot een instantie van de klasse. Dat wil zeggen, de waarde van de statische countvariabele zal voor alle objecten hetzelfde zijn Counter. In dit artikel bekijken we de fundamentele aspecten van het gebruik van de statische modifier in Java, evenals enkele functies die u helpen de belangrijkste programmeerconcepten te begrijpen.

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

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

1. U kunt GEEN toegang krijgen tot niet-statische leden van een klasse binnen een statische context, zoals een statische methode of blok. Het compileren van de onderstaande code resulteert in een fout:

   
   public class Counter {
   private int count;
   public static void main(String args []) {
      System.out.println(count); //  Compile time error
   }
   }
   

   Dit is een van de meest gemaakte fouten door Java-programmeurs, vooral nieuwelingen. Aangezien de mainmethode statisch is en de countvariabele niet, zal het gebruik van de printlnmethode binnen de mainmethode een "compileertijdfout" opleveren.

2. In tegenstelling tot lokale variabelen zijn statische velden en methoden NIET thread safein Java. In de praktijk is dit een van de meest voorkomende oorzaken van beveiligingsproblemen bij multi-threaded programmeren. Aangezien elke instantie van een klasse verwijst naar dezelfde kopie van een statische variabele, moet een dergelijke variabele worden beschermd of "vergrendeld" door de klasse. Zorg er daarom bij het gebruik van statische variabelen voor dat ze correct zijn synchronizedom problemen zoals race conditions.

3. Statische methoden hebben een praktisch voordeel omdat het niet nodig is om elke keer dat u ze wilt aanroepen een nieuw object te maken. Een statische methode kan worden aangeroepen met de naam van de klasse die deze declareert. Daarom zijn deze methoden perfect voor factorymethoden en utilitymethoden. De java.lang.Mathklasse is een prachtig voorbeeld: bijna al zijn methoden zijn statisch. De hulpprogrammaklassen van Java zijn finalom dezelfde reden gemarkeerd.

4. Een ander belangrijk punt is dat u ( ) statische methoden niet kunt overschrijven @Override. Als je zo'n methode declareert in een subclass, dwz een methode met dezelfde naam en handtekening, "verberg" je gewoon de methode van de superclassin plaats van deze te overschrijven. Dit fenomeen staat bekend als method hiding. Dit betekent dat als een statische methode wordt gedeclareerd in zowel de bovenliggende als de onderliggende klassen, de aangeroepen methode altijd gebaseerd zal zijn op het type variabele tijdens het compileren. In tegenstelling tot het overschrijven van methoden, worden dergelijke methoden niet uitgevoerd wanneer het programma wordt uitgevoerd. Laten we een voorbeeld bekijken:

   
   class Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the parent class / static method");
        } 
   }
   
   class Car extends Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the child class / static method");
        } 
   }
   
   public class Demo {   
      public static void main(String args []) {
         Vehicle v = new Car();
          v.kmToMiles(10);
     }
   }
   

   Console-uitvoer:

   Binnen de bovenliggende klasse / statische methode

   De code laat duidelijk zien dat ondanks het feit dat het object een is Car, de statische methode in de Vehicleklasse wordt aangeroepen, aangezien de methode werd aangeroepen tijdens het compileren. En merk op dat er geen compilatiefouten waren!

5. Bovendien kunt u, behalve klassen op het hoogste niveau, klassen statisch declareren. Dergelijke klassen staan ​​bekend als nested static classes. Ze zijn nuttig voor een betere samenhang. Een treffend voorbeeld van een geneste statische klasse is HashMap.Entry, wat een datastructuur is binnenin HashMap. Het is vermeldenswaard dat, net als interne klassen, statische geneste klassen worden gedeclareerd in een afzonderlijk .class-bestand. Dus als u vijf geneste klassen declareert in uw hoofdklasse, heeft u zes bestanden met de extensie .class. Een ander voorbeeld is de eigen aangifte Comparator, zoals een leeftijdsvergelijker ( AgeComparator) in de Employeeklas.

6. De statische modifier kan ook worden opgegeven in een statisch blok, beter bekend als een "statisch initialisatieblok", dat wordt uitgevoerd wanneer de klasse wordt geladen. Als u zo'n blok niet declareert, verzamelt Java alle statische velden in een enkele lijst en initialiseert deze wanneer de klasse wordt geladen. Een statisch blok KAN GEEN aangevinkte uitzonderingen genereren, maar wel ongecontroleerde uitzonderingen. In dit geval ExceptionInInitializerErrortreedt er een testament op. In de praktijk wordt elke uitzondering die optreedt tijdens de initialisatie van statische velden door Java in deze fout verpakt. Dit is ook de meest voorkomende oorzaak van de NoClassDefFoundError, omdat de klasse zich niet in het geheugen bevindt wanneer ernaar wordt verwezen.

7. Het is handig om te weten dat statische methoden tijdens het compileren worden gekoppeld, in tegenstelling tot het koppelen van virtuele of niet-statische methoden, die tijdens runtime worden gekoppeld wanneer ze op een echt object worden aangeroepen. Dienovereenkomstig kunnen statische methoden in Java niet worden overschreven, aangezien polymorfisme tijdens runtime niet op hen van toepassing is. Dit is een belangrijke beperking waarmee rekening moet worden gehouden bij het declareren van een methode statisch. Dit heeft alleen zin als er geen mogelijkheid of noodzaak is om de methode in een subklasse te overschrijven. Fabrieksmethoden en gebruiksmethoden zijn goede voorbeelden van correct gebruik van de statische modifier. Joshua Bloch wijst op verschillende voordelen die statische fabrieksmethoden hebben ten opzichte van constructeurs in zijn boek Effective Java, dat verplichte lectuur is voor elke Java-programmeur.

8. Initialisatie is een belangrijk aspect van een statisch blok. Statische velden of variabelen worden geïnitialiseerd nadat de klasse in het geheugen is geladen. De volgorde van initialisatie is van boven naar beneden, in dezelfde volgorde waarin ze zijn gedeclareerd in het bronbestand van de Java-klasse. Aangezien statische velden op een threadveilige manier worden geïnitialiseerd, wordt dit proces ook gebruikt om het Singletonpatroon te implementeren. Als je om wat voor reden dan ook geen Enumas a gebruikt Singleton, dan heb je een goed alternatief. Maar in dit geval moet u er rekening mee houden dat dit geen "luie" initialisatie is. Dit betekent dat het statische veld al wordt geïnitialiseerd VOORDAT iemand erom "vraagt". Als een object veel resources bevat of zelden wordt gebruikt, zal het niet in uw voordeel werken om het in een statisch blok te initialiseren.

9. Tijdens serialisatie transientworden statische velden, zoals variabelen, niet geserialiseerd. Als u gegevens opslaat in een statisch veld, bevat het inderdaad de initiële (standaard) waarde na deserialisatie. Als een statisch veld bijvoorbeeld een is int, is de waarde nul na deserialisatie. Als het type is float, is de waarde 0,0. Als het veld een is Object, is de waarde null. Eerlijk gezegd is dit een van de meest gestelde vragen over serialisatie in sollicitatiegesprekken voor Java-functies. Bewaar essentiële objectgegevens niet in een statisch veld!

10. Laten we het tot slot hebben over statische import. Deze modifier heeft veel gemeen met de standaardverklaring import, maar is anders omdat u hiermee een of alle statische klassenleden kunt importeren. Zodra statische methoden zijn geïmporteerd, zijn ze toegankelijk alsof ze in dezelfde klasse zijn gedeclareerd. Evenzo kunnen we door statische velden te importeren deze openen zonder de klassenaam op te geven. Deze functie verscheen in Java 1.5 en verbetert de leesbaarheid van code bij correct gebruik. Deze constructie wordt het vaakst gevonden in JUnit-tests, aangezien bijna alle testontwikkelaars statische import gebruiken voor assert-methoden, bijvoorbeeld assertEquals()en hun overbelaste varianten.

11. Dat is het voor nu. Elke Java-programmeur moet alle aspecten van de hierboven genoemde statische modifier kennen. Dit artikel besprak basisinformatie over statische variabelen, velden, methoden, initialisatieblokken en import. Het ging ook in op enkele belangrijke eigenschappen die essentieel zijn om Java-programma's te kunnen schrijven en begrijpen. Ik hoop dat elke ontwikkelaar zijn bekwame gebruik van statische leden zal perfectioneren, omdat het erg belangrijk is voor serieuze softwareontwikkeling."