приватний кінцевий статичний атрибут vs приватний кінцевий атрибут

У Java яка різниця між:

private final static int NUMBER = 10;

і

private final int NUMBER = 10;

І те privateй finalінше є, і різниця полягає в staticатрибуті.

Що краще? І чому?

Загалом, staticозначає "пов'язаний із самим типом , а не екземпляром типу".

Це означає, що ви можете посилатися на статичну змінну, не створюючи ніколи екземпляри типу, а будь-який код, що посилається на змінну, посилається на точно такі ж дані. Порівняйте це зі змінною екземпляра: у цьому випадку є одна незалежна версія змінної на екземпляр класу. Так, наприклад:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

друкує 10: y.instanceVariableі x.instanceVariableрозділені, тому xі yставляться до різних об'єктів.

Ви можете звертатися до статичних членів за допомогою посилань, хоча це погана ідея. Якби ми:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

тоді це буде надрукувати 20 - є лише одна змінна, а не одна на примірник. Було б зрозуміліше написати це як:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

Це робить поведінку набагато очевиднішою. Сучасні ІДЕ зазвичай пропонують змінити другий перелік на третій.

Немає жодної причини, щоб вбудоване оголошення ініціалізувало таке значення, як наступне, оскільки кожен екземпляр матиме своє власне, NUMBERале завжди з однаковим значенням (є незмінним та ініціалізується літералом). Це те саме, що мати лише одну final staticзмінну для всіх примірників.

private final int NUMBER = 10;

Тому, якщо він не може змінитися, немає жодного сенсу мати одну копію на примірник.

Але це має сенс, якщо він ініціалізований у такий конструктор:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

Тепер для кожного екземпляра MyClassми можемо мати різне, але незмінне значення number.

Для остаточного , при ініціалізації, йому можуть бути призначені різні значення під час виконання. Наприклад

