Разница между статической и конечной статической переменной в Java

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

Я не могу различать элемент final и final static. Последним статическим членом является тот, который является статическим членом, объявленным как final или что-то еще? В каких конкретных ситуациях они должны использоваться конкретно?

Статическая переменная или конечная статическая переменная никогда не могут быть объявлены внутри метода ни внутри статического метода, ни внутри метода экземпляра. Почему?

Следующий сегмент кода соответственно не будет скомпилирован, и компилятор будет выдавать компиляционную ошибку, если попытается ее скомпилировать.

public static void main(String args[])
{
    final int a=0;  //ok

    int b=1;  //ok

    static int c=2;  //wrong

    final static int x=0;  //wrong
}

Ответы

Ответ 1

Вы создаете огромное множество различных концепций. Даже вопрос в названии не соответствует вопросу в теле.

В любом случае, это те концепции, которые вы смешиваете:

  • Переменные
  • конечные переменные
  • поля
  • окончательные поля
  • статические поля
  • конечные статические поля

Ключевое слово static имеет смысл только для полей, но в коде, который вы показываете, вы пытаетесь использовать его внутри функции, где вы не можете объявлять поля (поля являются членами классов, переменные объявляются в методах).

Попробуйте быстро описать их.

  • переменные объявляются в методах и используются как некоторая изменяемая локальная память (int x; x = 5; x++)

  • конечные переменные также объявляются в методах и используются как неизменяемое локальное хранилище (final int y; y = 0; y++; // won't compile). Они полезны для обнаружения ошибок, когда кто-то пытается изменить что-то, что не должно быть изменено. Я лично делаю большинство параметров локальных переменных и методов final. Кроме того, они необходимы, когда вы ссылаетесь на них из внутренних, анонимных классов. В некоторых языках программирования единственным видом переменной является неизменяемая переменная (в других языках переменная типа по умолчанию является неизменяемой переменной) - как упражнение, попытайтесь выяснить, как написать цикл, который будет запускать указанное количество раз, когда вам не разрешено ничего менять после инициализации! (попробуйте, например, решить fizzbuzz только с конечными переменными!).

  • поля определяют изменяемое состояние объектов и объявляются в классах (class x { int myField; }).

  • конечные поля определяют неизменяемое состояние объектов, объявляются в классах и должны быть инициализированы до завершения конструктора (class x { final int myField = 5; }). Они не могут быть изменены. Они очень полезны при многопоточности, поскольку у них есть специальные свойства, связанные с обмениванием объектов между потоками (вам гарантируется, что каждый поток увидит правильно инициализированное значение конечных полей объекта, если объект разделяется после завершения конструктора и даже если он разделяется с расчетом данных). Если вы хотите другое упражнение, попробуйте снова разрешить fizzbuzz, используя только конечные поля и другие поля, а не переменные или параметры метода (очевидно, вам разрешено объявлять параметры в конструкторах, но это все!).

  • статические поля распределяются между всеми экземплярами любого класса. Вы можете думать о них как о каком-то глобальном изменяемом хранилище (class x { static int globalField = 5; }). Наиболее тривиальным (и обычно бесполезным) примером является подсчет экземпляров объекта (т.е. class x { static int count = 0; x() { count++; } }, здесь конструктор увеличивает счетчик каждый раз, когда он вызывается, т.е. Каждый раз, когда вы создаете экземпляр x с new x()). Остерегайтесь того, что, в отличие от конечных полей, они по сути не являются потокобезопасными; другими словами, вы наверняка получите неправильное количество экземпляров x с приведенным выше кодом, если вы создаете экземпляр из разных потоков; чтобы сделать это правильно, вам придется добавить какой-то механизм синхронизации или использовать для этой цели какой-то специализированный класс, но это другой вопрос (на самом деле это может быть предметом целой книги).

  • конечные статические поля - глобальные константы (class MyConstants { public static final double PI = 3.1415926535897932384626433; }).

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

Наконец, есть и другие ключевые слова, которые могут использоваться с полями, такими как transient, volatile и уровни доступа (public, protected, private). Но это другой вопрос (на самом деле, если вы хотите спросить о них, многие другие вопросы, я бы сказал).

Ответ 2

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

Финал в других терминах, является константой (как в C). Вы можете иметь конечную переменную внутри метода, а также на уровне класса. Если вы ставите final как static, он становится "членом класса, который является постоянным" .

Ответ 3

Я не могу отличить окончательный и конечный статический член. Конечным статическим членом является тот, который является статическим членом, объявленным как финал или что-то еще? В каких ситуациях они должны следует использовать конкретно?

Используйте final static, если хотите, чтобы он был static. Используйте final (нестатический), если вы не хотите, чтобы он был static.

Статическая переменная или конечная статическая переменная никогда не могут быть объявлены внутри метода ни внутри статического метода, ни внутри экземпляра метод. Почему?

Решение о разработке. На этот вопрос просто невозможно ответить, не спросив Джеймса Гослинга.

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

Потому что это нарушает правило, которое вы только что описали.

Ответ 4

final ключевое слово просто означает, что "это не может быть изменено". Его можно использовать с обоими полями и переменными в методе. Когда переменная объявляется окончательной, попытка изменить переменную приведет к ошибке времени компиляции. Например если я объявляю переменную как final int x = 12; пытаясь увеличить x, то есть (++ x), выдает ошибку. Короче говоря, примитивы final делают значение константой. С другой стороны, статические могут применяться только с полями, но не в методах. В поле, которое является конечным статичным, есть только один фрагмент файла storage.final, который показывает, что он является константой (не может быть изменен), статический показывает, что это только один.