what is static keyword java
Aquest tutorial explica la paraula clau estàtica a Java i el seu ús a variables, mètodes, blocs i classes. També indica la diferència entre membres estàtics i no estàtics:
Java admet diversos tipus de declaracions per indicar l'abast i el comportament de les seves variables, mètodes, classes, etc. Per exemple, la paraula clau final, segellada, estàtica, etc. Totes aquestes declaracions tenen un significat específic quan s’utilitzen al programa Java.
Explorarem totes aquestes paraules clau mentre procedim amb aquest tutorial. Aquí analitzarem els detalls d'una de les paraules clau més importants de Java, és a dir, 'estàtica'.
Què aprendreu:
- Paraula clau estàtica a Java
- Conclusió
Paraula clau estàtica a Java
Un membre d'un programa Java es pot declarar estàtic mitjançant la paraula clau 'estàtic' anterior a la seva declaració / definició. Quan un membre es declara estàtic, significa essencialment que el membre és compartit per totes les instàncies d'una classe sense fer-ne còpies.
Per tant, estàtic és un modificador que no s’utilitza a Java i que es pot aplicar als membres següents:
- variables
- Mètodes
- Blocs
- Classes (més concretament, classes imbricades)
Quan un membre es declara estàtic, s’hi pot accedir sense fer servir cap objecte. Això vol dir que abans d’instanciar una classe, el membre estàtic és actiu i accessible. A diferència d'altres membres de la classe no estàtics que deixen d'existir quan l'objecte de la classe surt de l'abast, el membre estàtic encara està actiu.
Variable estàtica a Java
Una variable membre d’una classe que es declara estàtica s’anomena variable estàtica. També s'anomena 'variable de classe'. Una vegada que la variable es declara estàtica, la memòria només s'assigna una vegada i no cada vegada que s'instancia una classe. Per tant, podeu accedir a la variable estàtica sense fer referència a cap objecte.
El programa Java següent mostra l’ús de variables estàtiques:
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); } } Sortida:
Al programa anterior, tenim dues variables estàtiques, és a dir, a i b. Modifiquem aquestes variables tant en una funció “printStatic” com en “main”. Tingueu en compte que els valors d’aquestes variables estàtiques es conserven a través de les funcions fins i tot quan l’abast de la funció finalitza. La sortida mostra els valors de les variables en dues funcions.
Per què necessitem variables estàtiques i on són útils?
Les variables estàtiques són més útils en aplicacions que necessiten comptadors. Com ja sabeu, els comptadors donaran valors incorrectes si es declaren com a variables normals.
Per exemple, si teniu una variable normal configurada com a comptador en una aplicació que té una classe, digueu cotxe. Després, sempre que creem un objecte de cotxe, la variable normal del comptador s’inicialitzarà amb cada instància. Però si tenim una variable de comptador com a variable estàtica o de classe, inicialitzarà només una vegada quan es creï la classe.
Més endavant, amb cada instància de la classe, aquest comptador s'incrementarà en un. Això és diferent de la variable normal en què amb cada instància el comptador s'incrementarà, però el valor del comptador serà sempre 1.
Per tant, fins i tot si creeu un centenar d’objectes del cotxe de classe, el comptador com a variable normal sempre tindrà el valor 1 mentre que, amb una variable estàtica, mostrarà el recompte correcte de 100.
A continuació es mostra un altre exemple de comptadors estàtics a 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(); } } Sortida:
El funcionament de la variable estàtica és evident al programa anterior. Hem declarat el recompte de variables estàtiques amb un valor inicial = 0. Després, al constructor de la classe, incrementem la variable estàtica.
A la funció principal, creem tres objectes del comptador de classes. La sortida mostra el valor de la variable estàtica cada vegada que es crea l'objecte comptador. Veiem que amb cada objecte creat, el valor de la variable estàtica existent s’incrementa i no es reinicialitza.
Mètode estàtic de Java
Un mètode a Java és estàtic quan va precedit de la paraula clau 'estàtic'.
Alguns punts que cal recordar sobre el mètode estàtic són:
com provar mètodes privats amb mockito
- Un mètode estàtic pertany a la classe enfront d'altres mètodes no estàtics que s'invocen mitjançant la instància d'una classe.
- Per invocar un mètode estàtic, no necessiteu cap objecte de classe.
- Els membres de dades estàtiques de la classe són accessibles pel mètode estàtic. El mètode estàtic pot fins i tot canviar els valors del membre de dades estàtiques.
- Un mètode estàtic no pot tenir cap referència als membres 'aquest' o 'súper'. Fins i tot si un mètode estàtic intenta referir-los, serà un error del compilador.
- Igual que les dades estàtiques, el mètode estàtic també pot anomenar altres mètodes estàtics.
- Un mètode estàtic no pot fer referència a membres o variables de dades no estàtiques i tampoc no pot cridar mètodes no estàtics.
El programa següent mostra la implementació del mètode estàtic a 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(); } } Sortida:
Es tracta d’una il·lustració senzilla. Definim un mètode estàtic que simplement imprimeix un missatge. A continuació, a la funció principal, s'anomena el mètode estàtic sense cap objecte ni instància d'una classe.
Un altre exemple d’implementació de paraules clau estàtiques a 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(); } } Al programa anterior, com podeu veure, tenim dos mètodes. El mètode printStatic és un mètode estàtic mentre que inst_print és un mètode d’instància. També tenim dues variables, static_count és una variable estàtica i b és una variable d’instància.
Al mètode estàtic - printStatic, primer, mostrem un missatge i després intentem canviar el valor de la variable d’instància b i també anomenem el mètode no estàtic.
A continuació, intentem utilitzar la paraula clau 'súper'.
b = 20;
impr_impressió ();
System.out.println (super.count_static);
Quan executem el programa amb les línies anteriors, obtenim errors de compilació per utilitzar variables d’instància, trucar a mètodes no estàtics i fer referència a super en un context estàtic. Aquestes són les limitacions del mètode estàtic.
Quan comentem les tres línies anteriors, només el programa anterior funciona bé i produeix la següent sortida.
Sortida:
Sobrecàrrega i anul·lació del mètode estàtic
Com tots sabeu, tant la sobrecàrrega com la sobrecàrrega són les característiques d’OOPS i ajuden al polimorfisme. La sobrecàrrega es pot classificar com a polimorfisme en temps de compilació en què podeu tenir mètodes amb el mateix nom però llistes de paràmetres diferents.
La substitució és una característica del polimorfisme en temps d'execució i en això, el mètode de la classe base s'anul·la a la classe derivada de manera que la signatura o el prototip del mètode és el mateix, però la definició difereix.
Analitzem com la sobrecàrrega i la substitució afecten la classe estàtica de Java.
Sobrecàrrega
Podeu sobrecarregar un mètode estàtic a Java amb llistes de paràmetres diferents però amb el mateix nom.
El programa següent mostra la sobrecàrrega:
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!!'); } } Sortida:
char * a int c ++
Aquest programa té dos mètodes estàtics amb el mateix nom 'static_method' però una llista d'arguments diferent. El primer mètode no accepta cap argument i el segon mètode adopta un argument de cadena.
Un punt a tenir en compte és que no podeu sobrecarregar el mètode només depenent de la paraula clau 'estàtica'. Per exemple, si teniu un mètode d’instància «suma» i si definiu un altre mètode «suma» i el declareu estàtic, no funcionarà. Aquest intent de sobrecàrrega basat en una paraula clau 'estàtica' provocarà un error de compilació.
Sobresortint
Com que s’invoquen mètodes estàtics sense cap objecte de la classe, fins i tot si teniu un mètode estàtic amb la mateixa signatura a la classe derivada, no s’anul·larà. Això es deu al fet que no hi ha polimorfisme en temps d'execució sense cap instància.
Per tant, no podeu anul·lar un mètode estàtic. Però si hi ha un mètode estàtic amb la mateixa signatura a la classe derivada, el mètode per cridar no depèn dels objectes en temps d’execució, sinó que depèn del compilador.
Heu de tenir en compte que, tot i que no es poden anul·lar els mètodes estàtics, el llenguatge Java no dóna cap error del compilador quan es té un mètode a la classe derivada amb la mateixa signatura que un mètode de classe base.
La implementació següent demostra aquest punt.
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(); } } Sortida:
Al programa anterior, podeu veure que el mètode estàtic que es diu no depèn de quin objecte assenyali el punter. Això es deu al fet que els objectes no s’utilitzen en absolut amb mètodes estàtics.
Bloc estàtic a Java
De la mateixa manera que teniu blocs de funció en llenguatges de programació com C ++, C #, etc. a Java, també hi ha un bloc especial anomenat bloc 'estàtic' que normalment inclou un bloc de codi relacionat amb dades estàtiques.
Aquest bloc estàtic s'executa en el moment en què es crea el primer objecte de la classe (precisament en el moment de la càrrega de classe) o quan s'utilitza el membre estàtic dins del bloc.
El programa següent mostra l'ús d'un bloc estàtic.
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); } } Sortida:
Tingueu en compte l'ordre d'execució de les sentències del programa anterior. El contingut del bloc estàtic s’executa primer seguit del programa principal. Les variables estàtiques sum i val1 tenen valors inicials mentre que val2 no s’inicialitza (per defecte és 0). Aleshores, al bloc estàtic val2 encara no té assignat cap valor i, per tant, el seu valor es mostra com a 0.
A la variable val2 se li assigna un valor després d'imprimir al bloc estàtic i es torna a calcular la suma. Per tant, a la funció principal, obtenim diferents valors de suma i val2.
Si especifiqueu un constructor, el contingut del bloc estàtic s’executarà fins i tot abans que el constructor. Els blocs estàtics s'utilitzen principalment per inicialitzar membres estàtics de la classe i altres inicialitzacions relacionades amb membres estàtics.
Classe estàtica de Java
A Java, teniu blocs estàtics, mètodes estàtics i fins i tot variables estàtiques. Per tant, és obvi que també podeu tenir classes estàtiques. A Java, és possible tenir una classe dins d’una altra classe i això s’anomena classe imbricada. La classe que tanca la classe imbricada s’anomena classe exterior.
A Java, tot i que podeu declarar una classe imbricada com a estàtica, no és possible tenir la classe externa com a estàtica.
Ara explorem les classes niades estàtiques a Java.
Classe imbricada estàtica a Java
Com ja s'ha esmentat, podeu tenir una classe imbricada a Java declarada com a estàtica. La classe imbricada estàtica difereix de la classe imbricada no estàtica (classe interna) en alguns aspectes que es detallen a continuació.
A diferència de la classe imbricada no estàtica, la classe estàtica imbricada no necessita una referència de classe externa.
Una classe imbricada estàtica només pot accedir als membres estàtics de la classe externa en comparació amb les classes no estàtiques que poden accedir als membres estàtics i no estàtics de la classe externa.
A continuació es mostra un exemple de classe imbricada estàtica.
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(); } } Sortida:
Al programa anterior, veureu que la classe imbricada estàtica pot accedir a la variable estàtica (cadena) des de la classe externa.
Importació estàtica a Java
Com ja sabeu, solem incloure diversos paquets i funcionalitats predefinides al programa Java mitjançant la directiva 'importació'. L'ús de la paraula estàtic amb la directiva d'importació us permet utilitzar la funcionalitat de la classe sense utilitzar el nom de la classe.
Exemple:
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'); } } Sortida:
En aquest programa, fem servir la importació estàtica per a la classe java.lang.System.
Nota: A la funció principal, acabem d’utilitzar out.println per mostrar el missatge.
Tot i que la funció d’importació estàtica fa que el codi sigui més concís i llegible, de vegades crea ambigüitat sobretot quan alguns paquets tenen les mateixes funcions. Per tant, la importació estàtica només s'ha d'utilitzar quan sigui extremadament necessària.
Estàtic vs No estàtic
Analitzem les principals diferències entre els membres estàtics i no estàtics de Java.
A continuació es detallen les diferències entre Variables estàtiques i no estàtiques .
| Variables estàtiques | Variables no estàtiques |
|---|---|
| Es pot accedir només mitjançant el nom de la classe. | Requereix l'accés als objectes d'una classe. |
| Són accessibles tant per mètodes estàtics com no estàtics. | Només són accessibles per a mètodes no estàtics. |
| Una memòria per a variables estàtiques només s’assigna una vegada per classe. | S'assigna una memòria per a variables no estàtiques per objecte. |
| Compartit per tots els objectes de la classe. | Es fa una còpia de la variable per objecte. |
| Té un abast global i està disponible per a tots els mètodes i blocs. | Té àmbit local i és visible per als objectes de la classe. |
A continuació es mostra la diferència entre mètodes estàtics i no estàtics .
| Mètodes estàtics | Mètodes no estàtics |
|---|---|
| Un mètode precedit per una paraula clau estàtica i disponible a nivell de classe. | Un mètode no precedit de paraules clau estàtiques i disponible per a cadascuna de les instàncies de la classe. |
| Admet enquadrament en temps de compilació o primerenc. | Admet enquadernació en temps d'execució o dinàmic. |
| Només pot accedir a membres de dades estàtiques de la seva classe i de qualsevol altra classe. | Pot accedir a membres tant estàtics com no estàtics de la classe i d'altres classes. |
| No es poden anul·lar els mètodes estàtics. | Es pot anul·lar. |
| La memòria només s’assigna una vegada. Per tant, la memòria utilitzada és menor. | El consum de memòria és més gran ja que s’assigna memòria cada vegada que s’invoca el mètode. |
Estàtica vs Final
Estàtica i Final són dues paraules clau de Java que poden donar un significat especial a l’entitat amb què s’utilitza. Per exemple, quan una variable es declara estàtica, es converteix en una variable de classe a la qual es pot accedir sense fer referència a l'objecte.
De la mateixa manera, quan una variable es declara com a final, es torna immutable, és a dir, una constant.
Tabulem algunes de les principals diferències entre les paraules clau estàtiques i finals de Java.
| Estàtic | final |
|---|---|
| Un membre de dades estàtiques (classe imbricada, variable o mètode) és un membre de dades precedit per una paraula clau estàtica i es pot accedir sense objecte. | La paraula clau final es pot aplicar a una variable, mètode, classe, etc. i imposa restriccions a les entitats. |
| No és obligatori inicialitzar la variable estàtica amb valor durant la declaració. | Cal que la variable final s’inicialitzi a un valor en el moment de la declaració |
| Podeu reinicialitzar les variables estàtiques. | No és possible reinicialitzar les variables finals. |
| Els mètodes estàtics són aquells que només poden accedir a membres estàtics. | Els mètodes finals són els mètodes que no es poden heretar / anul·lar. |
| Les classes estàtiques són classes els objectes no es poden crear. | Les classes finals són classes que no es poden heretar. |
Preguntes freqüents
P # 1) La classe Java pot ser estàtica?
Resposta: Sí, una classe a Java pot ser estàtica, sempre que no sigui la classe externa. Això significa que només les classes imbricades a Java poden ser estàtiques.
P # 2) Quan he d'utilitzar Static a Java?
Resposta: Sempre que vulgueu que un membre de dades del vostre programa mantingui el seu valor entre els objectes, haureu d’utilitzar estàtic. Per exemple, un taulell. Un mètode es pot declarar estàtic quan no voleu invocar-lo mitjançant un objecte.
P # 3) Una classe estàtica pot tenir un constructor?
Resposta: Sí, una classe estàtica pot tenir un constructor i el seu propòsit és únicament inicialitzar els membres de dades estàtiques. Només s’invocarà per primera vegada quan s’accedeixi als membres de les dades. No s’invocarà per a un accés posterior.
aplicació on podeu descarregar vídeos de youtube
Q # 4) Quin ús té Static Constructor?
Resposta: En general, el constructor s’utilitza per inicialitzar membres de dades estàtiques. També s’utilitza per realitzar operacions / accions que cal dur a terme només una vegada.
P # 5) Els mètodes estàtics s’hereten a Java?
Resposta: Sí, els mètodes estàtics a Java s’hereten però no s’anul·len.
Conclusió
En aquest tutorial, hem discutit detalladament la paraula clau estàtica de Java juntament amb el seu ús en membres, mètodes, blocs i classes de dades. La paraula clau estàtica és una paraula clau que s’utilitza per indicar el nivell de classe o l’abast global.
No cal que accediu a membres estàtics mitjançant instàncies de la classe. Podeu accedir directament als membres de dades estàtiques mitjançant el nom de la classe. També vam discutir les principals diferències entre els membres estàtics i no estàtics, així com les paraules clau estàtiques i finals.
En els nostres temes posteriors, explorarem més paraules clau i la seva importància en llenguatge Java.
Lectura recomanada
- Estàtic a C ++
- Interfície Java i tutoria de classes abstractes amb exemples
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Conceptes de C #: constructor, destructor, classe estàtica, Struct & Enum
- Modificadors d'accés a Java: tutorial amb exemples
- Tutorial de reflexió de Java amb exemples
- Introducció al llenguatge de programació Java: vídeo tutorial