プライベート最終静的属性とプライベート最終属性


305

Javaでは、何が違うのですか?

private final static int NUMBER = 10;

そして

private final int NUMBER = 10;

両方privateありますfinal、違いがあるstatic属性。

何が良いですか?なぜ?


62
private final static->この変数を1回だけ作成します。private final->すべてのオブジェクトに対してこの変数を作成します。最初の1つはメモリを節約します。
user1923551

4
final staticこの変数は定数であり、クラス自体にのみ関連付けられることを意味します。つまり、「クラスごとに1つの定数変数」finalは「インスタンスごとに1つの定数変数」を意味します。その結果、final staticコンストラクターは新しいインスタンスに関与するため、クラスのコンストラクターに変数を配置できません。(自分で試すとエラーが発生します)
LittleLittleQ

1
「クラスのコンストラクターに最後の静的変数を配置できない」とfinal staticは、コンストラクターで変数を初期化できないことを意味します。唯一の方法は、静的初期化子を使用することです:)
LittleLittleQ

2
@ user1923551大きなアプリケーション、メモリ不足のアプリケーション、またはシングルトンを使用する場合に、限られた時間だけ必要なものに対しては、効果が逆になります。すべてのクラスに静的なものがあると、不要なもののために(巨大な)メモリのチャンクが予約されます。静的な最終オブジェクトまたはコレクションを宣言すると、メモリリークになる可能性もあります。
うまくいけば

回答:


309

一般に、staticインスタンスではなく、自体に関連付けられている」ことを意味します

つまり、型のインスタンスを作成しなくても静的変数を参照でき、変数を参照するコードはまったく同じデータを参照しています。これをインスタンス変数と比較してください。その場合、クラスのインスタンスごとに変数の独立したバージョンが1つあります。だから例えば:

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

は10:y.instanceVariableを出力し、別のオブジェクトを参照しているx.instanceVariableためxy別のオブジェクトです。

静的メンバーを参照で参照できますが、そうすることはお勧めできません。私たちがした場合:

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

次に、20が出力されます。変数は1つだけで、インスタンスごとに1つはありません。これを次のように書くと、より明確になります。

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

これにより、動作がより明確になります。最近のIDEは通常、2番目のリストを3番目のリストに変更することを提案します。

次のように値を初期化するインライン宣言を行う必要はありません。各インスタンスは独自のNUMBER値を持ちますが、常に同じ値です(不変であり、リテラルで初期化されます)。これは、final staticすべてのインスタンスに対して変数を1つだけ持つことと同じです。

private final int NUMBER = 10;

したがって、変更できない場合、インスタンスごとに1つのコピーを作成しても意味がありません。

しかし、が次のようなコンストラクタで初期化されている場合は意味があります。

// 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


10
Java 5で列挙型が使用可能になるまで、静的ファイナルが定数を宣言する通常の方法でした。
Vineet Reynolds、

22
@Vineet:列挙された数がない限り、静的ファイナルはプリミティブ定数を宣言する方法です=)
Chii

@マシュー:潜在的に。定数ではなく、論理的にインスタンスに関連する値の場合。とにかく私はシングルトンがとても好きだというわけではありません。
Jon Skeet、2013年

1
過激な質問。クラスからそのわずかなメモリを絞り出す/取り戻すためにprivate finalオーバーprivate static finalを使用する価値はありますか?calculatorRAMが限られているがCPUリソースが豊富なデバイスについて考えてみましょう。
Myo Htet

1
@WinMyoHtet:静的フィールドを使用する場合、合計で1つしかありません。インスタンスフィールドを使用する場合、インスタンスごとに1つあります。インスタンスがない場合を除いて、静的フィールドを使用する方が良いでしょう。その場合、それはとにかく役に立ちません。
Jon Skeet 2013年

38

以下のために最終的に初期化するとき、それは実行時に異なる値を割り当てることができます。例えば

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.

90
これはコンパイルされません!最終変数には、値を割り当てるか、コンストラクターで値を割り当てる必要があります。この答えは、2つのコンストラクターが指定され、それぞれに異なる値に 'a'が割り当てられている場合は正しいでしょう。
MattC 2013

