개인 최종 정적 속성 대 개인 최종 속성


305

Java에서는 다음과 같은 차이점이 있습니다.

private final static int NUMBER = 10;

private final int NUMBER = 10;

및는 둘 다 private이며 final, 차이점은 static속성입니다.

더 나은 게 뭐야? 그리고 왜?


62
private final static->이 변수를 한 번만 만듭니다. private final-> 모든 객체에 대해이 변수를 만듭니다. 먼저 메모리를 절약하십시오.
user1923551

4
final static이 변수는 상수이고 클래스 자체와 만 연관됩니다. 즉 "클래스 당 하나의 상수 변수"이고 final"인스턴스 당 하나의 상수 변수" 결과적으로 final static생성자는 새로운 인스턴스를 포함하므로 클래스의 생성자 에는 변수를 넣을 수 없습니다 . (직접 시도해 볼 수 있으며 오류가 발생합니다)
LittleLittleQ

1
"클래스의 생성자에 최종 정적 변수를 넣을 수 없습니다"는 생성자에서 final static변수를 초기화 할 수 없다는 것을 의미 합니다. 유일한 방법은 정적 초기화를 사용하는 것입니다. :)
LittleLittleQ

2
@ user1923551이 효과는 큰 응용 프로그램, 메모리 부족 응용 프로그램 또는 단일 톤을 사용하는 경우 제한된 시간 동안 필요한 항목에만 적용됩니다. 모든 클래스에 정적 항목이 있으면 필요하지 않은 항목에 대해 (거대한) 메모리 덩어리가 예약됩니다. 정적 최종 객체 또는 컬렉션을 선언하기 위해 메모리 누수가 될 수도 있습니다.
희망적으로 도움이 된

답변:


309

일반적으로 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별개로 인해 xy다른 개체를 참조하십시오.

당신은 할 수 는 그렇게 나쁜 생각하지만, 참고 문헌을 통해 정적 멤버를 참조하십시오. 우리가 한 경우 :

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

그것은 행동을 훨씬 더 분명하게 만듭니다. 최신 IDE는 일반적으로 두 번째 목록을 세 번째 목록으로 변경하도록 제안합니다.

각 인스턴스마다 고유 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.


10
Java 5에서 열거 형을 사용할 수있을 때까지 정적 결승은 상수를 선언하는 일반적인 방법이었습니다.
Vineet Reynolds

22
@Vineet : 정적 결승은 열거 된 개수가 없다면 원시 상수를 선언하는 방법입니다. =)
Chii

@ 매튜 : 잠재적으로. 상수가 아니라 논리적으로 인스턴스 관련 값이 있습니다. 어쨌든 나는 싱글 톤을 좋아하지 않습니다.
Jon Skeet

1
근본적인 질문. 클래스에서 그 작은 기억을 짜내거나 되찾기 위해 private final오버 private static final를 사용할 가치가 있습니까? calculator램이 제한되어 있지만 많은 CPU 리소스가 있는 장치를 가정 해 봅시다 .
Myo Htet Win

1
@WinMyoHtet : 정적 필드를 사용하는 경우, 단지 거기에 하나의 전체이다. 인스턴스 필드를 사용하는 경우 인스턴스 당 하나가 있습니다. 인스턴스가 없으면 정적 필드를 사용하는 것이 좋습니다.이 경우 어쨌든 쓸모가 없습니다.
Jon Skeet 2016 년

38

에 대한 최종 초기화 할 때, 그것은 런타임에 다른 값을 할당 할 수 있습니다. 예를 들어

Class Test{
  public final int a;
}

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

따라서 각 인스턴스의 필드 값이 다릅니다 습니다 .

들어 정적 최종 , 모든 인스턴스는 동일한 가치를 공유하고, 처음으로 초기화 한 후 변경할 수 없습니다.

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

14
확인하면 컴파일되지 않습니다. 위에서 설명한 것처럼 생성자가 완료되기 전에 최종 인스턴스 변수를 인스턴스화해야하고 클래스를 만들기 전에 최종 클래스 변수를 인스턴스화해야합니다 (정적 블록을 사용할 수 있음). 왜 이렇게 많은 투표가 이루어 졌습니까?
Rudi Kershaw

MattC가 지적했듯이, 객체를 생성 한 후 최종 변수를 할당 할 수 없습니다. 실제로 최종 변수에 값을 제공하지 않으면 객체를 생성 할 수도 없습니다.
jamesdeath123

