Что такое использование частной статической переменной в Java?

статические переменные имеют одно значение для всех экземпляров класса.

Если вы должны были сделать что-то вроде:

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

а потом вы хотели изменить свое имя, это нормально, мое имя остается прежним. Если бы, однако, вы хотели изменить его так, чтобы у вас было 17 глаз, тогда у всех в мире также было бы 17 глаз.

частные статические переменные полезны так же, как и частные переменные экземпляра: они хранят состояние, к которому обращается только код в том же классе. Доступность (частная/публичная/etc) и экземпляр/статическая природа переменной являются полностью ортогональными понятиями.

Я бы избегал думать о статических переменных как разделяемых между "всеми экземплярами" класса-это предполагает, что должно быть по крайней мере один экземпляр для государства присутствовать. Нет-статическая переменная связана с самим типом вместо любой экземпляров типа.

поэтому в любое время, когда вам нужно какое-то состояние, связанное с типом, а не с каким-либо конкретным экземпляром, и вы хотите сохранить это состояние частным (например, разрешить контролируемый доступ через свойства), имеет смысл иметь частную статическую переменную.

в стороне, я бы настоятельно рекомендовал, чтобы только тип переменные, которые вы делаете открытыми (или даже не частными), являются константами-статическими конечными переменными неизменяемых типов. Все остальное должно быть частным ради разделения API и реализации (среди прочего).

Ну private static переменные могут использоваться для обмена данными между экземплярами этого класса. Хотя вы правы, что мы не можем получить доступ к private static переменные, используя конструкции типа ClassName.member или ClassInstance.member но член всегда будет виден из методов этого класса или экземпляров этого класса. Таким образом, в действительности экземпляры этого класса всегда смогут ссылаться на член.

Ну вы правы публичные статические переменные используются без создания экземпляра класса, но частные статические переменные не являются. Основное различие между ними и где я использую частные статические переменные, когда вам нужно использовать переменную в статической функции. Для статических функций можно использовать только статические переменные, поэтому вы делаете их закрытыми, чтобы не получать к ним доступ из других классов. Это единственный случай, для которого я использую private static.

здесь пример:

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

что такое использование частной статической переменной класса?

допустим, у вас есть класс библиотечной книги. Каждый раз, когда вы создаете новую книгу, вы хотите назначить ей уникальный идентификатор. Один из способов - просто начать с 0 и увеличить идентификационный номер. Но, как все остальные книги знают последний созданный идентификационный номер? Просто, сохраните его как статическую переменную. Клиенты должны знать, что фактический внутренний идентификационный номер для каждой книги? Нет. Эта информация является частной.

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

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

Это надуманный пример, но я уверен, что вы можете легко придумать случаи, когда вы хотите, чтобы все экземпляры класса имели доступ к общей информации, которая должна быть закрыта от всех остальных. Или даже если вы не можете, это хорошая практика программирования, чтобы сделать вещи как можно более частным. Что, если вы случайно сделали это поле numBooks общедоступным, хотя пользователи книг не должны были ничего с ним делать. Тогда кто-то может изменить количество книг, не создавая новую книгу.

очень подлый!

объявляет переменную как private static varName; отличается от объявление переменной private varName;?

да, оба разные. И первый из них называется class variable потому что он содержит одно значение для этого class в то время как другой называется instance variable потому что он может содержать разные значения для разных instances(Objects). Первый создается только один раз в jvm, а другой создается один раз на экземпляр, т. е. если у вас есть 10 экземпляров, то у вас будет 10 разных private varName; в jvm.

делает объявление переменной как static дать ему другие специальные недвижимость?

да, статические переменные получают некоторые другие свойства, чем обычные переменные экземпляра. Я уже упоминал несколько, и давайте посмотрим некоторые здесь:class variables (переменные экземпляра, которые объявлены как статические) могут быть доступны непосредственно с помощью имени класса, как ClassName.varName. И любой объект этого класса можно получить доступ и изменить его значение в отличие от переменных экземпляра доступны только его соответствующие объекты. Переменные класса могут использоваться в статических методах.

какая польза от private static variable в Java?

логически private static variable ничем не отличается от public static variable скорее первый дает вам больше контроля. ИМО, вы можете буквально заменить public static variable by private static variable С помощью public static методы getter и setter.

