what is static keyword java
Questo tutorial spiega la parola chiave statica in Java e il suo utilizzo in variabili, metodi, blocchi e classi. Indica anche la differenza tra membri statici e non statici:
Java supporta vari tipi di dichiarazioni per indicare l'ambito e il comportamento delle sue variabili, metodi, classi, ecc. Per esempio, la parola chiave final, sealed, static, ecc. Tutte queste dichiarazioni hanno un significato specifico quando vengono utilizzate nel programma Java.
Esploreremo tutte queste parole chiave mentre procediamo con questo tutorial. Qui discuteremo i dettagli di una delle parole chiave più importanti in Java, ovvero 'statica'.
Cosa imparerai:
- Parola chiave statica in Java
- Conclusione
Parola chiave statica in Java
Un membro in un programma Java può essere dichiarato statico utilizzando la parola chiave 'statico' che precede la sua dichiarazione / definizione. Quando un membro viene dichiarato statico, significa essenzialmente che il membro è condiviso da tutte le istanze di una classe senza fare copie per istanza.
Pertanto static è un modificatore non di classe utilizzato in Java e può essere applicato ai seguenti membri:
- Variabili
- Metodi
- Blocchi
- Classi (più specificamente, classi annidate)
Quando un membro viene dichiarato statico, è possibile accedervi senza utilizzare un oggetto. Ciò significa che prima di creare un'istanza di una classe, il membro statico è attivo e accessibile. A differenza di altri membri di classe non statici che cessano di esistere quando l'oggetto della classe esce dall'ambito, il membro statico è ancora ovviamente attivo.
Variabile statica in Java
Una variabile membro di una classe dichiarata come statica viene chiamata variabile statica. Viene anche chiamata 'variabile di classe'. Una volta che la variabile è stata dichiarata come statica, la memoria viene allocata solo una volta e non ogni volta che viene creata un'istanza di una classe. Quindi è possibile accedere alla variabile statica senza un riferimento a un oggetto.
Il seguente programma Java descrive l'utilizzo delle variabili statiche:
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); } } Produzione:
Nel programma sopra, abbiamo due variabili statiche, ad esempio a e b. Modifichiamo queste variabili in una funzione 'printStatic' così come in 'main'. Si noti che i valori di queste variabili statiche vengono conservati nelle funzioni anche quando l'ambito della funzione termina. L'output mostra i valori delle variabili in due funzioni.
Perché abbiamo bisogno di variabili statiche e dove sono utili?
Le variabili statiche sono più utili nelle applicazioni che richiedono contatori. Come sapete, i contatori daranno valori errati se dichiarati come variabili normali.
Ad esempio, se hai una variabile normale impostata come contatore in un'applicazione che ha una classe, dì auto. Quindi, ogni volta che creiamo un oggetto car, la normale variabile counter verrà inizializzata con ogni istanza. Ma se abbiamo una variabile contatore come variabile statica o di classe, verrà inizializzata solo una volta quando viene creata la classe.
Successivamente, con ogni istanza della classe, questo contatore verrà incrementato di uno. Questo è diverso dalla variabile normale in cui con ogni istanza il contatore verrà incrementato ma il valore del contatore sarà sempre 1.
Quindi, anche se crei un centinaio di oggetti della classe auto, il contatore come variabile normale avrà sempre il valore 1 mentre, con una variabile statica, mostrerà il conteggio corretto di 100.
Di seguito è riportato un altro esempio di contatori statici in 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(); } } Produzione:
Il funzionamento della variabile statica è evidente nel programma sopra. Abbiamo dichiarato la variabile statica count con valore iniziale = 0. Quindi nel costruttore della classe, incrementiamo la variabile statica.
Nella funzione principale creiamo tre oggetti del contatore di classi. L'output mostra il valore della variabile statica ogni volta che viene creato l'oggetto contatore. Vediamo che con ogni oggetto creato il valore della variabile statica esistente viene incrementato e non reinizializzato.
Metodo statico Java
Un metodo in Java è statico quando è preceduto dalla parola chiave 'statico'.
Alcuni punti che devi ricordare sul metodo statico includono:
come fare in modo che java apra i file jar
- Un metodo statico appartiene alla classe rispetto ad altri metodi non statici che vengono richiamati utilizzando l'istanza di una classe.
- Per invocare un metodo statico, non è necessario un oggetto classe.
- I membri dei dati statici della classe sono accessibili al metodo statico. Il metodo statico può anche modificare i valori del membro dati statico.
- Un metodo statico non può avere un riferimento ai membri 'this' o 'super'. Anche se un metodo statico tenta di fare riferimento a loro, sarà un errore del compilatore.
- Proprio come i dati statici, il metodo statico può anche chiamare altri metodi statici.
- Un metodo statico non può fare riferimento a variabili o membri di dati non statici e non può chiamare anche metodi non statici.
Il seguente programma mostra l'implementazione del metodo statico in 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(); } } Produzione:
Questa è una semplice illustrazione. Definiamo un metodo statico che stampa semplicemente un messaggio. Quindi nella funzione principale, il metodo statico viene chiamato senza alcun oggetto o istanza di una classe.
Un altro esempio di implementazione di parole chiave statiche in 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(); } } Nel programma sopra, come puoi vedere, abbiamo due metodi. Il metodo printStatic è un metodo statico mentre inst_print è un metodo di istanza. Abbiamo anche due variabili, static_count è una variabile statica eb è una variabile di istanza.
Nel metodo statico - printStatic, prima visualizziamo un messaggio e poi proviamo a cambiare il valore della variabile di istanza be chiamiamo anche il metodo non statico.
Successivamente, proviamo a utilizzare la parola chiave 'super'.
b = 20;
inst_print ();
System.out.println (super.count_static);
Quando eseguiamo il programma con le righe precedenti, otteniamo errori di compilazione per l'utilizzo di variabili di istanza, la chiamata a metodi non statici e il riferimento a super in un contesto statico. Questi sono i limiti del metodo statico.
Quando commentiamo le tre righe precedenti, solo allora il programma precedente funziona bene e produce il seguente output.
Produzione:
Sovraccarico e sovrascrittura del metodo statico
Come tutti sapete, sia l'overload che l'override sono le caratteristiche di OOPS e aiutano nel polimorfismo. Il sovraccarico può essere classificato come polimorfismo in fase di compilazione in cui è possibile avere metodi con lo stesso nome ma elenchi di parametri diversi.
L'override è una caratteristica del polimorfismo in fase di esecuzione e in questo, il metodo della classe base viene sovrascritto nella classe derivata in modo che la firma del metodo o il prototipo sia lo stesso ma la definizione sia diversa.
Parliamo di come l'overload e l'override influenzano la classe statica in Java.
Sovraccarico
È possibile eseguire l'overload di un metodo statico in Java con elenchi di parametri diversi ma con lo stesso nome.
Il seguente programma mostra Sovraccarico:
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!!'); } } Produzione:
Questo programma ha due metodi statici con lo stesso nome 'static_method' ma un diverso elenco di argomenti. Il primo metodo non accetta alcun argomento e il secondo metodo accetta un argomento stringa.
Un punto da notare è che non è possibile sovraccaricare il metodo semplicemente in base alla parola chiave 'statica'. Per esempio, se si dispone di un metodo di istanza 'sum' e se si definisce un altro metodo 'sum' e lo si dichiara come statico, non funzionerà. Questo tentativo di sovraccarico basato su una parola chiave 'statica' risulterà in un errore di compilazione.
Overriding
Poiché i metodi statici vengono richiamati senza alcun oggetto della classe, anche se si dispone di un metodo statico con la stessa firma nella classe derivata, non verrà eseguito l'override. Questo perché non esiste polimorfismo di runtime senza un'istanza.
white box vs black box test
Quindi non è possibile sovrascrivere un metodo statico. Ma se esiste un metodo statico con la stessa firma nella classe derivata, il metodo da chiamare non dipende dagli oggetti in fase di esecuzione, ma dipende dal compilatore.
È necessario notare che sebbene i metodi statici non possano essere sovrascritti, il linguaggio Java non fornisce alcun errore del compilatore quando si dispone di un metodo nella classe derivata con la stessa firma di un metodo della classe base.
La seguente implementazione dimostra questo punto.
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(); } } Produzione:
Nel programma precedente, puoi vedere che il metodo statico che viene chiamato non dipende dall'oggetto a cui punta il puntatore. Questo perché gli oggetti non vengono affatto utilizzati con metodi statici.
Blocco statico in Java
Proprio come i blocchi funzione nei linguaggi di programmazione come C ++, C #, ecc. Anche in Java, esiste un blocco speciale chiamato blocco 'statico' che di solito include un blocco di codice relativo ai dati statici.
Questo blocco statico viene eseguito nel momento in cui viene creato il primo oggetto della classe (precisamente al momento del caricamento della classe) o quando viene utilizzato il membro statico all'interno del blocco.
Il seguente programma mostra l'utilizzo di un blocco statico.
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); } } Produzione:
Notare l'ordine di esecuzione delle istruzioni nel programma precedente. Il contenuto del blocco statico viene eseguito per primo, seguito dal programma principale. Le variabili statiche sum e val1 hanno valori iniziali mentre val2 non è inizializzato (il valore predefinito è 0). Quindi nel blocco statico a val2 non viene ancora assegnato un valore e quindi il suo valore viene visualizzato come 0.
Alla variabile val2 viene assegnato un valore dopo la stampa nel blocco statico e la somma viene ricalcolata. Pertanto, nella funzione principale, otteniamo diversi valori di somma e val2.
Se si specifica un costruttore, il contenuto del blocco statico viene eseguito anche prima del costruttore. I blocchi statici vengono utilizzati principalmente per inizializzare i membri statici della classe e altre inizializzazioni relative ai membri statici.
Classe statica Java
In Java, hai blocchi statici, metodi statici e persino variabili statiche. Quindi è ovvio che puoi anche avere classi statiche. In Java, è possibile avere una classe all'interno di un'altra classe e questa è chiamata classe annidata. La classe che racchiude la classe nidificata è chiamata classe Outer.
In Java, sebbene sia possibile dichiarare una classe nidificata come statica, non è possibile avere la classe esterna come statica.
Esploriamo ora le classi annidate statiche in Java.
Classe annidata statica in Java
Come già accennato, puoi avere una classe annidata in Java dichiarata come statica. La classe nidificata statica differisce dalla classe nidificata non statica (classe interna) in alcuni aspetti, come elencato di seguito.
A differenza della classe nidificata non statica, la classe statica nidificata non necessita di un riferimento alla classe esterna.
Una classe annidata statica può accedere solo ai membri statici della classe esterna rispetto alle classi non statiche che possono accedere ai membri statici e non statici della classe esterna.
Di seguito viene fornito un esempio di una classe annidata statica.
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(); } } Produzione:
Nel programma sopra, si vede che la classe annidata statica può accedere alla variabile statica (stringa) dalla classe esterna.
Importazione statica in Java
Come sapete, di solito includiamo vari pacchetti e funzionalità predefinite nel programma Java utilizzando la direttiva 'import'. L'utilizzo della parola statica con la direttiva import consente di utilizzare la funzionalità della classe senza utilizzare il nome della classe.
Esempio:
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'); } } Produzione:
In questo programma, usiamo l'importazione statica per la classe java.lang.System.
Nota: Nella funzione principale, abbiamo appena usato out.println per visualizzare il messaggio.
Sebbene la funzionalità di importazione statica renda il codice più conciso e leggibile, a volte crea ambiguità soprattutto quando alcuni pacchetti hanno le stesse funzioni. Quindi l'importazione statica dovrebbe essere utilizzata solo quando estremamente necessario.
Statico vs Non statico
Parliamo delle principali differenze tra i membri statici e non statici di Java.
Di seguito sono elencate le differenze tra Variabili statiche e non statiche .
| Variabili statiche | Variabili non statiche |
|---|---|
| È possibile accedervi utilizzando solo il nome della classe. | Richiede l'accesso agli oggetti di una classe. |
| Sono accessibili sia ai metodi statici che a quelli non statici. | Sono accessibili solo a metodi non statici. |
| Una memoria per la variabile statica viene allocata solo una volta per classe. | Una memoria per le variabili non statiche viene allocata per oggetto. |
| Condiviso da tutti gli oggetti della classe. | Viene creata una copia della variabile per oggetto. |
| Ha ambito globale ed è disponibile per tutti i metodi e blocchi. | Ha ambito locale ed è visibile agli oggetti della classe. |
Di seguito è riportata la differenza tra metodi statici e non statici .
| Metodi statici | Metodi non statici |
|---|---|
| Un metodo che è preceduto da una parola chiave statica ed è disponibile a livello di classe. | Un metodo non preceduto dalla parola chiave statica e disponibile per ciascuna delle istanze della classe. |
| Supporta la compilazione o l'associazione anticipata. | Supporta il tempo di esecuzione o l'associazione dinamica. |
| Può accedere solo ai membri di dati statici della sua classe e di qualsiasi altra classe. | Può accedere ai membri statici e non statici della classe e di altre classi. |
| I metodi statici non possono essere sovrascritti. | Può essere sovrascritto. |
| La memoria viene allocata solo una volta. Quindi la memoria utilizzata è inferiore. | Il consumo di memoria è maggiore poiché la memoria viene allocata ogni volta che viene richiamato il metodo. |
Statico vs finale
Statico e Finale sono due parole chiave in Java che possono dare un significato speciale all'entità con cui viene utilizzato. Per esempio, quando una variabile viene dichiarata come statica, diventa una variabile di classe a cui è possibile accedere senza un riferimento all'oggetto.
Allo stesso modo, quando una variabile viene dichiarata come finale, diventa immutabile, ovvero una costante.
Tabularizziamo alcune delle principali differenze tra le parole chiave statiche e finali in Java.
| Statico | Finale |
|---|---|
| Un membro dati statico (classe nidificata, variabile o metodo) è un membro dati preceduto da una parola chiave statica e può essere raggiunto senza un oggetto. | La parola chiave finale può essere applicata a una variabile, un metodo, una classe, ecc. e impone restrizioni alle entità. |
| Non è obbligatorio inizializzare la variabile statica con valore durante la dichiarazione. | È necessario che la variabile finale sia inizializzata su un valore al momento della dichiarazione |
| È possibile reinizializzare le variabili statiche. | Non è possibile reinizializzare le variabili finali. |
| I metodi statici sono quelli che possono accedere solo ai membri statici. | I metodi finali sono i metodi che non possono essere ereditati / sovrascritti. |
| Le classi statiche sono classi i cui oggetti non possono essere creati. | Le classi finali sono classi che non possono essere ereditate. |
Domande frequenti
D # 1) La classe Java può essere statica?
Risposta: Sì, una classe in Java può essere statica, a condizione che non sia la classe esterna. Ciò significa che solo le classi nidificate in Java possono essere statiche.
D # 2) Quando dovrei usare Static in Java?
Risposta: Ogni volta che si desidera un membro dati nel programma che mantenga il proprio valore tra gli oggetti, è necessario utilizzare static. Per esempio, un contatore. Un metodo può essere dichiarato statico quando non si desidera richiamarlo utilizzando un oggetto.
D # 3) Una classe statica può avere un costruttore?
Risposta: Sì, una classe statica può avere un costruttore e il suo scopo è esclusivamente quello di inizializzare membri di dati statici. Verrà richiamato solo per la prima volta quando si accede ai membri dei dati. Non verrà richiamato per l'accesso successivo.
Q # 4) Qual è l'uso di Static Constructor?
Risposta: In generale, il costruttore viene utilizzato per inizializzare i membri dati statici. Viene anche utilizzato per eseguire operazioni / azioni che devono essere eseguite una sola volta.
D # 5) I metodi statici vengono ereditati in Java?
Risposta: Sì, i metodi statici in Java vengono ereditati ma non vengono sovrascritti.
Conclusione
In questo tutorial, abbiamo discusso in dettaglio la parola chiave static di Java insieme al suo utilizzo in membri di dati, metodi, blocchi e classi. La parola chiave statica è una parola chiave utilizzata per indicare il livello di classe o l'ambito globale.
domande e risposte dell'intervista pl / sql
Non è necessario accedere ai membri statici utilizzando le istanze della classe. È possibile accedere direttamente ai membri dei dati statici utilizzando il nome della classe. Abbiamo anche discusso delle principali differenze tra membri statici e non statici, nonché parole chiave statiche e finali.
Nei nostri argomenti successivi, esploreremo più parole chiave e il loro significato nel linguaggio Java.
Lettura consigliata
- Statico in C ++
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Distribuzione Java: creazione ed esecuzione di file JAR Java
- Java Virtual Machine: come JVM aiuta nell'esecuzione di applicazioni Java
- Concetti di C #: Constructor, Destructor, Static Class, Struct ed Enum
- Modificatori di accesso in Java - Tutorial con esempi
- Tutorial Java Reflection con esempi
- Introduzione al linguaggio di programmazione Java - Tutorial video