14
確認、これはコンパイルされません。上記のように、コンストラクタが完了する前に最終的なインスタンス変数をインスタンス化し、クラスが作成される前に最終的なクラス変数をインスタンス化する必要があります(静的ブロックを使用できます)。なぜこれが非常に多くの賛成票を獲得したのですか?
Rudi Kershaw 2014

MattCが指摘したように、そのオブジェクトの作成後に最終変数に割り当てることはできません。実際、最終変数に値を指定しないとオブジェクトを作成することもできません...
jamesdeath123

誰かがこれにつまずく場合に備えて、MattCの答えに従ってください。
Faz

これはOPが求めていたものだと思います。宣言で値が提供されなかった場合、インスタンス化時に決勝に値を割り当てることができることを忘れていました。
Salsero69

34

staticアプリケーションの全体の寿命のためにメモリ内の変数の滞在、及びクラスローディング中に初期化されます。非static変数は、newオブジェクトを構築するたびに初期化されます。一般的には次のように使用する方が良いでしょう:

private static final int NUMBER = 10;

どうして?これにより、インスタンスごとのメモリフットプリントが削減されます。キャッシュヒットにも適している可能性があります。そしてそれは理にかなっています:static特定のタイプ(別名class)のすべてのインスタンス(別名オブジェクト)で共有されるものに使用する必要があります。


静的変数も実行時に作成されます。したがって、オブジェクトが作成される前に、上記の変数またはメソッドを使用できます。
ボビー

13
Javaコーディング規約では、静的最終変数の名前はすべて大文字にする必要があります。
starblue

@Martijn Courteaux、クラスがアプリの存続期間中に一度使用される状況はどうですか?private final intインスタンスがGCされるとメモリから削除されますがprivate static final int、そのアプリの存続期間中はメモリに残ります。上記のシナリオで何を提案しますか?
MANN

@MANN:これは非常に理論的です。そのための有用なユースケースシナリオは文字通りありません。これは、クラスに50000のint varがある場合に役立ちます。この場合でも、200kbのメモリを節約できます。私たちはJavaについて話しているので、これはまったく無関係のようです。メモリクリティカルなデバイスの場合、まともなCまたはC ++コンパイラーはこれらの整数値を常にインライン化し、メモリを完全に解放する必要をなくします。
Martijn Courteaux 2017

17

staticは「クラスに関連付けられている」ことを意味します。これがない場合、変数はクラスの各インスタンスに関連付けられます。静的な場合は、メモリに1つしか存在しないことを意味します。そうでない場合は、作成するインスタンスごとに1つあります。staticは、クラスがロードされている限り、変数がメモリに残ることを意味します。それがなければ、変数はそのインスタンスがそうであるときにGCすることができます。


インスタンス変数は、それへのすべての参照/オブジェクトが死ぬたびにGCされます、そうですか?
Ruchir Baronia 2016

インスタンスはgc化されますが、静的変数はインスタンスではなくクラスに関連付けられます。クラスがメモリに残っている限り、その静的クラスのインスタンスとメソッドを参照できます。それらはperm gen(またはJDK 8で同等のもの)に入り、GCされません。
duffymo 2016

違う。メモリ内のインスタンスへの参照がある場合は、その使用可能なメソッドとインスタンスにアクセスできます。残りは間違っています。クラスとそのインスタンスの違いを理解できません。
duffymo 2016

13

答えを読んで、私は本当の意味での真のテストを見つけられませんでした。これが私の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オブジェクトではなく)文字列リテラルと同じであるため、静的メンバーと非静的メンバーの違いはありません。

ただし、非静的メンバーがプリミティブ型のインスタンスでない場合、それらのメンバーにはメモリの重複があります。

Javaが2つのint変数に同じアドレスを与えるので、valueStaticの値を10に変更するとさらに進みます。


2
「int」のオートボクシング->整数は、ここで混乱を引き起こしています。いくつかの(小さい)int値のオートボクシングが同じIntegerオブジェクトにつながることがわかります。
dkneller 2015

@StackHola @dkneller確かに、オートボクシングはここで発生する非常に重要な詳細です。署名はObjectUtils.identityToString(Object)です。(それに加えて、Javaはとにかく参照渡しをしません)。実際に役立つテストは、2つのオブジェクトを割り当て、public final int FOO = 10Javaリフレクションを使用して変数の値を強制的に変更することです。次に、他のオブジェクトもその値を変更したかどうかを確認します。
Martijn Courteaux 2017

