Er kunnen momenten zijn dat het nuttig is om waarden te hebben die worden gedeeld door alle instanties van een bepaalde klasse. Statische velden en statische constanten schakel dit type delen in door tot de klasse en niet naar de daadwerkelijke objecten.
De statische modifier
Normaal gesproken kunnen velden en methoden die in een klasse zijn gedefinieerd, alleen worden gebruikt als er een object van dat klassetype is gemaakt. Overweeg bijvoorbeeld een eenvoudige itemklasse die goederen in een winkel bijhoudt:
item van openbare klasse {
private String itemName;
openbaar item (String itemName)
{
this.itemName = itemName;
}
openbare String getItemName ()
{
itemnaam retourneren;
}
}
Om de methode getItemName () te kunnen gebruiken, moeten we eerst een object Item maken, in dit geval catFood:
openbare klasse StaticExample {
openbare statische leegte main (String [] args) {
Item catFood = nieuw item ("Whiskas");
System.out.println (catFood.getItemName ());
}
}
Als de statische modifier echter is opgenomen in een veld- of methodedeclaratie, is geen enkele instantie van de klasse dat vereist om het veld of de methode te gebruiken - ze zijn geassocieerd met de klas en niet met een individu voorwerp. Als je terugkijkt op het bovenstaande voorbeeld, zul je zien dat de statische modifier al wordt gebruikt in de
verklaring van de belangrijkste methode: openbaar statisch void main (String [] args) {
De belangrijkste methode is een statische methode daarvoor is geen object nodig voordat het kan worden aangeroepen. Omdat main () het startpunt is voor elke Java-toepassing, zijn er in feite geen objecten die het kunnen aanroepen. Je zou dit kunnen doen als je zin hebt in een programma dat zichzelf voortdurend noemt:
openbare klasse StaticExample {
openbare statische leegte main (String [] args) {
String [] s = {"random", "string"};
StaticExample.main (s);
}
}
Niet erg handig, maar merk op hoe de methode main () kan worden aangeroepen zonder een instantie van een StaticExample-klasse.
Wat is een statisch veld?
Statische velden worden ook wel klassenvelden genoemd. Het zijn gewoon velden met de statische modificatie in hun verklaringen. Laten we bijvoorbeeld teruggaan naar de klasse Item en een statisch veld toevoegen:
item van openbare klasse {
// statisch veld uniqueId
private static int uniqueId = 1;
privé int itemId;
private String itemName;
openbaar item (String itemName)
{
this.itemName = itemName;
itemId = uniqueId;
uniqueId ++;
}
}
De velden itemId en itemName zijn normale niet-statische velden. Wanneer een instantie van een itemklasse wordt gemaakt, hebben deze velden waarden die binnen dat object worden bewaard. Als er een ander Item-object wordt gemaakt, heeft het ook de velden itemId en itemName voor het opslaan van waarden.
Het statische veld uniqueId heeft echter een waarde die voor alle Item-objecten hetzelfde zal zijn. Als er 100 itemobjecten zijn, zijn er 100 instanties van de velden itemId en itemName, maar slechts één statisch uniqueId-veld.
In het bovenstaande voorbeeld wordt uniqueId gebruikt om elk Item-object een uniek nummer te geven. Dit is eenvoudig te doen als elk Item-object dat wordt gemaakt de huidige waarde in het unieke statische veld id neemt en vervolgens met één verhoogt. Het gebruik van een statisch veld betekent dat elk object niet over de andere objecten hoeft te weten om een te krijgen unieke ID. Dit kan handig zijn als u de volgorde wilt weten waarin de Item-objecten zijn gemaakt.
Wat is een statische constante?
Statische constanten lijken precies op statische velden, behalve dat hun waarden niet kunnen worden gewijzigd. In de veldaangifte is de laatste en statisch modifiers worden beide gebruikt. Misschien moet de klasse Item bijvoorbeeld een beperking opleggen aan de lengte van de itemName. We kunnen een statische constante maxItemNameLength maken:
item van openbare klasse {
privé statische int id = 1;
openbare statische uiteindelijke int maxItemNameLength = 20;
privé int itemId;
private String itemName;
openbaar item (String itemName)
{
if (itemName.length ()> maxItemNameLength)
{
this.itemName = itemName.substring (0,20);
}
anders
{
this.itemName = itemName;
}
itemId = id;
id ++;
} }
Net als bij statische velden worden statische constanten eerder aan de klasse gekoppeld dan aan een afzonderlijk object:
openbare klasse StaticExample {
openbare statische leegte main (String [] args) {
Item catFood = nieuw item ("Whiskas");
System.out.println (catFood.getItemName ());
System.out.println (Item.maxItemNameLength);
}
}
Er zijn twee belangrijke dingen die u moet opmerken over de statische constante maxItemNameLength:
- Het is verklaard als een openbaar veld. Over het algemeen is het een slecht idee om een veld openbaar te maken in elke klasse die u ontwerpt, maar in dit geval maakt het niet uit. De waarde van de constante kan niet worden gewijzigd.
- De statische constante wordt gebruikt vanuit de klassenaam Item, niet een Item-object.
Statische constanten zijn overal in de Java API te zien. Bijvoorbeeld de integer wrapper class heeft er twee die de maximum- en minimumwaarden an int opslaan data type kunnen hebben:
System.out.println ("De maximale waarde voor int is:" + Integer. MAXIMUM WAARDE);
System.out.println ("De minimumwaarde voor int is:" + Integer. MIN_VALUE);
Uitgang:
De maximale waarde voor int is: 2147483647
De min-waarde voor int is: -2147483648