what is static keyword java
Denna handledning förklarar statiska nyckelord i Java och dess användning i variabler, metoder, block och klasser. Anger också skillnaden mellan statiska och icke-statiska medlemmar:
Java stöder olika typer av deklarationer för att ange omfattningen och beteendet för dess variabler, metoder, klasser etc. Till exempel, nyckelordet final, förseglat, statiskt, etc. Alla dessa deklarationer har en viss specifik betydelse när de används i Java-programmet.
Vi kommer att utforska alla dessa nyckelord när vi fortsätter med den här handledningen. Här kommer vi att diskutera detaljerna i ett av de viktigaste nyckelorden i Java, dvs. 'statisk'.
Vad du kommer att lära dig:
- Statisk nyckelord i Java
- Slutsats
Statisk nyckelord i Java
En medlem i ett Java-program kan förklaras som statisk med hjälp av nyckelordet 'statisk' före dess deklaration / definition. När en medlem förklaras statisk betyder det i huvudsak att medlemmen delas av alla förekomster av en klass utan att göra kopior av varje instans.
Således är static en icke-klassmodifierare som används i Java och kan tillämpas på följande medlemmar:
- Variabler
- Metoder
- Block
- Klasser (mer specifikt kapslade klasser)
När en medlem förklaras statisk kan den nås utan att använda ett objekt. Detta betyder att innan en klass instanseras är den statiska medlemmen aktiv och tillgänglig. Till skillnad från andra icke-statiska klassmedlemmar som upphör att existera när objektet för klassen går utanför räckvidden är den statiska medlemmen fortfarande uppenbarligen aktiv.
Statisk variabel i Java
En medlemsvariabel i en klass som deklareras som statisk kallas den statiska variabeln. Det kallas också som 'Klassvariabel'. När variabeln deklareras som statisk, tilldelas minnet bara en gång och inte varje gång en klass instanseras. Därför kan du komma åt den statiska variabeln utan en referens till ett objekt.
Följande Java-program visar användningen av statiska variabler:
class Main { // static variables a and b static int a = 10; static int b; static void printStatic() { a = a /2; b = a; System.out.println('printStatic::Value of a : '+a + ' Value of b : '+b); } public static void main(String() args) { printStatic(); b = a*5; a++; System.out.println('main::Value of a : '+a + ' Value of b : '+b); } } Produktion:
I programmet ovan har vi två statiska variabler, dvs. a och b. Vi ändrar dessa variabler i en funktion ”printStatic” såväl som i ”main”. Observera att värdena för dessa statiska variabler bevaras över funktionerna även när funktionens omfång slutar. Utgången visar värdena på variabler i två funktioner.
Varför behöver vi statiska variabler och var är de användbara?
Statiska variabler är mest användbara i applikationer som behöver räknare. Som du vet kommer räknare att ge fel värden om deklareras som normala variabler.
Till exempel om du har en normal variabel som en räknare i ett program som har en klass säger bil. När vi skapar ett bilobjekt initieras den normala räknervariabeln sedan med varje instans. Men om vi har en motvariabel som en statisk eller klassvariabel initialiseras den bara en gång när klassen skapas.
Senare, med varje instans av klassen, kommer denna räknare att ökas av en. Detta skiljer sig från den normala variabeln där räknaren med varje instans ökas men räknarens värde kommer alltid att vara 1.
Därför, även om du skapar hundra objekt av klassbilen, kommer räknaren som en normal variabel alltid att ha värdet 1 medan det med en statisk variabel visar det korrekta antalet 100.
Nedan följer ett annat exempel på statiska räknare i Java:
class Counter { static int count=0;//will get memory only once and retain its value Counter() { count++;//incrementing the value of static variable System.out.println(count); } } class Main { public static void main(String args()) { System.out.println('Values of static counter:'); Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter(); } } Produktion:
Funktionen för den statiska variabeln framgår av ovanstående program. Vi har deklarerat det statiska variabelantalet med initialvärde = 0. Sedan i klassens konstruktör ökar vi den statiska variabeln.
I huvudfunktionen skapar vi tre objekt av klassräknaren. Utgången visar värdet på den statiska variabeln varje gång räkneobjektet skapas. Vi ser att det existerande statiska variabelvärdet ökas och inte återinitieras för varje objekt som skapas.
Statisk Java-metod
En metod i Java är statisk när den föregås av nyckelordet 'statisk'.
Några punkter som du behöver komma ihåg om den statiska metoden inkluderar:
snabbt sorteringsprogram i c ++
- En statisk metod tillhör klassen jämfört med andra icke-statiska metoder som åberopas med förekomsten av en klass.
- För att åberopa en statisk metod behöver du inte ett klassobjekt.
- De klassiska datamedlemmarna i klassen är tillgängliga för den statiska metoden. Den statiska metoden kan till och med ändra värdena för den statiska datamedlemmen.
- En statisk metod kan inte ha en hänvisning till 'detta' eller 'super' medlemmar. Även om en statisk metod försöker hänvisa dem blir det ett kompileringsfel.
- Precis som statiska data kan den statiska metoden också anropa andra statiska metoder.
- En statisk metod kan inte hänvisa till icke-statiska datamedlemmar eller variabler och kan inte anropa icke-statiska metoder också.
Följande program visar implementeringen av den statiska metoden i Java:
class Main { // static method static void static_method() { System.out.println('Static method in Java...called without any object'); } public static void main(String() args) { static_method(); } } Produktion:
Detta är en enkel illustration. Vi definierar en statisk metod som helt enkelt skriver ut ett meddelande. Sedan i huvudfunktionen kallas den statiska metoden utan något objekt eller förekomst av en klass.
Ett annat exempel på statisk nyckelordsimplementering i Java.
class Main { // static variable static int count_static = 5; // instance variable int b = 10; // static method static void printStatic() { count_static = 20; System.out.println('static method printStatic'); // b = 20; // compilation error 'error: non-static variable b cannot be referenced from a static context' //inst_print(); // compilation error 'non-static method inst_print() cannot be referenced from a static //context' //System.out.println(super.count_static); // compiler error 'non-static variable super cannot be //referenced from a static context' } // instance method void inst_print() { System.out.println('instance method inst_print'); } public static void main(String() args) { printStatic(); } } I ovanstående program, som du kan se, har vi två metoder. Metoden printStatic är en statisk metod medan inst_print är en instansmetod. Vi har också två variabler, static_count är en statisk variabel och b är en instansvariabel.
I den statiska metoden - printStatic, först visar vi ett meddelande och sedan försöker vi ändra värdet på förekomstvariabeln b och även anropa den icke-statiska metoden.
Därefter försöker vi använda nyckelordet ”super”.
b = 20;
inst_print ();
System.out.println (super.count_static);
När vi kör programmet med ovanstående rader får vi kompileringsfel för att använda instansvariabler, anropa icke-statiska metoder och referera super i ett statiskt sammanhang. Detta är begränsningarna för den statiska metoden.
När vi kommenterar ovanstående tre rader fungerar först ovanstående program bra och producerar följande utdata.
Produktion:
Överbelastning och överstyrning av statisk metod
Som ni alla vet är både överbelastning och överstyrning funktioner i OOPS och de hjälper till med polymorfism. Överbelastning kan klassificeras som sammanställningstidspolymorfism där du kan ha metoder med samma namn men olika parametrar.
Åsidosättande är ett inslag i körtidspolymorfism och i detta åsidosätts basklassmetoden i den härledda klassen så att metodesignaturen eller prototypen är densamma men definitionen skiljer sig åt.
Låt oss diskutera hur överbelastning och överstyrning påverkar den statiska klassen i Java.
Överbelastning
Du kan överbelasta en statisk metod i Java med olika parameterlistor men med samma namn.
Följande program visar överbelastning:
public class Main { public static void static_method() { System.out.println('static_method called '); } public static void static_method(String msg) { System.out.println('static_method(string) called with ' + msg); } public static void main(String args()) { static_method(); static_method('Hello, World!!'); } } Produktion:
Detta program har två statiska metoder med samma namn 'static_method' men en annan argumentlista. Den första metoden tar inget argument och den andra metoden tar ett strängargument.
En sak att notera är att du inte kan överbelasta metoden bara beroende på det 'statiska' nyckelordet. Till exempel, om du har en instansmetod 'summa' och om du definierar en annan metod 'summa' och förklarar den som statisk, kommer den inte att fungera. Detta försök att överbelasta baserat på ett 'statiskt' nyckelord kommer att resultera i ett kompileringsfel.
Åsidosättande
Eftersom statiska metoder åberopas utan något objekt av klassen, även om du har en statisk metod med samma signatur i den härledda klassen, kommer den inte att åsidosätta. Det beror på att det inte finns någon polymorfism under körning utan en instans.
Därför kan du inte åsidosätta en statisk metod. Men om det alls finns en statisk metod med samma signatur i den härledda klassen, beror inte metoden att anropa på objekten vid körningstid men på kompilatorn.
Du måste notera att även om statiska metoder inte kan åsidosättas, ger Java-språket inga kompileringsfel när du har en metod i den härledda klassen med samma signatur som en basklassmetod.
Följande implementering bevisar denna punkt.
classBase_Class { // Static method in base class which will be hidden in substatic_displayclass public static void static_display() { System.out.println('Base_Class::static_display'); } } classDerived_Class extends Base_Class { public static void static_display() { System.out.println('Derived_Class::static_display'); } } public class Main { public static void main(String args( )) { Base_Class obj1 = new Base_Class(); Base_Class obj2 = new Derived_Class(); Derived_Class obj3 = new Derived_Class(); obj1.static_display(); obj2.static_display(); obj3.static_display(); } } Produktion:
I ovanstående program kan du se att den statiska metoden som kallas inte beror på vilket objekt pekaren pekar på. Detta beror på att objekt inte alls används med statiska metoder.
Statiskt block i Java
Precis som du har funktionsblock på programmeringsspråk som C ++, C #, etc. i Java finns det också ett speciellt block som kallas 'statiskt' block som vanligtvis innehåller ett kodblock relaterat till statisk data.
Detta statiska block exekveras i det ögonblick då det första objektet i klassen skapas (exakt vid tidpunkten för klassladdning) eller när det statiska elementet inuti blocket används.
Följande program visar användningen av ett statiskt block.
class Main { static int sum = 0; static int val1 = 5; static int val2; // static block static { sum = val1 + val2; System.out.println('In static block, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); val2 = val1 * 3; sum = val1 + val2; } public static void main(String() args) { System.out.println('In main function, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); } } Produktion:
Notera ordningen för utförande av uttalanden i ovanstående program. Innehållet i det statiska blocket körs först följt av huvudprogrammet. De statiska variablerna summan och val1 har initialvärden medan val2 inte initialiseras (det är som standard 0). Sedan tilldelas val2 fortfarande inte ett värde i det statiska blocket och därför visas dess värde som 0.
Variabeln val2 tilldelas värde efter utskrift i det statiska blocket och summan beräknas om. Därför får vi i huvudfunktionen olika värden på sum och val2.
Om du anger en konstruktör körs innehållet i det statiska blocket redan innan konstruktorn. De statiska blocken används oftast för att initiera klassiska medlemmar i klassen och andra initialiseringar relaterade till statiska medlemmar.
Java Statisk klass
I Java har du statiska block, statiska metoder och till och med statiska variabler. Därför är det uppenbart att du också kan ha statiska klasser. I Java är det möjligt att ha en klass i en annan klass och detta kallas en nestad klass. Klassen som omsluter den kapslade klassen kallas den yttre klassen.
c ++ inmatningsfil
I Java, även om du kan förklara en kapslad klass som statisk, är det inte möjligt att ha den yttre klassen som statisk.
Låt oss nu utforska de statiska kapslade klasserna i Java.
Statisk kapslad klass i Java
Som redan nämnts kan du få en kapslad klass i Java deklarerad som statisk. Den statiska kapslade klassen skiljer sig från den icke-statiska kapslade klassen (inre klass) i vissa aspekter som anges nedan.
Till skillnad från den icke-statiska kapslade klassen behöver den kapslade statiska klassen inte en yttre klassreferens.
En statisk kapslad klass har endast åtkomst till statiska medlemmar av den yttre klassen mot de icke-statiska klasserna som har åtkomst till statiska såväl som icke-statiska medlemmar av den yttre klassen.
Ett exempel på en statisk kapslad klass ges nedan.
class Main{ private static String str = 'SoftwareTestingHelp'; //Static nested class static class NestedClass{ //non-static method public void display() { System.out.println('Static string in OuterClass: ' + str); } } public static void main(String args()) { Main.NestedClassobj = new Main.NestedClass(); obj.display(); } } Produktion:
I programmet ovan ser du att den statiska kapslade klassen kan komma åt den statiska variabeln (sträng) från den yttre klassen.
Statisk import i Java
Som ni vet brukar vi inkludera olika paket och fördefinierade funktioner i Java-programmet genom att använda 'import' -direktivet. Genom att använda ordet statisk med importdirektivet kan du använda klassfunktionaliteten utan att använda klassnamnet.
Exempel:
import static java.lang.System.*; class Main { public static void main(String() args) { //here we import System class using static, hence we can directly use functionality out.println('demonstrating static import'); } } Produktion:
I det här programmet använder vi statisk import för java.lang.System-klassen.
Notera: I huvudfunktionen har vi just använt out.println för att visa meddelandet.
bästa gratis PC-programvara
Även om den statiska importfunktionen gör koden mer kortfattad och läsbar, skapar den ibland tvetydighet, särskilt när vissa paket har samma funktioner. Därför bör statisk import endast användas när det är extremt nödvändigt.
Statisk vs icke-statisk
Låt oss diskutera de stora skillnaderna mellan statiska och icke-statiska medlemmar av Java.
Nedan listas skillnaderna mellan Statiska och icke-statiska variabler .
| Statiska variabler | Icke-statiska variabler |
|---|---|
| Det kan endast nås med klassnamn. | Kräver att objekt i en klass får åtkomst. |
| Är tillgängliga för både statiska och icke-statiska metoder. | Är endast tillgängliga för icke-statiska metoder. |
| Ett minne för statisk variabel tilldelas endast en gång per klass. | Ett minne för icke-statiska variabler tilldelas per objekt. |
| Delas av alla objekt i klassen. | En kopia av variabel per objekt görs. |
| Har global omfattning och är tillgänglig för alla metoder och block. | Har lokal räckvidd och är synlig för objekt i klassen. |
Nedan anges skillnaden mellan statiska och icke-statiska metoder .
| Statiska metoder | Icke-statiska metoder |
|---|---|
| En metod som föregås av ett statiskt nyckelord och som finns på klassnivå. | En metod som inte föregås av ett statiskt nyckelord och som är tillgänglig för var och en av klasserna. |
| Stöder kompileringstid eller tidig bindning. | Stöder körtid eller dynamisk bindning. |
| Har endast åtkomst till medlemmar av statisk data i sin klass och andra klasser. | Kan komma åt både statiska och icke-statiska medlemmar i klassen och andra klasser. |
| Statiska metoder kan inte åsidosättas. | Kan åsidosättas. |
| Minne tilldelas bara en gång. Därför är minnet som används mindre. | Minnesförbrukningen är mer eftersom minnet tilldelas varje gång metoden anropas. |
Statisk vs final
Static och Final är två nyckelord i Java som kan ge den enhet som den används med speciell mening. Till exempel, när en variabel deklareras som statisk blir den en klassvariabel som kan nås utan en referens till objektet.
På samma sätt, när en variabel förklaras som slutlig, blir den oföränderlig, dvs. en konstant.
Låt oss tabulera några av de stora skillnaderna mellan statiska och slutliga nyckelord i Java.
| Statisk | Slutlig |
|---|---|
| En statisk datamedlem (kapslad klass, variabel eller metod) är en datamedlem som föregås av ett statiskt nyckelord och kan nås utan ett objekt. | Det sista nyckelordet kan tillämpas på en variabel, metod, klass osv. och inför restriktioner för enheterna. |
| Det är inte obligatoriskt att initialisera den statiska variabeln med värdet under deklarationen. | Det krävs att den slutliga variabeln initialiseras till ett värde vid tidpunkten för deklarationen |
| Du kan återinitialisera de statiska variablerna. | Det går inte att återinitialisera slutliga variabler. |
| Statiska metoder är de som bara kan komma åt statiska medlemmar. | Slutliga metoder är de metoder som inte går att ärva / åsidosätta. |
| Statiska klasser är klasser vars objekt inte kan skapas. | Slutklasser är klasser som inte kan ärvas. |
Vanliga frågor
F # 1) Kan Java-klass vara statisk?
Svar: Ja, en klass i Java kan vara statisk, förutsatt att den inte är den yttre klassen. Detta innebär att endast kapslade klasser i Java kan vara statiska.
F # 2) När ska jag använda Static i Java?
Svar: Närhelst du vill ha en datamedlem i ditt program som ska behålla sitt värde över objekten, bör du använda statisk. Till exempel, en räknare. En metod kan förklaras som statisk när du inte vill åberopa den med ett objekt.
F # 3) Kan en statisk klass ha en konstruktör?
Svar: Ja, en statisk klass kan ha en konstruktör och dess syfte är enbart att initiera statiska datamedlemmar. Det kommer endast att åberopas för första gången när datamedlemmarna är åtkomliga. Det åberopas inte för efterföljande åtkomst.
F # 4) Vad är användningen av Static Constructor?
Svar: Generellt används konstruktorn för att initiera medlemmar av statisk data. Den används också för att utföra operationer / åtgärder som behöver utföras bara en gång.
F # 5) Ärver statiska metoder i Java?
Svar: Ja, statiska metoder i Java ärvs men åsidosätts inte.
Slutsats
I denna handledning diskuterade vi det statiska nyckelordet för Java i detalj tillsammans med dess användning i datamedlemmar, metoder, block och klasser. Det statiska nyckelordet är ett nyckelord som används för att ange klassnivå eller globalt omfång.
Du behöver inte komma åt statiska medlemmar med instanser av klassen. Du kan direkt komma åt medlemmarna för statisk data med hjälp av klassnamnet. Vi diskuterade också de stora skillnaderna mellan statiska och icke-statiska medlemmar samt statiska och slutliga nyckelord.
I våra följande ämnen kommer vi att utforska fler nyckelord och deras betydelse på Java-språket.
Rekommenderad läsning
- Statisk i C ++
- Java-gränssnitt och abstrakt klasshandledning med exempel
- Java-distribution: Skapande och utförande av Java JAR-fil
- Java Virtual Machine: Hur JVM hjälper till att köra Java-applikationen
- C # -koncept: konstruktör, förstörare, statisk klass, struktur och enum
- Åtkomstmodifierare i Java - Handledning med exempel
- Java Reflection Tutorial med exempel
- Introduktion till Java-programmeringsspråk - Videohandledning