La palabra clave estática se puede utilizar con clase, variable, método y bloque. Los miembros estáticos pertenecen a la clase en lugar de a una instancia específica, lo que significa que si hace que un miembro sea estático, puede acceder a él sin un objeto. Tomemos un ejemplo para entender esto:
Aquí tenemos un método estático myMethod(), podemos llamar a este método sin ningún objeto porque cuando hacemos un miembro estático se convierte en el nivel de clase. Si eliminamos la palabra clave estática y la convertimos en no estática, necesitamos crear un objeto de la clase para llamarla.
Los miembros estáticos son comunes para todas las instancias (objetos) de la clase, pero los miembros no estáticos están separados para cada instancia de la clase.
class SimpleStaticExample
{
// This is a static method
static void myMethod()
{
System.out.println("myMethod");
}
public static void main(String[] args)
{
/* You can see that we are calling this
* method without creating any object.
*/
myMethod();
}
}
Producción:
myMethod
Bloque estático
El bloque estático se utiliza para inicializar variables estáticas y se ejecuta cuando la clase se carga en la memoria. Una clase puede tener múltiples bloques estáticos, que se ejecutarán en la misma secuencia en la que fueron escritos en el programa.
Ejemplo 1: bloque estático único
Como puede ver, ambas variables estáticas se inicializaron antes de acceder a ellas en el método principal.
class JavaExample{
static int num;
static String mystr;
static{
num = 97;
mystr = "Static keyword in Java";
}
public static void main(String args[])
{
System.out.println("Value of num: "+num);
System.out.println("Value of mystr: "+mystr);
}
}
Producción:
Value of num: 97 Value of mystr: Static keyword in Java
Ejemplo 2: múltiples bloques estáticos
Veamos cómo funcionan varios bloques estáticos en Java. Se ejecutan en el orden indicado, lo que significa que el primer bloque estático se ejecuta antes que el segundo bloque estático. Por eso, los valores inicializados por el primer bloque son sobrescritos por el segundo bloque.
class JavaExample2{
static int num;
static String mystr;
//First Static block
static{
System.out.println("Static Block 1");
num = 68;
mystr = "Block1";
}
//Second static block
static{
System.out.println("Static Block 2");
num = 98;
mystr = "Block2";
}
public static void main(String args[])
{
System.out.println("Value of num: "+num);
System.out.println("Value of mystr: "+mystr);
}
}
Producción:
Static Block 1 Static Block 2 Value of num: 98 Value of mystr: Block2
Variables estáticas de Java
Una variable estática es común a todas las instancias (u objetos) de la clase porque es una variable de nivel de clase. En otras palabras, se puede decir que solo se crea y comparte una única copia de la variable estática entre todas las instancias de la clase. La asignación de memoria para estas variables ocurre solo una vez cuando la clase se carga en la memoria.
Pocos puntos importantes:
- Las variables estáticas también se conocen como variables de clase.
- a diferencia de variables no estáticas, puede acceder a estas variables directamente en métodos estáticos y no estáticos.
Ejemplo 1: Se puede acceder a las variables estáticas directamente en el método Static
Aquí tenemos un método estático disp() y dos variables estáticas var1 es var2. Ambas variables son directamente accesibles en el método estático.
class JavaExample3{
static int var1;
static String var2;
//This is a Static Method
static void disp(){
System.out.println("Var1 is: "+var1);
System.out.println("Var2 is: "+var2);
}
public static void main(String args[])
{
disp();
}
}
Producción:
Var1 is: 0 Var2 is: null
Ejemplo 2: las variables estáticas se comparten entre todas las instancias de clase
En este ejemplo, la variable String no es estática y la variable entera es estática. Como puede ver en la salida, la variable no estática es diferente para ambos objetos, pero la variable estática se comparte entre ellos, es por eso que los cambios realizados en la variable estática por objeto ob2 se refleja en ambos objetos.
class JavaExample{
//Static integer variable
static int var1=77;
//non-static string variable
String var2;
public static void main(String args[])
{
JavaExample ob1 = new JavaExample();
JavaExample ob2 = new JavaExample();
/* static variables can be accessed directly without
* any instances. Just to demonstrate that static variables
* are shared, I am accessing them using objects so that
* we can check that the changes made to static variables
* by one object, reflects when we access them using other
* objects
*/
//Assigning the value to static variable using object ob1
ob1.var1=88;
ob1.var2="I'm Object1";
/* This will overwrite the value of var1 because var1 has a single
* copy shared among both the objects.
*/
ob2.var1=99;
ob2.var2="I'm Object2";
System.out.println("ob1 integer:"+ob1.var1);
System.out.println("ob1 String:"+ob1.var2);
System.out.println("ob2 integer:"+ob2.var1);
System.out.println("ob2 STring:"+ob2.var2);
}
}
Producción:
ob1 integer:99 ob1 String:I'm Object1 ob2 integer:99 ob2 STring:I'm Object2
Para obtener más detalles sobre consulte: Java – variable estática
Métodos estáticos de Java
Los métodos estáticos pueden acceder a las variables de clase (variables estáticas) sin usar el objeto (instancia) de la clase, sin embargo, solo se puede acceder a los métodos y variables no estáticos usando objetos.
Se puede acceder a los métodos estáticos directamente en métodos estáticos y no estáticos.
Sintaxis:
Palabra clave estática seguida del tipo de retorno, seguida del nombre del método.
static return_type method_name();
Ejemplo 1: el método estático principal accede a variables estáticas sin ningún objeto
class JavaExample{
static int i = 10;
static String s = "Beginnersbook";
//This is a static method
public static void main(String args[])
{
System.out.println("i:"+i);
System.out.println("s:"+s);
}
}
Producción:
i:10 s:Beginnersbook
Ejemplo 2: método estático al que se accede directamente en el método estático y no estático
class JavaExample{
static int i = 100;
static String s = "Beginnersbook";
//Static method
static void display()
{
System.out.println("i:"+i);
System.out.println("i:"+s);
}
//non-static method
void funcn()
{
//Static method called in non-static method
display();
}
//static method
public static void main(String args[])
{
JavaExample obj = new JavaExample();
//You need to have object to call this non-static method
obj.funcn();
//Static method called in another static method
display();
}
}
Producción:
i:100 i:Beginnersbook i:100 i:Beginnersbook
Más información: método estático vs método no estático en Java
Clase estática
Puedes tomar una lección estático solo si es una clase anidada.
- La clase estática anidada no necesita hacer referencia a la clase externa
- Una clase estática no puede acceder a miembros no estáticos de la clase externa
Veremos estos dos puntos con la ayuda de un ejemplo:
Ejemplo de clase estática
class JavaExample{
private static String str = "BeginnersBook";
//Static class
static class MyNestedClass{
//non-static method
public void disp() {
/* If you make the str variable of outer class
* non-static then you will get compilation error
* because: a nested static class cannot access non-
* static members of the outer class.
*/
System.out.println(str);
}
}
public static void main(String args[])
{
/* To create instance of nested class we didn't need the outer
* class instance but for a regular nested class you would need
* to create an instance of outer class first
*/
JavaExample.MyNestedClass obj = new JavaExample.MyNestedClass();
obj.disp();
}
}
Producción:
BeginnersBook