Когда именно мы должны использовать "public static final String"?

Ответ 1

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

Используйте public final static String когда вы хотите создать String которая:

1. принадлежит классу (static: экземпляр не нужен для его использования), и это
2. не изменится (final), например, когда вы хотите определить константу String которая будет доступна всем экземплярам класса и другим объектам, использующим этот класс.

Пример:

public final static String MY_CONSTANT = "SomeValue";

// ... in some other code, possibly in another object, use the constant:
if (input.equals(MyClass.MY_CONSTANT)

Так же:

public static final int ERROR_CODE = 127;

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

Даже если константа будет использоваться только для чтения - в текущем классе и/или только в одном месте, рекомендуется объявить все константы как final: она будет более понятной, и во время жизни кода константа может в конечном итоге использоваться в более чем одном месте.

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

Ответ 2

• Статические средства. Вы можете использовать его без экземпляра класса или с помощью любого объекта.

• final.. Это ключевое слово, которое используется для того, чтобы строка была постоянной. Вы не можете изменить значение этой строки. Посмотрите пример ниже:

    public class StringTest { 
             static final String str = "Hello"; 
    public static void main(String args[]) { 
             // str = "world"; // gives error 
             System.out.println(str); // called without the help of an object                       
             System.out.println(StringTest.str);// called with class name  
               } 
           } 
  

Спасибо

Ответ 3

Ключевое слово final означает, что значение является постоянным (его нельзя изменить). Это аналогично const в C.

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

Надеюсь, что это поможет.

Ответ 4

final указывает, что значение не может быть изменено после установки. static позволяет вам установить значение, и это значение будет одинаковым для ВСЕХ экземпляров класса, которые его используют. Кроме того, вы можете получить доступ к значению строки public static w/o, имеющей экземпляр класса.

Ответ 5

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

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

Ответ 6

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

Ответ 7

 public делает его доступным для других классов. Вы можете использовать его без создания экземпляра класса или с использованием любого объекта.

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

 final делает его неизменяемым значением. Это "постоянное" значение, которое одинаково для всех экземпляров класса и не может быть изменено.

Ответ 8

public делает его доступным для других классов. static делает это равномерным значением во всех экземплярах класса. final делает это немодифицируемым значением. Таким образом, в основном это значение " константа", которое одинаково для всех экземпляров класса и не может быть изменено. Что касается вашей озабоченности "Я не понимаю, почему люди используют это, даже если константа будет использоваться только в одном месте и только в том же классе. Почему это объявление? Почему бы нам просто не использовать переменную?" Я бы сказал, поскольку это публичное поле, постоянное значение также может использоваться в другом месте в каком-либо другом классе, используя ClassName.value. например: класс с именем Math может иметь PI как конечное статическое длинное значение, к которому можно получить доступ как Math.PI.

Ответ 9

Почему люди используют константы в классах вместо переменной?

читаемость и ремонтопригодность,

с некоторым числом, например, 40.023 в вашем коде, не сказано много о том, что представляет собой число, поэтому мы заменяем его словом в таких словах, как "USER_AGE_YEARS". Позже, когда мы посмотрим на код, ясно, что это число.

Почему мы не просто используем переменную? Ну, если бы мы знали, что число изменится, но если его некоторое число, которое не изменится, как 3.14159, мы сделаем его окончательным.

Но что, если его не число, как строка? В этом случае в основном для удобства обслуживания, если вы используете String несколько раз в своем коде (и он не будет меняться во время выполнения), удобно иметь его в качестве конечной строки в верхней части класса. Таким образом, когда вы хотите изменить его, есть только одно место, чтобы изменить его, а не многие.

Например, если у вас есть сообщение об ошибке, которое многократно печатается в вашем коде, с окончательной строкой ERROR_MESSAGE = "Что-то пошло не так". легче поддерживать, если вы хотите изменить его из "Что-то пошло не так". "Слишком поздно, что он уже мертв", вам нужно будет только изменить эту строку, а не все места, в которых вы будете использовать этот комментарий.

Ответ 10

Это своего рода стандарт/лучшая практика. Уже есть ответы со списком сценариев, но для вашего второго вопроса:

Почему они должны это делать? Почему они должны инициализировать значение как окончательное перед его использованием?

Открытые константы и поля, инициализированные при объявлении, должны быть "статическими окончательными", а не просто "окончательными"

Вот некоторые из причин, почему так должно быть:

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

2. Кроме того, когда непубличное конечное поле не является статичным, это означает, что разные экземпляры могут иметь разные значения. Однако инициализация нестатического конечного поля в его объявлении вынуждает каждый экземпляр иметь одинаковое значение из-за поведения конечного поля.

Ответ 11

Вам не нужно использовать final, но final разъясняет всем остальным, включая компилятор, что это константа и что в этом есть хорошая практика.

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

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

Вот почему:

1. Поскольку он объявлен как final, компилятор вставит это поле во время компиляции в любой модуль компиляции, читающий это поле. Пока все хорошо.
2. Люди часто забывают, что, поскольку поле также объявлено как public, компилятор также встроит это значение в любой другой модуль компиляции. Это означает, что другие классы используют это поле.

Каковы последствия?

Представьте, что у вас есть это:

class Foo {
  public static final String VERSION = "1.0";
}

class Bar {
  public static void main(String[] args) {
    System.out.println("I am using version " + Foo.VERSION);
  }
}

После компиляции и запуска Bar вы получите:

I am using version 1.0

Теперь вы улучшаете Foo и меняете версию на "1.1". После перекомпиляции Foo вы запускаете Bar и получаете неправильный вывод:

I am using version 1.0

Это происходит потому, что VERSION объявлен final, поэтому его фактическое значение уже было встроено в Bar во время первого запуска компиляции. Как следствие, чтобы пример поля public static final ... распространялся должным образом после фактического изменения того, что было объявлено final (вы лгали !;), вам нужно будет перекомпилировать каждый класс, использующий его.

Я видел это пару раз, и это действительно трудно отладить.

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

class Foo {
  private static String version = "1.0";
  public static final String getVersion() {
    return version;
  }
}

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