Er zijn me verschillende definities voor verteld, ik heb op Wikipedia gekeken, maar als beginner van Java weet ik nog steeds niet wat het betekent. Iemand vloeiend in Java?
Antwoord 1, autoriteit 100%
statisch betekent dat de variabele of methode die als zodanig is gemarkeerd, beschikbaar is op klasseniveau. Met andere woorden, u hoeft geen instantie van de klasse te maken om er toegang toe te krijgen.
public class Foo {
public static void doStuff(){
// does stuff
}
}
Dus, in plaats van een instantie van Foo te maken en vervolgens doStuffals volgt aan te roepen:
Foo f = new Foo();
f.doStuff();
Je roept de methode gewoon rechtstreeks tegen de klasse aan, zoals zo:
Foo.doStuff();
Antwoord 2, autoriteit 14%
In zeer lekentermen is de klasse een mal en het object is de kopie die met die mal is gemaakt. Statisch hoort bij de mal en is direct toegankelijk zonder kopieën te maken, vandaar het bovenstaande voorbeeld
Antwoord 3, autoriteit 6%
Het statische sleutelwoord kan op verschillende manieren in Java worden gebruikt en in bijna alle gevallen is het een modifier, wat betekent dat het ding dat het aanpast bruikbaar is zonder een omsluitende objectinstantie.
Java is een objectgeoriënteerde taal en standaard vereist de meeste code die u schrijft een instantie van het object dat moet worden gebruikt.
public class SomeObject {
public int someField;
public void someMethod() { };
public Class SomeInnerClass { };
}
Om someField, someMethod of SomeInnerClass te gebruiken moet ik eerst een instantie van SomeObject maken.
public class SomeOtherObject {
public void doSomeStuff() {
SomeObject anInstance = new SomeObject();
anInstance.someField = 7;
anInstance.someMethod();
//Non-static inner classes are usually not created outside of the
//class instance so you don't normally see this syntax
SomeInnerClass blah = anInstance.new SomeInnerClass();
}
}
Als ik die dingen statisch verklaar, dan hebben ze geen omsluitende instantie nodig.
public class SomeObjectWithStaticStuff {
public static int someField;
public static void someMethod() { };
public static Class SomeInnerClass { };
}
public class SomeOtherObject {
public void doSomeStuff() {
SomeObjectWithStaticStuff.someField = 7;
SomeObjectWithStaticStuff.someMethod();
SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass();
//Or you can also do this if your imports are correct
SomeInnerClass blah2 = new SomeInnerClass();
}
}
Het verklaren van iets statisch heeft verschillende implicaties.
Ten eerste, er kan slechts één waarde van een statisch veld in uw hele toepassing.
public class SomeOtherObject {
public void doSomeStuff() {
//Two objects, two different values
SomeObject instanceOne = new SomeObject();
SomeObject instanceTwo = new SomeObject();
instanceOne.someField = 7;
instanceTwo.someField = 10;
//Static object, only ever one value
SomeObjectWithStaticStuff.someField = 7;
SomeObjectWithStaticStuff.someField = 10; //Redefines the above set
}
}
Het tweede probleem is dat statische methoden en innerlijke klassen geen toegang hebben tot velden in het omsluitende object(omdat er geen is).
public class SomeObjectWithStaticStuff {
private int nonStaticField;
private void nonStaticMethod() { };
public static void someStaticMethod() {
nonStaticField = 7; //Not allowed
this.nonStaticField = 7; //Not allowed, can never use *this* in static
nonStaticMethod(); //Not allowed
super.someSuperMethod(); //Not allowed, can never use *super* in static
}
public static class SomeStaticInnerClass {
public void doStuff() {
someStaticField = 7; //Not allowed
nonStaticMethod(); //Not allowed
someStaticMethod(); //This is ok
}
}
}
Het statische trefwoord kan ook worden toegepast op interne interfaces, annotaties en opsommingen.
public class SomeObject {
public static interface SomeInterface { };
public static @interface SomeAnnotation { };
public static enum SomeEnum { };
}
In al deze gevallen is het zoekwoord overbodig en heeft het geen effect. Interfaces, annotaties en opsommingen zijn standaard statisch omdat ze nooit een relatie hebben met een innerlijke klasse.
Dit beschrijft alleen wat het trefwoord doet. Het beschrijft niet of het gebruik van het zoekwoord een slecht idee is of niet. Dat kan in meer detail worden behandeld in andere vragen, zoals Is het een slechte zaak om veel statische methoden te gebruiken?
Er zijn ook enkele minder gebruikelijke toepassingen van het zoekwoord static. Er zijn statische imports waarmee u statische typen (inclusief interfaces, annotaties en opsommingen die niet overbodig zijn gemarkeerd als statisch) ongekwalificeerd kunt gebruiken.
//SomeStaticThing.java
public class SomeStaticThing {
public static int StaticCounterOne = 0;
}
//SomeOtherStaticThing.java
public class SomeOtherStaticThing {
public static int StaticCounterTwo = 0;
}
//SomeOtherClass.java
import static some.package.SomeStaticThing.*;
import some.package.SomeOtherStaticThing.*;
public class SomeOtherClass {
public void doStuff() {
StaticCounterOne++; //Ok
StaticCounterTwo++; //Not ok
SomeOtherStaticThing.StaticCounterTwo++; //Ok
}
}
Ten slotte zijn er statische initializers, dit zijn blokken code die worden uitgevoerd wanneer de klasse voor het eerst wordt geladen (wat meestalis net voordat een klasse voor de eerste keer wordt geïnstantieerd in een toepassing) en ( zoals statische methoden) hebben geen toegang tot niet-statische velden of methoden.
public class SomeObject {
private static int x;
static {
x = 7;
}
}
Antwoord 4, autoriteit 2%
Nog een goed voorbeeld van wanneer statische kenmerkenen bewerkingen worden gebruikt wanneer u het ontwerppatroon Singletonwilt toepassen. In een notendop, het Singleton-ontwerppatroon zorgt ervoor dat één en slechts één object van een bepaalde klasse ooit wordt geconstrueerd tijdens de levensduur van uw systeem. om ervoor te zorgen dat er maar één object ooit wordt geconstrueerd, behouden typische implementaties van het Singleton-patroon een interne statische verwijzing naar de enkele toegestane objectinstantie, en de toegang tot die instantie wordt gecontroleerd met behulp van een static-bewerking
Antwoord 5
In aanvulling op wat @inkedmn heeft aangegeven, is er een statisch lid op klasniveau. Daarom wordt het genoemde lid eenmaal in het geheugen geladen door de JVM voor die klasse (wanneer de klasse is geladen). Dat wil zeggen, er zijn geen ninstanties van een statisch lid geladen voor ninstanties van de klasse waartoe het behoort.
Antwoord 6
Bovenstaande punten zijn correct en ik wil nog enkele belangrijke punten toevoegen over Statisch trefwoord.
Intern wat er gebeurt als u een statisch zoekwoord gebruikt, is dat het wordt opgeslagen in het permanente geheugen(dat is in het heapgeheugen), we weten dat er twee soorten geheugen zijn ze zijn stack-geheugen(tijdelijk geheugen) en heap-geheugen(permanent geheugen), dus als u geen statisch sleutelwoord gebruikt, wordt het opgeslagen in een tijdelijk geheugen dat zich in geheugen stapelen(of je kunt het noemen als vluchtig geheugen).
dus je zult gaan twijfelen wat het nut van dit recht is???
voorbeeld: static int a=10;(1 programma)
zojuist vertelde ik dat als je een statisch zoekwoord gebruikt voor variabelenof voor methodehet wordt opgeslagen in het permanente geheugenrechts.
dus heb ik dezelfde variabele gedeclareerd met trefwoord staticin een ander programma met een andere waarde.
voorbeeld: static int a=20;(2 programma)
de variabele ‘a’ wordt in het heapgeheugen opgeslagen door programma 1. Dezelfde statische variabele ‘a’ wordt gevonden in programma 2op dat moment zal niet opnieuw een ‘a’-variabele in het heap-geheugen maken, in plaats daarvan vervangt het gewoon de waarde van a van 10 tot 20.
In het algemeen zal het opnieuwvariabele ‘a’ in het stapelgeheugen (tijdelijk geheugen) creëren als u ‘a’ niet als statische variabele declareert.
over het algemeen kan ik zeggen dat, als we statische trefwoorden gebruiken
1.we kunnen geheugen besparen
2.we kunnen duplicaten vermijden
3. U hoeft geen object te maken om toegang te krijgen tot de statische variabele met behulp van de klassenaam die u kunt openen.