11

他の答えは、一般的に非静的定数を使用する理由がないことを明確にしているようですが、定数変数に異なる値を持つさまざまなインスタンスが存在する可能性があることを指摘する人を見つけることができませんでした。

次の例を検討してください。

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

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

TestClassの3つのインスタンスを作成すると、同じランダム値が3回出力されます。これは、1つの値だけが生成されて静的定数に格納されるためです。

ただし、代わりに次の例を試すと、

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

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

TestClassの3つのインスタンスを作成すると、3つの異なるランダム値が出力されます。これは、各インスタンスが独自にランダムに生成された定数値を持っているためです。

インスタンスごとに異なる定数値を使用することが本当に役立つ状況は考えられませんが、これが静的ファイナルと非静的ファイナルに明確な違いがあることを指摘するのに役立つことを願っています。


2

すでにジョンが言ったように、クラス変数とも呼ばれる静的変数は、クラスのインスタンス間で存在する変数です。

私はこれの例をここに見つけました:

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

2

私が行ったテストから、静的なfinal変数はfinal(非静的)変数と同じではありません!最終(非静的)変数はオブジェクトごとに異なる可能性があります!!! しかし、それはコンストラクター内で初期化が行われた場合のみです!(それがコンストラクターから初期化されない場合、変更できない作成されたすべてのオブジェクトの最終変数を作成するため、それはメモリーの浪費です。)

例えば:

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ファイナル:21スタティックファイナル:5

匿名の1年生のIT学生、ギリシャ


thiswは答えではありません:(
Sanjaya Pandey

2

さらに、ジョンの答えに静的ファイナルを使用すると、一種の「定義」として動作します。それを使用するクラスをコンパイルすると、コンパイルされた.classファイルに書き込まれます。ここで私のスレッドを確認してください

あなたの主な目的のために:クラスの異なるインスタンスで異なるNUMBERを使用しない場合、finalおよびstaticを使用することをお勧めします。 (私のケーススタディで説明されているような考えられるトラブルを考慮せずに、コンパイルされたクラスファイルをコピーしないように注意する必要があります。ほとんどの場合、これは発生しません。心配しないでください:))

インスタンスで異なる値を使用する方法を示すには、次のコードを確認してください。

public class JustFinalAttr {
  public final int Number;

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

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

詳細な比較のためにここにリンクがありました。申し訳ありませんが、これはモデレートされたと思います。
BlondCode

リンクが戻ってきました。編集者はそれを死んだと見なしていた。現在ライブ中のようです。
エリックG.

2

これが私の2セントです。

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

重要なのは、変数と関数は異なる値を返すことができるため、最終的な変数に異なる値を割り当てることができるということです。


どちらがより良いのか、そしてその理由を詳しく説明してください
Daniel

2

static、static final、final変数の使用法を理解するためのもう1つの単純な例。コードのコメントには適切な説明があります。

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

    }

}

1

非常に少なく、静的

どちらも定数なので、それほど大きな違いはありません。ほとんどのクラスデータオブジェクトでは、静的とはクラス自体に関連付けられたものを意味し、newで作成されたオブジェクトの数に関係なく、コピーは1つしかありません。

定数なので、実際にはクラスにもインスタンスにも格納されない可能性がありますが、コンパイラーは、静的メソッドからインスタンスオブジェクトにアクセスすることを許可しません。リフレクションAPIを存在させるには、静的にしないと、無意味な作業が必要になる場合もあります。


1

クラス内の変数は、同じコマンドでfinal ANDとして初期化されて宣言されるため、インスタンスに関係なく同じ値になるため、静的として宣言しない理由はまったくありません。したがって、すべてのインスタンスが値の同じメモリアドレスを共有できるため、インスタンスごとに新しい変数を作成する必要がなくなり、処理時間を節約でき、1つの共通アドレスを共有することでメモリを節約できます。


1

private static finalは定数と見なされ、定数はこのクラス内でのみアクセスできます。キーワードstaticが含まれているため、値はクラスのすべてのオブジェクトに対して一定になります。

プライベート最終変数値は、オブジェクトごとの定数のようになります。

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

0

