usar - ¿Cuál es el uso de una variable estática privada en Java?

private static java

Question

Si una variable se declara como public static varName; , entonces puedo acceder desde cualquier lugar como ClassName.varName . También sé que los miembros estáticos son compartidos por todas las instancias de una clase y no se reasignan en cada instancia.

Declara una variable como private static varName; cualquiera diferente de declarar un private varName; variable private varName; ?

En ambos casos, no se puede acceder como ClassName.varName o como ClassInstance.varName desde ninguna otra clase.

¿Decir que la variable es estática le da otras propiedades especiales?

Answer 1

Declara una variable como private static varName; cualquiera diferente de declarar un private varName; variable private varName; ?

Sí, ambos son diferentes. Y el primero se llama class variable porque contiene un valor único para esa class mientras que el otro se llama instance variable porque puede contener un valor diferente para diferentes instances(Objects) . El primero se crea solo una vez en jvm y el otro se crea una vez por instancia; es decir, si tiene 10 instancias, entonces tendrá 10 private varName; diferentes private varName; en jvm.

¿Decir que la variable es static le da otras propiedades especiales?

Sí, las variables estáticas obtienen algunas propiedades diferentes a las variables de instancia normales. Ya he mencionado algunos y veamos algunos aquí: se puede acceder directamente a las class variables ( class variables instancia declaradas como estáticas) utilizando el nombre de clase como ClassName.varName . Y cualquier objeto de esa clase puede acceder y modificar su valor, a diferencia de las variables de instancia a las que solo acceden sus respectivos objetos. Las variables de clase se pueden usar en métodos estáticos.

¿Cuál es el uso de una private static variable en Java?

Lógicamente, private static variable no es diferente de public static variable sino que la primera le da más control. IMO, puede reemplazar literalmente public static variable por private static variable con la ayuda de métodos public static getter y setter public static .

Un área ampliamente utilizada de private static variable encuentra en la implementación del patrón sencillo de Singleton , donde solo tendrá una instancia única de esa clase en todo el mundo. Aquí static identificador static desempeña un papel crucial para hacer que esa única instancia sea accesible por el mundo exterior (por supuesto, el método getter estático público también juega un rol principal).

public class Singleton {
    private static Singleton singletonInstance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return Singleton.singletonInstance;
    }
}

Answer 2

¿Para qué sirve una variable de clase privada estática?

Digamos que tienes una clase de libro de la biblioteca. Cada vez que creas un nuevo libro, quieres asignarle un ID único. Una forma es simplemente comenzar en 0 e incrementar el número de identificación. Pero, ¿cómo saben los demás libros el último número de identificación creado? Simple, guárdelo como una variable estática. ¿Los usuarios necesitan saber que el número de identificación interna real es para cada libro? No. Esa información es privada.

public class Book {
    private static int numBooks = 0;
    private int id;
    public String name;

    Book(String name) {
        id = numBooks++;
        this.name = name;
    }
}

Este es un ejemplo artificial, pero estoy seguro de que puede pensar fácilmente en los casos en los que desea que todas las instancias de la clase tengan acceso a información común que debe mantenerse privada de todos los demás. O incluso si no puedes, es una buena práctica de programación hacer las cosas lo más privadas posible. ¿Qué pasa si accidentalmente hiciste público ese campo numBooks, aunque se suponía que los usuarios de Book no deberían hacer nada con él? Entonces, alguien podría cambiar la cantidad de libros sin crear un nuevo libro.

Muy furtivo!

Answer 3

*) Si una variable se declara como privada, no se puede ver fuera de la clase. Esto se conoce como ocultación de datos.

*) Si una variable se declara como estática, el valor de la variable es el mismo para todas las instancias y no es necesario crear un objeto para llamar a esa variable. Podemos invocar esa variable simplemente

classname.variablename;

Answer 4

Bien, tiene razón, las variables públicas estáticas se usan sin hacer una instancia de la clase, pero las variables estáticas privadas no. La principal diferencia entre ellos y donde uso las variables estáticas privadas es cuando necesitas usar una variable en una función estática. Para las funciones estáticas solo puedes usar variables estáticas, por lo que las haces privadas para no acceder a ellas desde otras clases. Ese es el único caso en el que utilizo estática privada.

