Palabra clave estática en Java

La palabra clave estática en Java se utiliza principalmente para la gestión de la memoria. La palabra clave estática en Java se usa para compartir la misma variable o método de una clase determinada. Los usuarios pueden aplicar palabras clave estáticas con variables, métodos, bloques y clases anidadas. La palabra clave estática pertenece a la clase que una instancia de la clase. La palabra clave estática se usa para una variable constante o un método que es el mismo para cada instancia de una clase.

La palabra clave estática es un modificador de no acceso en Java que se aplica a lo siguiente: 

1. bloques
2. Variables
3. Métodos
4. Clases

Nota: Para crear un miembro estático (bloque, variable, método, clase anidada), precede su declaración con la palabra clave estática . 

Cuando un miembro se declara estático, se puede acceder a él antes de que se cree cualquier objeto de su clase y sin referencia a ningún objeto. Por ejemplo, en el siguiente programa java, estamos accediendo al método estático m1() sin crear ningún objeto de la clase Test . 

// Java program to demonstrate that a static member
// can be accessed before instantiating a class
  
class Test
{
    // static method
    static void m1()
    {
        System.out.println("from m1");
    }
  
    public static void main(String[] args)
    {
          // calling m1 without creating
          // any object of class Test
           m1();
    }
}

from m1

Bloques estáticos

Si necesita hacer el cálculo para inicializar sus variables estáticas , puede declarar un bloque estático que se ejecuta exactamente una vez, cuando la clase se carga por primera vez. 

Considere el siguiente programa Java que demuestra el uso de bloques estáticos. 

// Java program to demonstrate use of static blocks
  
class Test
{
    // static variable
    static int a = 10;
    static int b;
      
    // static block
    static {
        System.out.println("Static block initialized.");
        b = a * 4;
    }
  
    public static void main(String[] args)
    {
       System.out.println("from main");
       System.out.println("Value of a : "+a);
       System.out.println("Value of b : "+b);
    }
}

Static block initialized.
from main
Value of a : 10
Value of b : 40

Para obtener un artículo detallado sobre bloques estáticos, consulte bloques estáticos

Variables estáticas

Cuando una variable se declara como estática, se crea una sola copia de la variable y se comparte entre todos los objetos en el nivel de clase. Las variables estáticas son, esencialmente, variables globales. Todas las instancias de la clase comparten la misma variable estática.

Puntos importantes para las variables estáticas:

• Podemos crear variables estáticas solo a nivel de clase. Ver aquí
• El bloque estático y las variables estáticas se ejecutan en el orden en que están presentes en un programa.

A continuación se muestra el programa Java para demostrar que el bloque estático y las variables estáticas se ejecutan en el orden en que están presentes en un programa. 

// Java program to demonstrate execution
// of static blocks and variables
  
class Test
{
    // static variable
    static int a = m1();
      
    // static block
    static {
        System.out.println("Inside static block");
    }
      
    // static method
    static int m1() {
        System.out.println("from m1");
        return 20;
    }
      
    // static method(main !!)
    public static void main(String[] args)
    {
       System.out.println("Value of a : "+a);
       System.out.println("from main");
    }
}

from m1
Inside static block
Value of a : 20
from main

Métodos estáticos

Cuando un método se declara con la palabra clave estática , se conoce como método estático. El ejemplo más común de un método estático es el método main() . Como se discutió anteriormente, se puede acceder a cualquier miembro estático antes de que se cree cualquier objeto de su clase y sin referencia a ningún objeto. Los métodos declarados como estáticos tienen varias restricciones: 

• Solo pueden llamar directamente a otros métodos estáticos.
• Solo pueden acceder directamente a datos estáticos.
• No pueden referirse a esto o super de ninguna manera.

A continuación se muestra el programa java para demostrar las restricciones de los métodos estáticos.

// Java program to demonstrate restriction on static methods
  
class Test
{
    // static variable
    static int a = 10;
      
    // instance variable
    int b = 20;
      
    // static method
    static void m1()
    {
        a = 20;
        System.out.println("from m1");
          
         // Cannot make a static reference to the non-static field b
         b = 10; // compilation error
                  
         // Cannot make a static reference to the 
                 // non-static method m2() from the type Test
         m2();  // compilation error
           
         //  Cannot use super in a static context
         System.out.println(super.a); // compiler error 
    }
      
    // instance method
    void m2()
    {    
        System.out.println("from m2");
    }
      
      
      
    public static void main(String[] args)
    {
        // main method 
    }
}

Producción:

prog.java:18: error: non-static variable b cannot be referenced from a static context
         b = 10; // compilation error
         ^
prog.java:22: error: non-static method m2() cannot be referenced from a static context
         m2();  // compilation error
         ^
prog.java:25: error: non-static variable super cannot be referenced from a static context
         System.out.println(super.a); // compiler error 
                            ^
prog.java:25: error: cannot find symbol
         System.out.println(super.a); // compiler error 
                                 ^
  symbol: variable a
4 errors

¿Cuándo usar variables y métodos estáticos?

Utilice la variable estática para la propiedad que es común a todos los objetos. Por ejemplo, en la clase Estudiante, todos los estudiantes comparten el mismo nombre de universidad. Use métodos estáticos para cambiar variables estáticas.

Considere el siguiente programa Java, que ilustra el uso de palabras clave estáticas con variables y métodos.

// A java program to demonstrate use of
// static keyword with methods and variables
  
// Student class
class Student {
    String name;
    int rollNo;
  
    // static variable
    static String cllgName;
  
    // static counter to set unique roll no
    static int counter = 0;
  
    public Student(String name)
    {
        this.name = name;
  
        this.rollNo = setRollNo();
    }
  
    // getting unique rollNo
    // through static variable(counter)
    static int setRollNo()
    {
        counter++;
        return counter;
    }
  
    // static method
    static void setCllg(String name) { cllgName = name; }
  
    // instance method
    void getStudentInfo()
    {
        System.out.println("name : " + this.name);
        System.out.println("rollNo : " + this.rollNo);
  
        // accessing static variable
        System.out.println("cllgName : " + cllgName);
    }
}
  
// Driver class
public class StaticDemo {
    public static void main(String[] args)
    {
        // calling static method
        // without instantiating Student class
        Student.setCllg("XYZ");
  
        Student s1 = new Student("Alice");
        Student s2 = new Student("Bob");
  
        s1.getStudentInfo();
        s2.getStudentInfo();
    }
}

name : Alice
rollNo : 1
cllgName : XYZ
name : Bob
rollNo : 2
cllgName : XYZ

Clases estáticas 

Una clase puede hacerse  estática  solo si es una clase anidada. No podemos declarar una clase de nivel superior con un modificador estático, pero podemos declarar clases anidadas como estáticas. Estos tipos de clases se denominan clases estáticas anidadas. La clase estática anidada no necesita una referencia de clase externa. En este caso, una clase estática no puede acceder a miembros no estáticos de la clase Outer. 

Nota: para la clase anidada estática, vea una clase anidada estática en Java

Implementación:

// A java program to demonstrate use
// of static keyword with Classes
  
import java.io.*;
  
public class GFG {
  
    private static String str = "GeeksforGeeks";
  
    // Static class
    static class MyNestedClass {
        
        // non-static method
        public void disp(){ 
          System.out.println(str); 
        }
    }
    
    public static void main(String args[])
    {
        GFG.MyNestedClass obj
            = new GFG.MyNestedClass();
        obj.disp();
    }
}

GeeksforGeeks

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.