누군가 넘어 질 경우를 대비하여 MattC의 답변을 따르십시오.
Faz

이것이 OP가 요구 한 것이라고 생각합니다. 선언에 값이 제공되지 않으면 인스턴스화에서 최종 값에 값을 할당 할 수 있다는 것을 잊었습니다.
Salsero69

34

static변수 응용 프로그램의 전체 수명 동안 메모리에 숙박, 그리고 클래스 로딩시에 초기화됩니다. 않은 static변수는 컨스마다 초기화되는 new개체. 일반적으로 사용하는 것이 좋습니다 :

private static final int NUMBER = 10;

왜? 이를 통해 인스턴스 당 메모리 사용량이 줄어 듭니다. 캐시 적중에도 유리합니다. 그리고 그것은 의미 static가 있습니다. 특정 유형 (일명 class) 의 모든 인스턴스 (일명 객체)에서 공유되는 것들에 사용해야합니다 .


정적 변수도 런타임에 작성됩니다. 따라서 개체를 만들기 전에 해당 변수 또는 메서드를 사용할 수 있습니다.
bobby

13
Java 코딩 규칙에 따라 정적 최종 변수의 이름은 모두 대문자 여야합니다.
starblue

@Martijn Courteaux, 앱 수명 동안 클래스가 한 번 사용되는 상황은 어떻습니까! private final int인스턴스가 GC 될 때 메모리에서 제거되는 반면 private static final int해당 앱의 수명 동안 메모리에 남아 있습니다. 위 시나리오에서 무엇을 제안 하시겠습니까?
MANN

@MANN : 이것은 이론적 인 것입니다. 말 그대로 유용한 유스 케이스 시나리오는 없습니다. 클래스에 50000 int var가있는 경우 유용 할 수 있습니다. 이 경우에도 200kb의 메모리를 절약 할 수 있습니다. 우리가 Java를 말하고 있기 때문에 이것은 전혀 관련이없는 것 같습니다. 메모리 크리티컬 디바이스의 경우 적절한 C 또는 C ++ 컴파일러는 이러한 정수 값을 항상 인라인하여 메모리를 완전히 비울 필요가 없습니다.
Martijn Courteaux

17

정적은 "클래스와 연관된"을 의미합니다. 그렇지 않으면 변수가 클래스의 각 인스턴스와 연결됩니다. 정적이라면 메모리에 하나만 있다는 것을 의미합니다. 그렇지 않은 경우 생성 한 각 인스턴스마다 하나씩 있습니다. static은 클래스가로드되는 동안 변수가 메모리에 남아 있음을 의미합니다. 그것 없이는, 인스턴스가있을 때 변수를 gc'd 할 수 있습니다.


인스턴스 변수는 모든 참조 / 객체가 죽을 때마다 gc'd됩니다.
Ruchir Baronia

인스턴스는 gc'd이지만 정적은 인스턴스가 아닌 클래스와 연결됩니다. 클래스가 메모리에 남아있는 한 공개 정적 인스턴스와 메서드를 참조 할 수 있습니다. 그것들은 perm gen (또는 JDK 8과 동등한 것)에 들어 가지 않으며 gc'd되지 않습니다.
duffymo

잘못된. 메모리의 인스턴스에 대한 참조가있는 경우 사용 가능한 메소드 및 인스턴스에 액세스 할 수 있습니다. 나머지는 잘못되었습니다. 클래스와 인스턴스의 차이점을 이해하지 못합니다.
duffymo

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

두 번째 개체에 대한 결과 :

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가 두 개의 int 변수에 동일한 주소를 제공하므로 valueStatic의 값을 10으로 변경하면 더 나아가게됩니다.


2
'int'-> Integer의 자동 상자가 여기에서 혼동을 일으 킵니다. 당신은 (작은) 일부 int 값의 자동 박스가 동일한 Integer 객체로 이어진다는 것을 알았습니다.
dkneller

@StackHola @dkneller 실제로 오토 박싱은 여기서 일어나는 매우 중요한 세부 사항입니다. 서명은입니다 ObjectUtils.identityToString(Object). (어쨌든 Java는 어쨌든 참조로 전달하지 않습니다). 실제로 유용한 테스트는 두 가지 객체를 할당하고 public final int FOO = 10Java 리플렉션을 사용하여 변수 의 값을 강제로 변경하는 것입니다. 그런 다음 다른 개체도 값을 변경했는지 확인하십시오.
Martijn Courteaux