静的なものは、すべてのクラスインスタンスとクラス自体の同じメンバーです。
非静的はインスタンス(オブジェクト)ごとに1つであるため、厳密に言えば、静的にしないとメモリの浪費になります。


0

この変数を静的とマークすると、ご存じのように、これらの値に再度アクセスするには静的メソッドが必要になります。これは、静的メソッドでのみこれらの変数を使用することを考えている場合に役立ちます。これがそうであれば、これが最良の方法です。

ただし、「System.out」のように誰もそれを変更できないため、変数をパブリックとして作成できます。これも、意図と達成したいことによって異なります。


1
静的メソッドは静的変数にアクセスする必要はありません-私はあなたが「静的メソッドからインスタンス変数にアクセスする」ことを考えていると思います(許可されていません)。
ataulm 2012

0

クラスがインスタンスを2つ以上持たない場合、どれがより多くのメモリを必要としますか。

プライベート静的最終整数ID = 250; またはプライベートの最終int ID = 250;

staticはメモリにコピーが1つしかないクラス型を指し、非staticはインスタンス変数ごとに新しいメモリの場所にあることを理解しました。ただし、内部的に同じクラスの1つのインスタンスを比較するだけの場合(つまり、複数のインスタンスが作成されない場合)、1つの静的なfinal変数によって使用されるスペースの点でオーバーヘッドはありますか?


1
ただ繰り返すのではなく、他の答えがすでにカバーしているものを。
ユーザー不明、

0

静的変数はクラスに属します(つまり、すべてのオブジェクトがその変数を共有します)。非静的変数は各オブジェクトに属しています。

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」の場合は、クラスに変数を割り当てる必要があります(静的変数はクラスに属しています) )。



0

Final:final変数が割り当てられると、常に同じ値が含まれます。変数が静的であるか静的でないかは問わず、メモリ内で1回初期化されたすべてのインスタンスに対して1つの変数のみになります。


-1

これは役立つかもしれません

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.");
    }
}

1
この質問に対する答えは確かですか?
mikus 2015年

-2

「静的」キーワードは、クラスの個々のインスタンスではなく、クラスの変数プロパティを作成します。そのクラスのすべてのインスタンス間で共有される変数のコピーが1つあります。静的変数の状態の変更は、すべてのインスタンスに反映されます。staticにfinalを追加すると、クラスのロード時に一度だけ初期化され、後でクラスのインスタンスによって変更できない変数が取得されます。静的最終変数は宣言時に初期化する必要があります。そうしないと、コンパイル時にエラーが発生します。プライベートインスタンスフィールドに関しては、オブジェクトのプロパティ/ state /クラスのインスタンス/ instanceを参照します。クラスの各インスタンス/オブジェクトには、インスタンス変数の独自のコピーがあります。インスタンス変数が最終的に宣言されると、これは、このインスタンスの値を変更できないことを意味します。そのためには、宣言時またはコンストラクターで最終変数を初期化する必要があります。どちらかで行われていない場合は、コンパイル時エラーが表示されます。初期化後、値を再割り当てしようとすると、コンパイル時エラーが発生します。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。そのためには、宣言時またはコンストラクターで最終変数を初期化する必要があります。どちらかで行われていない場合は、コンパイル時エラーが表示されます。初期化後、値を再割り当てしようとすると、コンパイル時エラーが発生します。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。そのためには、宣言時またはコンストラクターで最終変数を初期化する必要があります。どちらかで行われていない場合は、コンパイル時エラーが表示されます。初期化後、値を再割り当てしようとすると、コンパイル時エラーが発生します。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。どちらでも行われていない場合、コンパイル時エラーが表示されます。初期化後、値を再割り当てしようとすると、コンパイル時エラーが発生します。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。どちらでも行われていない場合、コンパイル時エラーが表示されます。初期化後、値を再割り当てしようとすると、コンパイル時エラーが発生します。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。クラスのすべてのインスタンス間でデータが共有され、データを読み取り専用にする場合は、静的なfinal変数を使用します。クラスの個々のインスタンスに属しているが一度だけのデータを表す場合は、instance final変数を使用します。保存したものは変更できません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。静的キーワードとインスタンスキーワードの使用は、設計のニーズとそのデータがドメインで何を表すかによって異なります。データがクラスインスタンス間で使用される場合、各オブジェクトの個々のコピー/メモリ参照は必要ありません。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.