Aquí hay un ejemplo:

Class test {
   public static String name = "AA";
   private static String age;

   public static void setAge(String yourAge) {
       //here if the age variable is not static you will get an error that you cannot access non static variables from static procedures so you have to make it static and private to not be accessed from other classes
       age = yourAge;
   }
}

Answer 5

Bueno, private static variables private static se pueden usar para compartir datos entre instancias de esa clase. Si bien tiene razón al decir que no podemos acceder a las variables private static utilizando construcciones como ClassName.member o ClassInstance.member el miembro siempre será visible desde los métodos de esa clase o instancias de esa clase. Entonces, en efecto, las instancias de esa clase siempre podrán referirse al miembro.

Answer 6

Cuando en un método estático utiliza una variable, la variable también debe ser estática como ejemplo:

private static int a=0;  
public static void testMethod() {  
        a=1;  
}

Answer 7

En el siguiente ejemplo, EyeB cambia la vista, mientras que la leg permanece igual. Esto se debe a que una variable privada hace una copia de sí mismo al método, de modo que su valor original permanece igual; mientras que un valor estático privado solo tiene una copia para todos los métodos para compartir, por lo que editar su valor cambiará su valor original.

public class test {
private static int eye=2;
private int leg=3;

public test (int eyes, int legs){
    eye = eyes;
    leg=leg;
}

public test (){
}

public void print(){
    System.out.println(eye);
    System.out.println(leg);
}

public static void main(String[] args){
    test PersonA = new test();      
    test PersonB = new test(14,8);
    PersonA.print();    
}

}

> 14 3

Answer 8

La palabra clave privada se usará para el acceso variable dentro de la clase y para mantener la estática en el sentido en que también podemos acceder a la variable en el método estático, pero la variable de referencia no puede acceder en el método estático.

Answer 9

Las variables de ThreadLocal se implementan típicamente como privadas estáticas. De esta forma, no están vinculados a la clase y cada subproceso tiene su propia referencia a su propio objeto "threadLocal".

Answer 10

Las variables estáticas privadas son útiles de la misma forma que las variables de instancia privadas son útiles: almacenan el estado al que se accede solo por código dentro de la misma clase. La accesibilidad (privada / pública / etc.) y la naturaleza instancia / estática de la variable son conceptos completamente ortogonales.

Evitaría pensar en variables estáticas como compartidas entre "todas las instancias" de la clase, lo que sugiere que debe haber al menos una instancia para que el estado esté presente. No, una variable estática está asociada con el tipo en sí en lugar de cualquier instancia del tipo.

Por lo tanto, cada vez que desee un estado que esté asociado con el tipo en lugar de una instancia particular, y desee mantener ese estado privado (tal vez permitiendo el acceso controlado a través de propiedades, por ejemplo), tiene sentido tener una variable privada estática.

Como comentario aparte, recomendaría encarecidamente que el único tipo de variables que haga públicas (o incluso no privadas) sean constantes: variables estáticas finales de tipos inmutables. Todo lo demás debe ser privado para separar la API y la implementación (entre otras cosas).

Answer 11

Las variables estáticas son aquellas variables que son comunes para todas las instancias de una clase ... si una instancia lo cambia ... entonces el valor de la variable estática se actualizaría para todas las demás instancias.

Answer 12

Las variables estáticas tienen un único valor para todas las instancias de una clase.

Si tuviera que hacer algo como:

public class Person
{
    private static int numberOfEyes;
    private String name;
}

y luego quisiste cambiar tu nombre, está bien, mi nombre permanece igual. Si, por más que quisieras cambiarlo para que tuvieras 17 ojos, todos en el mundo también tendrían 17 ojos.

Answer 13

Otra perspectiva:

1. Una clase y su instancia son dos cosas diferentes en el tiempo de ejecución. Una información de clase es "compartida" por todas las instancias de esa clase.
2. Las variables de clase no estáticas pertenecen a las instancias y la variable estática pertenece a la clase.
3. Al igual que las variables de instancia pueden ser privadas o públicas, las variables estáticas también pueden ser privadas o públicas.

Answer 14

Para algunas personas, esto tiene más sentido si lo ven en un par de idiomas diferentes, así que escribí un ejemplo en Java y PHP en mi página donde explico algunos de estos modificadores. Usted podría estar pensando en esto incorrectamente.