Class Test{
  public final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t2.a = 20; //fixed

Таким чином, кожен екземпляр має різне значення поля a .

Для статичного фіналу всі екземпляри мають одне і те ж значення, і їх неможливо змінити після першої ініціалізації.

Class TestStatic{
      public static final int a;
}

TestStatic t1  = new TestStatic();
t1.a = 10;
TestStatic t2  = new TestStatic();
t1.a = 20;   // ERROR, CAN'T BE ALTERED AFTER THE FIRST INITIALIZATION.

А staticзмінна залишається в пам'яті на все життя додатки, і инициализируется під час завантаження класу. Незмінна staticініціалізується кожного разу, коли ви створюєте newоб'єкт. Зазвичай краще використовувати:

private static final int NUMBER = 10;

Чому? Це зменшує слід пам’яті на примірник. Можливо, це також сприятливо для хітів кешу. І це просто має сенс: його staticслід використовувати для речей, які поділяються між усіма екземплярами (ака-об'єктами) певного типу (ака class).

статичні засоби "пов'язані з класом"; без нього змінна асоціюється з кожним екземпляром класу. Якщо він статичний, це означає, що ви будете мати лише одну пам'ять; якщо ні, то ви матимете його для кожного створеного екземпляра. статичний означає, що змінна залишатиметься в пам’яті до тих пір, поки клас завантажений; без нього змінна може бути gc'd, коли є її примірник.

Читаючи відповіді, я не знайшов справжнього тесту, який би дійсно дійшов до суті. Ось мої 2 копійки:

public class ConstTest
{

    private final int         value             = 10;
    private static final int  valueStatic       = 20;
    private final File        valueObject       = new File("");
    private static final File valueObjectStatic = new File("");

    public void printAddresses() {


        System.out.println("final int address " +
                ObjectUtils.identityToString(value));
        System.out.println("final static int address " +
                ObjectUtils.identityToString(valueStatic));
        System.out.println("final file address " + 
                ObjectUtils.identityToString(valueObject));
        System.out.println("final static file address " + 
                ObjectUtils.identityToString(valueObjectStatic));
    }


    public static void main(final String args[]) {


        final ConstTest firstObj = new ConstTest();
        final ConstTest sndObj = new ConstTest();

        firstObj.printAdresses();
        sndObj.printAdresses();
    }

}

Результати для першого об’єкта:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@6c22c95b
final static file address java.io.File@5fd1acd3

Результати для 2-го об'єкта:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@3ea981ca
final static file address java.io.File@5fd1acd3

Висновок:

Як я думав, java робить різницю між примітивними та іншими типами. Примітивні типи в Java завжди "кешовані", однакові для рядків-літералів (не нових об'єктів String), тому різниці між статичними та нестатичними членами немає.

Однак є дублювання пам'яті для нестатичних членів, якщо вони не є примірником примітивного типу.

Зміна значення valueStatic на 10 навіть піде далі, оскільки Java дасть однакові адреси двом змінним int.

Хоча в інших відповідях здається досить зрозумілим, що в цілому немає причин використовувати нестатичні константи, я не міг знайти когось, який би вказував, що на їх постійних змінних можливі різні екземпляри з різними значеннями.

Розглянемо наступний приклад:

public class TestClass {
    private final static double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

Створення трьох екземплярів TestClass видало б три рази одне і те ж випадкове значення, оскільки генерується лише одне значення і зберігається в статичну константу.

Однак, замість цього спробуйте наступний приклад:

public class TestClass {
    private final double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

Створивши три екземпляри TestClass, тепер було б надруковано три різні випадкові значення, оскільки кожен екземпляр має власне постійне значення, що генерується випадковим чином.

Я не можу придумати жодної ситуації, де було б дійсно корисно мати різні постійні значення в різних випадках, але я сподіваюся, що це допомагає вказувати на те, що між статичним та нестатичним фіналом існує чітка різниця.

Як уже говорив Джон, статична змінна, яку також називають змінною класу, - це змінна, яка існує у всіх примірниках класу.

Я знайшов приклад цього тут :

public class StaticVariable
{
  static int noOfInstances;
  StaticVariable()
  {
    noOfInstances++;
  }
  public static void main(String[] args)
  {
    StaticVariable sv1 = new StaticVariable();
    System.out.println("No. of instances for sv1 : " + sv1.noOfInstances);

    StaticVariable sv2 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for st2 : "  + sv2.noOfInstances);

    StaticVariable sv3 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for sv2 : "  + sv2.noOfInstances);
    System.out.println("No. of instances for sv3 : "  + sv3.noOfInstances);
  }
}

Вихід програми наведено нижче:

Як ми бачимо в цьому прикладі, кожен об'єкт має свою копію змінної класу.

C:\java>java StaticVariable
No. of instances for sv1 : 1
No. of instances for sv1 : 2
No. of instances for st2 : 2
No. of instances for sv1 : 3
No. of instances for sv2 : 3
No. of instances for sv3 : 3

З тестів, які я зробив, статичні кінцеві змінні не збігаються з кінцевими (нестатичними) змінними! Кінцеві (нестатичні) змінні можуть відрізнятися від об'єкта до об'єкта !!! Але це лише в тому випадку, якщо ініціалізація зроблена всередині конструктора! (Якщо він не ініціалізований з конструктора, то це лише марно пам'ять, оскільки він створює остаточні змінні для кожного створеного об'єкта, який неможливо змінити.)

Наприклад:

class A
{
    final int f;
    static final int sf = 5;

    A(int num)
    {
        this.f = num;
    }

    void show()
    {
        System.out.printf("About Object: %s\n Final: %d\n Static Final: %d\n\n", this.toString(), this.f, sf);
    }

    public static void main(String[] args)
    {
        A ob1 = new A(14);
        ob1.show();

        A ob2 = new A(21);
        ob2.show();

    }
}

Що відображається на екрані:

Про об’єкт: A @ addbf1 Фінал: 14 Статичний фінал: 5

Про об’єкт: A @ 530daa Final: 21 Статичний фінал: 5

Анонімний студент 1 курсу ІТ, Греція

Крім того, у відповідь Джона, якщо ви використовуєте статичний фінал, він буде вести себе як "своєрідне визначення". Після того як ви компілюєте клас, який його використовує, він буде записаний у файлі .class. Перевірте мою нитку про це тут .

Для вашої основної мети: Якщо ви не використовуєте НОМЕР по-різному в різних екземплярах класу, я б радив використовувати остаточний та статичний. (Вам просто потрібно пам’ятати, щоб не копіювати складені файли класів, не враховуючи можливих проблем, як описано в моєму прикладі. Більшість випадків цього не відбувається, не хвилюйтесь :))

Щоб показати вам, як використовувати різні значення в екземплярах, перевірте цей код:

public class JustFinalAttr {
  public final int Number;

  public JustFinalAttr(int a){
    Number=a;
  }
}

...System.out.println(new JustFinalAttr(4).Number);

Ось два мої центи:

final           String CENT_1 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";
final   static  String CENT_2 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";

Приклад:

package test;

public class Test {

    final long OBJECT_ID = new Random().nextLong();
    final static long CLASSS_ID = new Random().nextLong();

    public static void main(String[] args) {
        Test[] test = new Test[5];
        for (int i = 0; i < test.length; i++){
            test[i] = new Test();
            System.out.println("Class id: "+test[i].CLASSS_ID);//<- Always the same value
            System.out.println("Object id: "+test[i].OBJECT_ID);//<- Always different
        }
    }
}

Ключовим є те, що змінні та функції можуть повертати різні значення. Тому остаточні змінні можуть присвоюватися різним значенням.

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

public class City {

    // base price that is always same for all objects[For all cities].
    private static double iphone_base_price = 10000;

    // this is total price = iphone_base_price+iphone_diff;
    private double iphone_citi_price;

    // extra price added to iphone_base_price. It is constant per city. Every
    // city has its own difference defined,
    private final double iphone_diff;

    private String cityName = "";

    // static final will be accessible everywhere within the class but cant be
    // changed once initialized.
    private static final String countryName = "India";

    public City(String cityName, double iphone_diff) {
        super();
        this.iphone_diff = iphone_diff;
        iphone_citi_price = iphone_base_price + iphone_diff;
        this.cityName = cityName;

    }

    /**
     * get phone price
     * 
     * @return
     */
    private double getPrice() {

        return iphone_citi_price;
    }

    /**
     * Get city name
     * 
     * @return
     */
    private String getCityName() {

        return cityName;
    }

    public static void main(String[] args) {

        // 300 is the
        City newyork = new City("Newyork", 300);
        System.out.println(newyork.getPrice() + "  " + newyork.getCityName());

        City california = new City("California", 800);
        System.out.println(california.getPrice() + "  " + california.getCityName());

        // We cant write below statement as a final variable can not be
        // reassigned
        // california.iphone_diff=1000; //************************

        // base price is defined for a class and not per instances.
        // For any number of object creation, static variable's value would be the same
        // for all instances until and unless changed.
        // Also it is accessible anywhere inside a class.
        iphone_base_price = 9000;

        City delhi = new City("delhi", 400);
        System.out.println(delhi.getPrice() + "  " + delhi.getCityName());

        City moscow = new City("delhi", 500);
        System.out.println(moscow.getPrice() + "  " + moscow.getCityName());

        // Here countryName is accessible as it is static but we can not change it as it is final as well. 
        //Something are meant to be accessible with no permission to modify it. 
        //Try un-commenting below statements
        System.out.println(countryName);

        // countryName="INDIA";
        // System.out.println(countryName);

    }

}

дуже мало, і статично

Немає великої різниці, оскільки вони обидві константи. Для більшості об’єктів даних класу статичні означатимуть щось, пов’язане із самим класом, при цьому існує лише одна копія незалежно від того, скільки об’єктів створено за допомогою нового.

Оскільки це константа, вона може насправді не зберігатися ні в класі, ні в екземплярі, але компілятор все ще не дозволить вам отримати доступ до об'єктів екземпляра статичним методом, навіть якщо він знає, якими вони були б. Існування API відображення також може вимагати певної безглуздої роботи, якщо ви не зробите його статичним.

Оскільки змінна в класі оголошена як остаточна І ініціалізована в одній команді, немає абсолютно ніяких причин не оголошувати її статичною, оскільки вона матиме те саме значення незалежно від примірника. Отже, всі екземпляри можуть спільно використовувати одну і ту ж адресу пам'яті для значення, тим самим економлячи час обробки, усуваючи необхідність створення нової змінної для кожного примірника та економлячи пам'ять шляхом спільного використання 1 загальної адреси.

приватний статичний фінал вважатиметься постійним і до константи можна отримати доступ лише в цьому класі. Оскільки, включене статичне ключове слово, значення буде постійним для всіх об'єктів класу.

значення приватної кінцевої змінної буде подібним до константи на об'єкт

Ви можете посилатися на java.lang.String або шукати приклад нижче.

public final class Foo
{

    private final int i;
    private static final int j=20;

    public Foo(int val){
        this.i=val;
    }

    public static void main(String[] args) {
        Foo foo1= new Foo(10);

        Foo foo2= new Foo(40);

        System.out.println(foo1.i);
        System.out.println(foo2.i);
        System.out.println(check.j);
    }
}

// Вихід:

10
40
20

Статичний - той самий член у всіх екземплярах класу та в самому класі.
Нестатичний - це один для кожного екземпляра (об'єкта), тож у вашому точному випадку це марно трата пам'яті, якщо ви не ставите статику.

Якщо ви позначите цю змінну статичною, то, як відомо, вам потрібні були статичні методи, щоб знову отримати доступ до цих значень, це буде корисно, якщо ви вже думаєте використовувати ці змінні лише в статичних методах. Якщо це так, то це було б найкращим.

Однак ви можете зробити цю змінну тепер публічною, оскільки ніхто не може її змінити так само, як "System.out", це знову залежить від ваших намірів і того, що ви хочете досягти.

Скажімо, якщо в класі не буде більше ніж один екземпляр ніколи, то для якого потрібна більше пам'яті:

приватний статичний кінцевий int ID = 250; або приватний кінцевий int ID = 250;

Я розумів, що статичні стосуватимуться типу класу з лише однією копією в пам'яті, а нестатична буде знаходитися в новому місці пам'яті для кожної змінної примірника. Однак внутрішньо, якщо ми просто порівнюємо 1 екземпляр одного класу коли-небудь (тобто більше 1 екземпляра не було б створено), то чи є накладні витрати з точки зору простору, використовувані 1 статичною кінцевою змінною?

Статична змінна належить до класу (це означає, що всі об'єкти поділяють цю змінну). Нестатична змінна належить кожному об'єкту.

public class ExperimentFinal {

private final int a;
private static final int b = 999; 

public ExperimentFinal(int a) {
    super();
    this.a = a;
}
public int getA() {
    return a;
}
public int getB() {
    return b;
}
public void print(int a, int b) {
    System.out.println("final int: " + a + " \nstatic final int: " + b);
}
public static void main(String[] args) {
    ExperimentFinal test = new ExperimentFinal(9);
    test.print(test.getA(), test.getB());
} }

Як ви бачите вище приклад, для "final int" ми можемо призначити нашу змінну для кожного екземпляра (об'єкта) класу, однак для "static final int" нам слід призначити змінну в класі (статична змінна належить класу ).

Якщо ви використовуєте статичний, значення змінної буде однаковим для всіх ваших примірників, якщо змінити в одному екземплярі, інші зміниться також.

Заключний: Після призначення остаточної змінної вона завжди містить одне і те ж значення. де змінна є статичною або не статичною: вона буде лише однією змінною для всіх екземплярів, ініціалізованих один раз у Пам'яті

Це може допомогти

public class LengthDemo {
public static void main(String[] args) {
    Rectangle box = new Rectangle();
    System.out.println("Sending the value 10.0 "
            + "to the setLength method.");
    box.setLength(10.0);
    System.out.println("Done.");
    }
}

Ключове слово "статичний" робить властивість змінного класу, а не окремі екземпляри класу. Буде одна копія цієї змінної, яка поділяється між усіма примірниками цього класу. Будь-яка зміна стану статичної змінної відображатиметься у всіх примірниках. Додамо final до статики, і ми отримаємо змінну, яка була ініціалізована раз і назавжди під час завантаження класу і не може бути змінена пізніше жодним екземпляром класу. Статичні кінцеві змінні потрібно ініціалізувати під час оголошення, інакше ми маємо помилку часу компіляції. Що стосується приватного поля екземпляра, воно стосується властивості / стану об'єкта / екземпляра класу. Кожен екземпляр / об’єкт класу матиме власну копію змінної екземпляра. Коли змінну екземпляра оголошено остаточною, це означає, що ми не можемо змінити його значення для цього випадку. Для цього нам потрібно ініціалізувати підсумкову змінну або при оголошенні, або в конструкторі. Якщо це не зроблено в жодному з них, відображатиметься помилка часу компіляції. Після ініціалізації, якщо ви спробуєте перепризначити значення, ви отримаєте помилку часу компіляції. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Для цього нам потрібно ініціалізувати підсумкову змінну або при оголошенні, або в конструкторі. Якщо це не зроблено в жодному з них, відображатиметься помилка часу компіляції. Після ініціалізації, якщо ви спробуєте перепризначити значення, ви отримаєте помилку часу компіляції. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Для цього нам потрібно ініціалізувати підсумкову змінну або при оголошенні, або в конструкторі. Якщо це не зроблено в жодному з них, відображатиметься помилка часу компіляції. Після ініціалізації, якщо ви спробуєте перепризначити значення, ви отримаєте помилку часу компіляції. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Якщо це не зроблено в жодному з них, покаже помилка часу компіляції. Після ініціалізації, якщо ви спробуєте перепризначити значення, ви отримаєте помилку часу компіляції. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Якщо це не зроблено в жодному з них, покаже помилка часу компіляції. Після ініціалізації, якщо ви спробуєте перепризначити значення, ви отримаєте помилку часу компіляції. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Використовуйте статичні кінцеві змінні, де дані будуть обмінюватися у всіх екземплярах класу, і ви хочете, щоб вони були лише для читання. Використовуйте остаточну змінну екземпляра, якщо ви хочете представляти деякі дані, що належать кожному окремому екземпляру класу, але один раз збережене неможливо змінити. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта. Використання статичного та ключового слова екземпляра залежить від ваших потреб дизайну та того, що ці дані представляють у домені. Якщо дані використовуються через екземпляри класу, тоді немає необхідності в окремих копіях / посиланнях на пам'ять для кожного об'єкта.