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.
leer  Método que anula en java con ejemplo

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

leer  Herencia jerárquica en java con programa de ejemplo

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.

  1. La clase estática anidada no necesita hacer referencia a la clase externa
  2. 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

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *