개인 최종 정적 속성 대 개인 최종 속성
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);
그것은 행동을 훨씬 더 분명하게 만듭니다. 최신 IDE는 일반적으로 두 번째 목록을 세 번째 목록으로 변경하도록 제안합니다.
다음과 같은 선언을 할 이유가 없습니다
private final int NUMBER = 10;
변경할 수없는 경우 인스턴스 당 하나의 사본이있는 지점이 없습니다.
들어 최종 초기화 할 때, 그것은 런타임에 다른 값을 할당 할 수 있습니다. 예를 들어
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.
static변수 응용 프로그램의 전체 수명 동안 메모리에 숙박, 그리고 클래스 로딩시에 초기화됩니다. 객체 static를 생성 할 때마다 비 변수가 초기화됩니다 new. 일반적으로 사용하는 것이 좋습니다 :
private static final int NUMBER = 10;
왜? 이를 통해 인스턴스 당 메모리 사용량이 줄어 듭니다. 캐시 적중에도 유리합니다. 그리고 그것은 이해가됩니다 : static특정 유형 (일명 class) 의 모든 인스턴스 (일명 객체)에서 공유되는 것들에 사용해야합니다 .
정적은 "클래스와 연관된"을 의미합니다. 그렇지 않으면 변수는 클래스의 각 인스턴스와 연결됩니다. 정적이라면 메모리에 하나만 있다는 것을 의미합니다. 그렇지 않은 경우 생성 한 각 인스턴스마다 하나씩 있습니다. 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의 기본 유형은 문자열 리터럴 (새 문자열 오브젝트가 아님)에 대해 항상 "캐시"되므로 정적 멤버와 비 정적 멤버간에 차이가 없습니다.
그러나 비 정적 멤버가 기본 유형의 인스턴스가 아닌 경우 비 정적 멤버에 대한 메모리 복제가 있습니다.
Java가 두 개의 int 변수에 동일한 주소를 제공하므로 valueStatic의 값을 10으로 변경하면 더 나아가게됩니다.
다른 답변은 일반적으로 비 정적 상수를 사용할 이유가 없다는 것을 분명히하는 것처럼 보이지만 상수 변수에 다른 값을 가진 다양한 인스턴스를 가질 수 있음을 지적하는 사람을 찾을 수 없었습니다.
다음 예제를 고려하십시오.
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 인스턴스를 만들면 세 개의 다른 임의 값이 인쇄됩니다.
다른 인스턴스에서 다른 상수 값을 갖는 것이 실제로 유용한 상황은 생각할 수 없지만 정적과 비 정적 결승 사이에 명확한 차이가 있음을 지적하는 데 도움이되기를 바랍니다.
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 Final : 14 정적 Final : 5
객체 정보 : A @ 530daa Final : 21 정적 Final : 5
익명의 1 학년 IT 학생, 그리스
또한 정적 결승을 사용하는 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);
여기 내 두 센트가 있습니다 :
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
}
}
}
핵심은 변수와 함수가 다른 값을 반환 할 수 있다는 것이므로 최종 변수에 다른 값을 할당 할 수 있습니다.
아주 작고 정적 인
둘 다 상수이므로 큰 차이가 없습니다. 대부분의 클래스 데이터 객체의 경우 정적은 클래스 자체와 관련된 것을 의미하며 새 객체로 작성된 객체 수에 관계없이 하나의 사본 만 있습니다.
상수이기 때문에 실제로 클래스 또는 인스턴스에 저장되지 않을 수도 있지만 컴파일러는 정적 메소드에서 인스턴스 객체에 액세스 할 수는 없습니다. 리플렉션 API가 있으면 정적이 아닌 경우 무의미한 작업이 필요할 수 있습니다.
클래스의 변수는 동일한 명령에서 final로 선언되고 초기화되므로 인스턴스에 관계없이 동일한 값을 가지므로 정적 변수로 선언하지 않는 이유는 없습니다. 따라서 모든 인스턴스는 값에 대해 동일한 메모리 주소를 공유 할 수 있으므로 각 인스턴스에 대해 새 변수를 작성할 필요가없고 하나의 공통 주소를 공유하여 메모리를 절약하여 처리 시간을 절약 할 수 있습니다.
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
정적 클래스는 모든 클래스 인스턴스와 클래스 자체에서 동일한 멤버입니다.
비 정적 그렇게에서, 모든 인스턴스 (객체)에 대한 하나입니다 정확한 경우 당신이 경우 메모리의 낭비 하지 않는 정적을 넣어.
이 변수를 정적으로 표시하면 알다시피,이 값에 다시 액세스하기 위해 정적 메소드가 필요할 수 있습니다. 정적 변수에서만 이러한 변수를 사용하려는 경우에 유용합니다. 이것이 그렇다면 이것이 가장 좋은 것입니다.
그러나 "System.out"처럼 아무도 변수를 수정할 수 없으므로 변수를 공용으로 만들 수 있습니다. 다시 한 번 의도와 달성하고자하는 대상에 따라 다릅니다.
클래스에 인스턴스가 두 개 이상 없을 경우 더 많은 메모리를 사용한다고 가정 해 보겠습니다.
개인 정적 최종 int ID = 250; 또는 private final int ID = 250;
static은 메모리에 사본이 하나만있는 클래스 유형을 참조하고 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());
} }
위 예제에서 볼 수 있듯이 "final int"의 경우 클래스의 각 인스턴스 (객체)에 변수를 할당 할 수 있지만 "static final int"의 경우 클래스에 변수를 할당해야합니다 (정적 변수는 클래스에 속함) ).
정적, 정적 최종 최종 변수의 사용법을 이해하는 또 다른 간단한 예입니다. 코드 주석에는 적절한 설명이 있습니다.
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);
}
}
static을 사용하면 변수의 값이 모든 인스턴스에서 동일하며 한 인스턴스에서 변경되면 다른 인스턴스도 변경됩니다.
최종 : 최종 변수가 할당되면 항상 같은 값을 포함합니다. 변수가 정적이거나 정적이 아닌 곳 : 메모리에서 한 번 초기화 된 모든 인스턴스에 대해 하나의 변수 만
이것은 도움이 될 수 있습니다
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.");
}
}
'Programing' 카테고리의 다른 글
| Android 용 C 또는 C ++로 애플리케이션을 작성 하시겠습니까? (0) | 2020.03.22 |
|---|---|
| NULL, '\ 0'과 0의 차이점은 무엇입니까? (0) | 2020.03.22 |
| MySQL에서 utf8mb4와 utf8 문자셋의 차이점은 무엇입니까? (0) | 2020.03.22 |
| 벡터에서 요소의 인덱스를 찾기위한 R 함수가 있습니까? (0) | 2020.03.22 |
| 자식 리포지토리에 대한 명명 규칙이 있습니까? (0) | 2020.03.22 |