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

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

Java에서 다음 사항의 차이점:

private final static int NUMBER = 10;

그리고

private final int NUMBER = 10;

다 되다private그리고final, 차이점은 입니다.static기여하다

뭐가 더 좋아?그리고 왜?

대체적으로.static"유형의 예가 아니라 유형 자체와 일치한다"는 뜻이다.

즉, 유형의 인스턴스를 만들지 않고도 정적 변수를 참조할 수 있으며 변수를 참조하는 코드는 정확히 동일한 데이터를 참조하는 것이다.인스턴스(instance) 변수와 비교하십시오. 이 경우 클래스의 인스턴스당 하나의 독립된 버전의 변수가 있음.예를 들면 다음과 같다.

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

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

그것은 그 행동을 훨씬 더 명백하게 만든다.현대 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.

A static변수는 애플리케이션의 전체 수명 동안 메모리에 유지되며, 클래스 로딩 중에 초기화된다.A 비-비-비-비-비-비-비- 비-static이 변수있는 마르다 기구를 되는 것이다.new으로 다음과 같이 하는 것이 일반적으로 다음을 사용하는 것이 더 좋다.

private static final int NUMBER = 10;

properties당 공간이 때문에? 이것은 인스턴스당 메모리 사용 공간을 줄인다.그것은 또한 캐시 적중에도 유리할 수 있다.그리고 이건 말이 돼.static특정 유형(예: k.a)의 모든 인스턴스(예: k.a 객체)에 걸쳐 공유되는 것에 사용해야 한다.class).

최종적으로는 초기화할 때 런타임에 다른 값을 할당할 수 있다.예를 들면

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 = 0;
}

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

정적(static)은 "클래스와 동기화"를 의미하며, 클래스가 없으면 변수는 클래스의 각 인스턴스와 연관된다.정적인 경우에는 메모리에 하나만 있고, 그렇지 않은 경우에는 각 인스턴스마다 하나씩 있는 것이다.정적(static)은 클래스가 로드되는 동안 변수가 메모리에 유지됨을 의미한다. 변수가 없으면 해당 인스턴스가 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

두 번째 개체에 대한 결과:

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

다른 답변들은 일반적으로 정전기적이지 않은 상수를 사용할 이유가 없다는 것을 꽤 분명히 하는 것처럼 보이지만, 나는 그들의 상수 변수에 다른 값을 갖는 다양한 인스턴스들이 있을 수 있다는 것을 지적하는 사람을 찾을 수 없었다.

다음 예를 고려해 보십시오.

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

각 인스턴스마다 랜덤으로 생성된 상수 값이 있기 때문에, 테스트 클래스의 인스턴스 세 개를 만들면 세 개의 다른 랜덤 값이 인쇄된다.

서로 다른 예에서 상이한 값을 갖는 것이 정말 유용할 만한 상황은 생각할 수 없지만, 이것이 정적인 결승전과 비정적인 결승전 사이에 분명한 차이가 있다는 점을 지적하는 데 도움이 되었으면 한다.

아주 작고 정적인

둘 다 상수여서 큰 차이가 없다.대부분의 클래스 데이터 개체에서 정적이란 클래스 자체와 관련된 것을 의미하며, 아무리 많은 개체가 새로 생성되었더라도 복사본이 하나만 있다는 것을 의미한다.

상수이기 때문에 클래스에 저장되거나 한 인스턴스에 저장되지 않을 수 있지만 컴파일러는 여전히 정적 방법에서 인스턴스 개체에 액세스할 수 없도록 한다.반사 API의 존재는 정적으로 만들지 않으면 의미 없는 작업이 필요할 수도 있다.

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

내가 만든 테스트에서, 정적 최종 변수는 최종(비정적) 변수와 같지 않다!최종(비정적) 변수는 물체마다 다를 수 있다!!!그러나 그것은 생성자 내에서 초기화가 이루어지는 경우에만! (시뮬레이터에서 초기화가 되지 않으면 변경될 수 없는 생성되는 모든 객체에 대해 최종 변수를 생성하기 때문에 메모리 낭비일 뿐이다.)

예를 들면 다음과 같다.

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

익명의 IT 1학년, 그리스

게다가 당신이 정적 파이널을 사용한다면 그것은 일종의 "정의"로 작용할 것이다.일단 당신이 그것을 사용하는 클래스를 컴파일하면, 그것은 컴파일된 .class 파일에 타게 될 것이다.여기서 내 실마리를 확인해 봐.

주요 목표:클래스의 다른 예에서 NUMBER를 다르게 사용하지 않으면 최종 및 정적인 파일을 사용할 것을 권고한다. (내 사례 연구에서 설명한 것과 같은 가능한 문제를 고려하지 않고 컴파일된 클래스 파일을 복사하지 않도록 유의하면 된다. 이런 일이 일어나지 않는 경우는 대부분, 걱정하지 마십시오 :)