Deberías mirar mis ejemplos si no tiene sentido a continuación. Vaya aquí http://www.siteconsortium.com/h/D0000D.php

La conclusión es que es exactamente lo que dice que es. Es una variable de miembro estática que es privada. Por ejemplo, si desea crear un objeto Singleton, ¿por qué quiere que la variable SingletonExample.instance sea pública? Si lo hiciera, una persona que estaba usando la clase podría sobrescribir fácilmente el valor.

Eso es todo lo que es.

public class SingletonExample { private static SingletonExample instance = null; private static int value = 0; private SingletonExample() { ++this.value; } public static SingletonExample getInstance() { if(instance!=null) return instance; synchronized(SingletonExample.class) { instance = new SingletonExample(); return instance; } } public void printValue() { System.out.print( this.value ); } public static void main(String [] args) { SingletonExample instance = getInstance(); instance.printValue(); instance = getInstance(); instance.printValue(); } }

Answer 15

Por supuesto, se puede acceder como ClassName.var_name , pero solo desde dentro de la clase en la que está definido, porque es private .

public static variables public static o public static menudo se usan para constantes. Por ejemplo, a muchas personas no les gusta las constantes de "código rígido" en su código; les gusta crear una variable public static o private static con un nombre significativo y usarla en su código, lo que debería hacer que el código sea más legible. (También debe hacer tales constantes final ).

Por ejemplo:

public class Example {
    private final static String JDBC_URL = "jdbc:mysql://localhost/shopdb";
    private final static String JDBC_USERNAME = "username";
    private final static String JDBC_PASSWORD = "password";

    public static void main(String[] args) {
        Connection conn = DriverManager.getConnection(JDBC_URL,
                                         JDBC_USERNAME, JDBC_PASSWORD);

        // ...
    }
}

Si lo haces public o private depende de si quieres que las variables sean visibles fuera de la clase o no.

Answer 16

Si una variable se define como pública estática, se puede acceder a través de su clase de cualquier clase.

Por lo general, las funciones se definen como estáticas públicas a las que se puede acceder simplemente llamando al nombre de la clase implementadora.

Un muy buen ejemplo de esto es el método sleep() en la clase Thread

Thread.sleep(2500);

Si una variable se define como privada estática, solo se puede acceder a ella dentro de esa clase, por lo que no es necesario el nombre de la clase o aún puede usar el nombre de la clase (hasta usted). La diferencia entre private var_name y private static var_name es que las variables estáticas privadas se pueden acceder solo mediante métodos estáticos de la clase, mientras que las variables privadas se pueden acceder mediante cualquier método de esa clase (excepto los métodos estáticos)

Un buen ejemplo de ello es cuando se definen conexiones de bases de datos o constantes que requieren declarar la variable como privada estática.

Otro ejemplo común es

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

Answer 17

Si usa variables estáticas privadas en su clase, las clases internas estáticas en su clase pueden alcanzar sus variables. Esto es perfectamente bueno para la seguridad del contexto.

Answer 18

Soy nuevo en Java, pero una forma de usar variables estáticas, como supongo que muchas personas lo hacen, es contar el número de instancias de la clase. p.ej:

public Class Company {
    private static int numCompanies;

    public static int getNumCompanies(){
        return numCompanies;
    }
}

Entonces puedes sysout:

Company.getNumCompanies();

También puede obtener acceso a numCompanies desde cada instancia de la clase (que no entiendo completamente), pero no será de una "manera estática". No tengo idea si esto es una buena práctica o no, pero tiene sentido para mí.

Answer 19

la variable estática privada se compartirá también en la subclase. Si cambió en una subclase y la otra subclase obtendrá el valor modificado, en cuyo caso, puede que no sea lo que espera.

public class PrivateStatic {

private static int var = 10;
public void setVar(int newVal) {
    var = newVal;
}

public int getVar() {
    return var;
}

public static void main(String... args) {
    PrivateStatic p1 = new Sub1();
    System.out.println(PrivateStatic.var);
    p1.setVar(200);

    PrivateStatic p2 = new Sub2();
    System.out.println(p2.getVar());
}
}


class Sub1 extends PrivateStatic {

}

class Sub2 extends PrivateStatic {
}