одна широко используемая область private static variable в реализации простой Singleton шаблон где у вас будет только один экземпляр этого класса во всем мире. Здесь static идентификатор играет решающую роль, чтобы сделать этот единственный экземпляр доступным для внешнего мира (конечно, public static getter method также играет главную роль).

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

    private Singleton(){}

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

другой ракурс :

1. класс и его экземпляр-это две разные вещи во время выполнения. Информация о классе является "общей" для всех экземпляров этого класса.
2. нестатические переменные класса принадлежат экземплярам, а статическая переменная принадлежит классу.
3. так же, как переменные экземпляра могут быть частными или общедоступными, статические переменные также могут быть частными или общедоступными.

частное ключевое слово будет использовать для доступа к переменной внутри класса и сохранения статики в том смысле, что мы можем получить доступ к переменной в статическом методе, но ссылочная переменная не может получить доступ в статическом методе.

когда в статическом методе вы используете переменную, переменная тоже должна быть статической в качестве примера:

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

статические переменные-те переменные, которые являются общими для всех экземпляров класса..если один экземпляр изменяет его.. тогда значение статической переменной будет обновлено для всех остальных экземпляров

для некоторых людей это имеет больше смысла, если они видят его на нескольких разных языках, поэтому я написал пример на Java и PHP на своей странице, где я объясняю некоторые из этих модификаторов. Возможно, вы думаете об этом неправильно.

вы должны посмотреть на мои примеры, если это не имеет смысла ниже. Иди сюда http://www.siteconsortium.com/h/D0000D.php

суть в том, что это в значительной степени именно то, что он говорит. Это статический элемент переменная, которая является частной. Например, если вы хотите создать одноэлементный объект, почему вы хотите сделать SingletonExample.экземпляр переменной общественности. Если вы это сделали, человек, который использовал класс, мог легко перезаписать значение.

вот и все.

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

Если вы используете частные статические переменные в своем классе, статические внутренние классы в вашем классе могут достигать ваших переменных. Это отлично подходит для контекстной безопасности.

если переменная определена как public static, к ней можно получить доступ через ее имя класса из любого класса.

обычно функции определяются как общедоступные статические, к которым можно получить доступ, просто вызвав имя реализующего класса.

очень хорошим примером этого является sleep() метод класса Thread

Thread.sleep(2500);

если переменная определена как частная статическая, она может быть доступна только в этом классе, поэтому имя класса не требуется, или вы все еще можете использовать имя класса (до вас). Разница между private var_name и private static var_name заключается в том, что частные статические переменные могут быть доступны только статическими методами класса, а частные переменные могут быть доступны любым методом этого класса(кроме статических методов)

очень хорошим примером этого является определение соединений с базой данных или констант, которые требуют объявления переменной как частной статической .

Другим распространенным примером является

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

Я новичок в Java, но один из способов использования статических переменных, как я предполагаю, многие люди делают, это подсчитать количество экземпляров класса. например:

public Class Company {
    private static int numCompanies;

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

тогда вы можете sysout:

Company.getNumCompanies();

вы также можете получить доступ к numCompanies из каждого экземпляра класса (который я не совсем понимаю), но это не будет "статическим способом". Я понятия не имею, является ли это лучшей практикой или нет, но это имеет смысл для меня.

*)Если переменная объявлена как частная, то она не видна вне класса.это называется datahiding.

*) Если переменная объявлена как статическая, то значение переменной одинаково для всех экземпляров, и нам не нужно создавать объект для вызова этой переменной.мы можем назвать эту переменную просто

имя_класса.переменное имя;

частная статическая переменная также будет совместно использоваться в подклассе. Если вы изменили в одном подклассе, а другой подкласс получит измененное значение, в этом случае это может быть не то, что вы ожидаете.

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

ThreadLocal переменные обычно реализуются как частные статические. На этом пути они не привязаны к классу, и каждый поток имеет свою собственную ссылку на свой собственный объект "threadLocal".

В следующем примере, eye изменяется PersonB, в то время как leg остается прежним. Это потому, что частная переменная делает копию самого себя к методу, так что его исходное значение остается неизменным; в то время как частное статическое значение только один экземпляр для всех методов для совместного использования, поэтому редактирование его значения изменит его исходное значение.

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

}

> Четырнадцать 3