11

다른 답변은 일반적으로 비 정적 상수를 사용할 이유가 없다는 것을 분명히하는 것처럼 보이지만 상수 변수에 다른 값을 가진 다양한 인스턴스를 가질 수 있음을 지적하는 사람을 찾을 수 없었습니다.

다음 예제를 고려하십시오.

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

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

TestClass의 3 개의 인스턴스를 생성하면 하나의 값만 생성되어 정적 상수에 저장되므로 동일한 임의의 값을 세 번 인쇄합니다.

그러나 대신 다음 예제를 시도하면

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

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

TestClass의 3 개의 인스턴스를 만들면 각 인스턴스마다 임의로 생성 된 상수 값이 있기 때문에 3 개의 다른 임의의 값이 인쇄됩니다.

다른 인스턴스에서 다른 상수 값을 갖는 것이 실제로 유용한 상황은 생각할 수 없지만 정적과 비 정적 결승 사이에 명확한 차이가 있음을 지적하는 데 도움이되기를 바랍니다.


2

Jon이 말했듯이 클래스 변수라고도하는 정적 변수는 클래스의 인스턴스에 존재하는 변수입니다.

나는 이것에 대한 예를 여기서 발견 했다 .

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

내가 만든 테스트에서 정적 최종 변수는 최종 (비 정적) 변수와 동일하지 않습니다! 최종 (정적이 아닌) 변수는 객체마다 다를 수 있습니다 !!! 그러나 생성자 내에서 초기화가 수행 된 경우에만 해당됩니다! (생성자에서 초기화되지 않은 경우 생성 할 수없는 모든 객체에 대해 최종 변수를 생성하기 때문에 메모리 낭비 일뿐입니다.)

예를 들면 다음과 같습니다.

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 Final : 14 정적 Final : 5

객체 정보 : A @ 530daa Final : 21 정적 Final : 5

익명의 1 학년 IT 학생, 그리스


