in

En términos simples, ¿qué significa «estático» en Java?

apple touch icon@2

La palabra clave estática se puede usar de varias maneras diferentes en Java y en casi todos los casos es un modificador, lo que significa lo que está modificando. se puede utilizar sin una instancia de objeto adjunta.

Java es un lenguaje orientado a objetos y, de forma predeterminada, la mayoría del código que escribe requiere una instancia del objeto que se utilizará.

public class SomeObject {
    public int someField;
    public void someMethod() { };
    public Class SomeInnerClass { };
}

Para usar someField, someMethod o SomeInnerClass Primero tengo que crear una instancia de SomeObject.

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObject anInstance = new SomeObject();
        anInstance.someField = 7;
        anInstance.someMethod();
        //Non-static inner classes are usually not created outside of the
        //class instance so you don't normally see this syntax
        SomeInnerClass blah = anInstance.new SomeInnerClass();
    }
}

Si declaro esas cosas estáticas, entonces no requieren una instancia adjunta.

public class SomeObjectWithStaticStuff {
    public static int someField;
    public static void someMethod() { };
    public static Class SomeInnerClass { };
}

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someMethod();
        SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass();
        //Or you can also do this if your imports are correct
        SomeInnerClass blah2 = new SomeInnerClass();
    }
}

Declarar algo estático tiene varias implicaciones.

Primero, solo puede haber un valor de un campo estático en toda su aplicación.

public class SomeOtherObject {
    public void doSomeStuff() {
        //Two objects, two different values
        SomeObject instanceOne = new SomeObject();
        SomeObject instanceTwo = new SomeObject();
        instanceOne.someField = 7;
        instanceTwo.someField = 10;
        //Static object, only ever one value
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someField = 10; //Redefines the above set
    }
}

El segundo problema es que Los métodos estáticos y las clases internas no pueden acceder a los campos del objeto adjunto. (ya que no hay uno).

public class SomeObjectWithStaticStuff {
    private int nonStaticField;
    private void nonStaticMethod() { };

    public static void someStaticMethod() {
        nonStaticField = 7; //Not allowed
        this.nonStaticField = 7; //Not allowed, can never use *this* in static
        nonStaticMethod(); //Not allowed
        super.someSuperMethod(); //Not allowed, can never use *super* in static
    }

    public static class SomeStaticInnerClass {

        public void doStuff() {
            someStaticField = 7; //Not allowed
            nonStaticMethod(); //Not allowed
            someStaticMethod(); //This is ok
        }

    }
}

La palabra clave estática también se puede aplicar a interfaces internas, anotaciones y enumeraciones.

public class SomeObject {
    public static interface SomeInterface { };
    public static @interface SomeAnnotation { };
    public static enum SomeEnum { };
}

En todos estos casos, la palabra clave es redundante y no tiene ningún efecto. Las interfaces, anotaciones y enumeraciones son estáticas de forma predeterminada porque nunca tienen una relación con una clase interna.

Esto solo describe lo que hace la palabra clave. No describe si el uso de la palabra clave es una mala idea o no. Eso se puede cubrir con más detalle en otras preguntas como ¿Es malo usar muchos métodos estáticos?

También hay algunos usos menos comunes de la palabra clave static. Hay importaciones estáticas que le permiten utilizar tipos estáticos (incluidas interfaces, anotaciones y enumeraciones no marcadas de forma redundante como estáticas) sin calificar.

//SomeStaticThing.java
public class SomeStaticThing {
    public static int StaticCounterOne = 0;
}

//SomeOtherStaticThing.java
public class SomeOtherStaticThing {
    public static int StaticCounterTwo = 0;
}

//SomeOtherClass.java
import static some.package.SomeStaticThing.*;
import some.package.SomeOtherStaticThing.*;

public class SomeOtherClass {
    public void doStuff() {
        StaticCounterOne++; //Ok
        StaticCounterTwo++; //Not ok
        SomeOtherStaticThing.StaticCounterTwo++; //Ok
    }
}

Por último, hay inicializadores estáticos que son bloques de código que se ejecutan cuando la clase se carga por primera vez (que es generalmente justo antes de que se cree una instancia de una clase por primera vez en una aplicación) y (como los métodos estáticos) no puede acceder a campos o métodos no estáticos.

public class SomeObject {

    private static int x;

    static {
        x = 7;
    }
}

Deja una respuesta

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

expressjs

Tutorial de ExpressJS

gfg 200x200 min

3 formas diferentes de imprimir series de Fibonacci en Java