¿Para qué sirve una variable estática privada en Java?

Si una variable se declara como public static varName;, entonces puedo acceder a ella 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.

¿Declarar una variable como private static varName;algo diferente de declarar una variable private varName;?

En ambos casos, no se puede acceder como ClassName.varNameo como ClassInstance.varNamede cualquier otra clase.

¿Declarar la variable como estática le da otras propiedades especiales?

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

public statico las private staticvariables se usan a menudo para constantes. Por ejemplo, a muchas personas no les gusta "codificar" constantes en su código; les gusta hacer una public statico private staticvariable con un nombre significativo y usarlo 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 hace publico privatedepende de si desea que las variables sean visibles fuera de la clase o no.

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

Si hicieras algo como:

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

y luego quisiste cambiar tu nombre, está bien, mi nombre sigue siendo el mismo. Sin embargo, si quisieras cambiarlo para tener 17 ojos, todos en el mundo también tendrían 17 ojos.

Las variables estáticas privadas son útiles de la misma manera que las variables de instancias privadas: almacenan el estado al que solo se accede mediante 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 que las variables estáticas se comparten entre "todas las instancias" de la clase, lo que sugiere que tiene que 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.

Entonces, cada vez que desee algún estado asociado con el tipo en lugar de cualquier instancia en 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 estática privada.

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

Bueno, tienes razón, las variables públicas estáticas se utilizan sin hacer una instancia de la clase, pero las variables estáticas privadas no. La principal diferencia entre ellos y dónde uso las variables privadas estáticas es cuando necesitas usar una variable en una función estática. Para las funciones estáticas solo puede usar variables estáticas, por lo que las hace privadas para no acceder a ellas desde otras clases. Ese es el único caso para el que utilizo static static.

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;
   }
}

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

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

Digamos que tienes un libro de biblioteca Clase. Cada vez que crea un nuevo libro, desea asignarle una identificación única. Una forma es simplemente comenzar en 0 e incrementar el número de identificación. Pero, ¿cómo saben todos los otros 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 interno 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 casos en los que desearía 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 puede, es una buena práctica de programación hacer las cosas lo más privadas posible. ¿Qué pasaría si accidentalmente hiciera público ese campo numBooks, aunque no se suponía que los usuarios de Book hicieran nada con él? Entonces alguien podría cambiar el número de libros sin crear un nuevo libro.

Muy astuto!

¿Declarar una variable como private static varName;algo diferente de declarar una variable private varName;?

Sí, ambos son diferentes. Y el primero se llama class variableporque tiene un valor único para eso, classmientras que el otro se llama instance variableporque puede tener 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, tendrá 10 diferentes private varName;en jvm.

¿Declarar la variable como staticle da otras propiedades especiales?

Sí, las variables estáticas obtienen algunas propiedades diferentes a las variables de instancia normales. Ya mencioné algunos y veamos algunos aquí: class variables(se puede acceder directamente a las variables de instancia que se declaran como estáticas) usando el nombre de clase like 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 objetos respectivos. Las variables de clase se pueden usar en métodos estáticos.

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

Lógicamente, private static variableno es diferente de public static variablela primera, te da más control. OMI, literalmente puedes reemplazarpublic static variable por private static variablela ayuda de public staticmétodos get y set.

Un área ampliamente utilizada private static variablees la implementación de un Singletonpatrón simple donde tendrá una sola instancia de esa clase en todo el mundo. Aquí el staticidentificador juega un papel crucial para hacer que esa instancia única sea accesible para el mundo exterior (por supuesto, el método público de obtención estática también juega un papel principal).

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

    private Singleton(){}

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

La palabra clave privada se usará para el acceso variable dentro de la clase y para mantener la estática en el sentido de 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.

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 instancias y la variable estática pertenece a 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.

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

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

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

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. Quizás estés 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 casi exactamente lo que dice que es. Es una variable miembro estática que es privada. Por ejemplo, si desea crear un objeto Singleton, ¿por qué desea hacer pública la variable SingletonExample.instance? Si lo hiciera, una persona que estaba usando la clase podría sobrescribir fácilmente el valor.

Eso es todo lo que es.

    clase pública SingletonExample {
      instancia de SingletonExample estática privada = nulo;
      valor int estático privado = 0;
      private SingletonExample () {
        ++ this.value;
      }
      Public static SingletonExample getInstance () {
        if (instancia! = nulo)
        instancia de retorno;
        sincronizado (SingletonExample.class) {
        instancia = new SingletonExample ();
        instancia de retorno;
        }
      }
      public void printValue () {
        System.out.print (this.value);
      }

      public static void main (String [] args) {
        SingletonExample instancia = getInstance ();
        instance.printValue ();
        instancia = getInstance ();
        instance.printValue ();
         }
    }

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.

Si una variable se define como estática pública, se puede acceder a ella a través de su nombre de clase desde 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 ello es el sleep()método en la clase Thread

Thread.sleep(2500);

Si una variable se define como estática privada, solo se puede acceder a ella dentro de esa clase, por lo que no se necesita un nombre de 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 solo se puede acceder a las variables privadas estáticas mediante métodos estáticos de la clase, mientras que a las variables privadas se puede acceder mediante cualquier método de esa clase (excepto los métodos estáticos)

Un muy buen ejemplo de ello es definir definiciones de conexiones o constantes de bases de datos que requieren declarar variables como estáticas privadas.

Otro ejemplo común es

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

Soy nuevo en Java, pero una forma en que uso 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 esta es la mejor práctica o no, pero tiene sentido para mí.

*) Si una variable se declara como privada, entonces no es visible fuera de la clase. Esto se llama 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 llamar a esa variable simplemente

classname.variablename;

La variable estática privada también se compartirá en la subclase. Si cambió en una subclase y la otra subclase obtendrá el valor cambiado, 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 {
}

ThreadLocalLas variables se implementan típicamente como private static. De esta manera, no están vinculados a la clase y cada hilo tiene su propia referencia a su propio objeto "ThreadLocal".

En el siguiente ejemplo, eyees cambiado por PersonB, mientras legpermanece igual. Esto se debe a que una variable privada hace una copia de sí misma en el 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