thisw는 대답이 아닙니다 :(
Sanjaya Pandey

2

또한 정적 결승을 사용하는 Jon의 대답은 일종의 "정의"로 작동합니다. 사용하는 클래스를 컴파일하면 컴파일 된 .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

링크가 돌아 왔습니다. 편집자는 그것을 죽은 것으로 꺼냈다. 지금 살아있는 것 같습니다.
Erick G. Hagstrom 2016 년

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

정적, 정적 최종 최종 변수의 사용법을 이해하는 또 다른 간단한 예입니다. 코드 주석에는 적절한 설명이 있습니다.

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

아주 작고 정적 인

둘 다 상수이므로 큰 차이가 없습니다. 대부분의 클래스 데이터 객체의 경우 정적은 클래스 자체와 관련된 것을 의미하며 새 객체로 작성된 객체 수에 관계없이 하나의 사본 만 있습니다.

상수이기 때문에 실제로 클래스 또는 인스턴스에 저장되지 않을 수도 있지만 컴파일러는 정적 메소드에서 인스턴스 객체에 액세스 할 수는 없습니다. 리플렉션 API가 있으면 정적이 아닌 경우 무의미한 작업이 필요할 수 있습니다.


1

클래스의 변수는 final로 선언되고 동일한 명령에서 초기화되므로 인스턴스에 관계없이 동일한 값을 가지므로 정적 변수로 선언하지 않는 이유는 없습니다. 따라서 모든 인스턴스는 값에 대해 동일한 메모리 주소를 공유 할 수 있으므로 각 인스턴스에 대해 새 변수를 작성할 필요가없고 하나의 공통 주소를 공유하여 메모리를 절약함으로써 처리 시간을 절약 할 수 있습니다.


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

정적 클래스는 모든 클래스 인스턴스와 클래스 자체에서 동일한 멤버입니다.
비 정적 그렇게에서, 모든 인스턴스 (객체)에 대한 하나입니다 정확한 경우 당신이 경우 메모리의 낭비 하지 않는 정적을 넣어.


0

이 변수를 정적으로 표시하면 알다시피,이 값에 다시 액세스하기 위해 정적 메소드가 필요할 수 있습니다. 정적 변수에서만 이러한 변수를 사용하려는 경우에 유용합니다. 이것이 그렇다면 이것이 가장 좋은 것입니다.

그러나 "System.out"처럼 아무도 변수를 수정할 수 없으므로 변수를 공용으로 만들 수 있습니다. 다시 한 번 의도와 달성하고자하는 대상에 따라 다릅니다.


1
정적 메소드는 정적 변수에 액세스 할 필요가 없습니다. "정적 메소드에서 인스턴스 변수에 액세스"(허용되지 않음)를 생각하고 있다고 생각합니다.
ataulm

0

클래스에 인스턴스가 두 개 이상 없을 경우 더 많은 메모리를 사용한다고 가정 해 보겠습니다.

개인 정적 최종 int ID = 250; 또는 private final int ID = 250;

static은 메모리에 사본이 하나만있는 클래스 유형을 참조하고 non static은 각 인스턴스 변수의 새 메모리 위치에 있음을 이해했습니다. 그러나 내부적으로 동일한 클래스의 인스턴스 하나만 비교하면 (즉, 하나 이상의 인스턴스가 생성되지 않음) 정적 정적 변수 1 개에서 사용되는 공간 측면에서 오버 헤드가 있습니까?


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

static을 사용하면 변수의 값이 모든 인스턴스에서 동일하며 한 인스턴스에서 변경되면 다른 인스턴스도 변경됩니다.


0

최종 : 최종 변수가 할당되면 항상 같은 값을 포함합니다. 변수가 정적이거나 정적이 아닌 곳 : 메모리에서 한 번 초기화 된 모든 인스턴스에 대해 하나의 변수 만


-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

-2

"Static"키워드는 클래스의 개별 인스턴스가 아닌 클래스의 변수 속성을 만듭니다. 해당 클래스의 모든 인스턴스간에 공유되는 해당 변수의 사본이 하나 있습니다. 정적 변수의 상태가 변경되면 모든 인스턴스에 반영됩니다. final을 static에 추가하면 클래스 로딩 시간에 한 번 초기화되고 클래스의 인스턴스에서 나중에 변경할 수없는 변수가 생깁니다. 정적 최종 변수는 선언 시간에 초기화해야합니다. 그렇지 않으면 컴파일 시간 오류가 발생합니다. 개인 인스턴스 필드에 관한 한, 클래스의 객체 / 인스턴스의 속성 / 상태를 나타냅니다. 클래스의 각 인스턴스 / 개체에는 자체 인스턴스 변수 사본이 있습니다. 인스턴스 변수가 final로 선언되면 이는이 인스턴스의 값을 변경할 수 없음을 의미합니다. 이를 위해 선언 또는 생성자에서 최종 변수를 초기화해야합니다. 둘 중 하나에서 수행하지 않으면 컴파일 시간 오류가 표시됩니다. 초기화되면 값을 다시 할당하려고하면 컴파일 시간 오류가 발생합니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 이를 위해 선언 또는 생성자에서 최종 변수를 초기화해야합니다. 둘 중 하나에서 수행하지 않으면 컴파일 시간 오류가 표시됩니다. 초기화되면 값을 다시 할당하려고하면 컴파일 시간 오류가 발생합니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 이를 위해 선언 또는 생성자에서 최종 변수를 초기화해야합니다. 둘 중 하나에서 수행하지 않으면 컴파일 시간 오류가 표시됩니다. 초기화되면 값을 다시 할당하려고하면 컴파일 시간 오류가 발생합니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 둘 중 하나에서 수행되지 않으면 컴파일 시간 오류가 표시됩니다. 초기화되면 값을 다시 할당하려고하면 컴파일 시간 오류가 발생합니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 둘 중 하나에서 수행되지 않으면 컴파일 시간 오류가 표시됩니다. 초기화되면 값을 다시 할당하려고하면 컴파일 시간 오류가 발생합니다. 클래스의 모든 인스턴스에서 데이터가 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용합니다. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 데이터가 클래스의 모든 인스턴스에서 공유되고 데이터를 읽기 전용 인 정적 최종 변수를 사용하십시오. 클래스의 각 개별 인스턴스에 속하는 데이터를 한 번만 나타내려면 인스턴스 최종 변수를 사용하십시오. 저장은 변경할 수 없습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다. 정적 키워드와 인스턴스 키워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 나타내는 내용에 따라 다릅니다. 데이터가 클래스 인스턴스에서 사용되면 각 객체에 대한 개별 사본 / 메모리 참조가 필요하지 않습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.