인스턴스에서 다른 값을 사용하는 방법을 표시하려면 다음 코드를 선택하십시오.

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

    }

}

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

사설 정적 결승은 상수로 간주되며 상수는 이 등급 내에서만 접근할 수 있다.정적 키워드가 포함되므로 클래스의 모든 개체에 대해 값이 일정하게 유지된다.

개인 최종 변수 값은 개체당 상수와 같을 것이다.

java.lang을 참조할 수 있다.문자열 또는 아래의 예를 찾아보십시오.

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

정적 인스턴스는 모든 클래스 인스턴스와 클래스 자체에서 동일한 멤버로 구성된다.
비정적(non-static)은 모든 인스턴스(객체)에 대해 하나이므로, 정확한 경우 정적을 넣지 않으면 기억의 낭비가 된다.

만일 당신이 알고 있는 바와 같이 이 변수를 정적으로 표시한다면, 당신은 정적 방법에 다시 접근하도록 요구할 것이다. 이것은 당신이 이미 정적 방법에만 이러한 변수를 사용하는 것을 생각한다면 유용할 것이다.만약 그렇다면 이것이 가장 좋은 것이 될 것이다.

그러나 "System.out"처럼 누구도 수정할 수 없기 때문에 변수를 공개로 만들 수 있으며, 그것은 다시 여러분의 의도와 여러분이 성취하고자 하는 것에 달려 있다.

클래스에 두 개 이상의 인스턴스가 없는 경우 다음 중 어떤 인스턴스가 더 많은 메모리를 사용하는지 말해보십시오.

개인용 정적 최종 인트 ID = 250; 또는 개인용 최종 인트 ID 250;

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

정적 변수는 클래스에 속한다(즉, 모든 객체가 해당 변수를 공유한다는 의미).비 정적 변수는 각 객체에 속한다.

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

위의 예에서 볼 수 있듯이, "최종 int"의 경우 클래스의 각 인스턴스(객체)에 변수를 할당할 수 있지만, "static final int"의 경우 클래스에 변수를 할당해야 한다(정적 변수는 클래스에 속함).

정적(static)을 사용할 경우 변수 값은 모든 인스턴스 간에 동일하며, 한 인스턴스에서 변경될 경우 다른 인스턴스도 변경된다.

Final: 최종 변수가 할당되면 항상 동일한 값을 포함한다.변수가 정적이거나 정적이 아닌 경우: 메모리에서 한 번 초기화된 모든 인스턴스에 대해 하나의 변수만 될 것이다.

이것이 도움이 될 것이다.

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

"static" 키워드는 클래스의 개별 인스턴스가 아닌 클래스의 가변 속성을 만든다.해당 클래스의 모든 인스턴스 간에 공유되는 변수의 복사본이 하나 있을 것이다.정적 변수의 상태 변화는 모든 경우에 반영될 것이다.정적에 최종 값을 추가하면 클래스 로딩 시간에 한 번 그리고 전체적으로 초기화되었으며 클래스의 어떤 인스턴스로도 나중에 변경할 수 없는 변수를 얻을 수 있다.정적 최종 변수는 선언 시간에 초기화되어야 하며 그렇지 않으면 컴파일 시간 오류가 있다.개인 인스턴스(instance) 필드에 관한 한, 클래스의 객체/인스턴스의 속성/상태를 가리킨다.클래스의 각 인스턴스/개체는 인스턴스 변수의 복사본을 가질 것이다.인스턴스 변수가 최종으로 선언되면 이 인스턴스에 대한 값을 변경할 수 없다는 것을 의미한다.이를 위해 선언 시 또는 생성자에서 최종 변수를 초기화해야 한다.둘 중 하나에서 수행되지 않으면 컴파일 시간 오류가 표시된다.초기화가 완료되면 값을 재할당하려고 하면 컴파일 시간 오류가 발생한다.클래스의 모든 인스턴스에서 데이터를 공유하고 데이터를 읽기 전용으로 사용할 정적 최종 변수를 사용하십시오.클래스의 각 개별 인스턴스에 속하지만 저장한 후에는 변경할 수 없는 일부 데이터를 나타내려면 인스턴스(instance) 최종 변수를 사용하십시오.정적 및 인스턴스(instance) 키 워드의 사용은 설계 요구 사항과 해당 데이터가 도메인에서 무엇을 나타내는지에 따라 달라진다.데이터가 클래스 인스턴스 전체에서 사용되는 경우 각 개체에 대해 개별 복사본/메모리 참조가 필요하지 않다.

참조URL: https://stackoverflow.com/questions/1415955/private-final-static-attribute-vs-private-final-attribute