Java의 "최종"키워드는 어떻게 작동합니까? (여전히 개체를 수정할 수 있습니다.)

Java에서는 final변수와 함께 키워드를 사용하여 값을 변경하지 않도록 지정합니다. 그러나 클래스의 생성자 / 메소드에서 값을 변경할 수 있음을 알았습니다. 변수가 static그렇다면 컴파일 오류입니다.

코드는 다음과 같습니다.

import java.util.ArrayList;
import java.util.List;

class Test {
  private final List foo;

  public Test()
  {
      foo = new ArrayList();
      foo.add("foo"); // Modification-1
  }
  public static void main(String[] args) 
  {
      Test t = new Test();
      t.foo.add("bar"); // Modification-2
      System.out.println("print - " + t.foo);
  }
}

위의 코드는 정상적으로 작동하며 오류가 없습니다.

이제 변수를 static다음 과 같이 변경하십시오 .

private static final List foo;

이제 컴파일 오류입니다. 이것이 final실제로 어떻게 작동합니까?

항상 변수 를 초기화 할 final수 있습니다. 컴파일러는 한 번만 수행 할 수 있도록합니다.

final변수에 저장된 객체에서 메소드를 호출하는 것은의 의미와 관련이 없습니다 final. 다시 말해 final, 참조 자체에 관한 것이며 참조 된 객체의 내용에 관한 것이 아닙니다.

Java에는 객체 불변성 개념이 없습니다. 이것은 신중하게 객체를 디자인함으로써 달성되며 사소한 노력과는 거리가 멀다.

이것은 가장 좋아하는 인터뷰 질문 입니다. 이 질문을 통해 면접관은 생성자, 메서드, 클래스 변수 (정적 변수) 및 인스턴스 변수와 관련하여 개체의 동작을 얼마나 잘 이해하는지 알아 봅니다.

import java.util.ArrayList;
import java.util.List;

class Test {
    private final List foo;

    public Test() {
        foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

    public void setFoo(List foo) {
       //this.foo = foo; Results in compile time error.
    }
}

위의 경우 'Test'에 대한 생성자를 정의하고 'setFoo'메소드를 제공했습니다.

생성자 정보 : 생성자는 키워드 를 사용하여 객체 생성 당 한 번만 호출 할 수 있습니다 new. 생성자는 그렇게 설계되지 않았으므로 생성자를 여러 번 호출 할 수 없습니다.

메소드 정보 : 메소드는 원하는 횟수만큼 호출 할 수 있으며 (아직도) 컴파일러가 알고 있습니다.

시나리오 1

private final List foo;  // 1

foo이다 인스턴스 변수. Test클래스 객체를 만들면 인스턴스 변수 foo가 Test클래스 의 객체 내부에 복사됩니다 . foo생성자 내부에 할당 하면 컴파일러는 생성자가 한 번만 호출된다는 것을 알고 있으므로 생성자 내부에 할당하는 데 아무런 문제가 없습니다. 메서드 내부에

할당 foo하면 컴파일러는 메서드를 여러 번 호출 할 수 있다는 것을 알고 있습니다. 즉, 값을 여러 번 변경해야하므로 final변수에 사용할 수 없습니다 . 그래서 컴파일러는 생성자가 좋은 선택이라고 결정합니다! 최종 변수에는 한 번만 값을 지정할 수 있습니다.

시나리오 2

private static final List foo = new ArrayList();

foo이제 정적 변수입니다. Test클래스 의 인스턴스를 만들면 정적 foo이므로 객체에 복사되지 않습니다 foo. 이제는 foo각 객체의 독립적 인 속성이 아닙니다. 이것은 Test클래스 의 속성입니다 . 그러나 foo여러 객체와 new키워드를 사용하여 생성 된 모든 객체가 Test여러 객체 생성시 값을 변경하는 생성자를 호출하는 경우 ( static foo모든 객체에 복사되지는 않지만 여러 객체간에 공유 됨) .)

시나리오 3

t.foo.add("bar"); // Modification-2

위 Modification-2의 질문에서입니다. 위의 경우 첫 번째 참조 객체를 변경하지 않고 foo허용되는 내용을 추가합니다 . 참조 변수에 a new ArrayList()를 할당하려고하면 컴파일러가 불평 foo합니다.
규칙final 변수를 초기화 한 경우 다른 개체를 참조하도록 변수를 변경할 수 없습니다. (이 경우 ArrayList)

최종 클래스는 서브 클래 싱 될 수 없습니다.
최종 메소드는 재정의 될 수 없습니다. (이 메소드는 수퍼 클래스에 있습니다. )
final 메소드는 재정의 할 수 있습니다. 문법적으로 읽습니다.이 방법은 서브 클래스에 있습니다.

최종 키워드에는 여러 가지 방법이 있습니다.

• 최종 클래스 는 서브 클래 싱 될 수 없습니다.
• 서브 클래스로 최종 메소드 를 대체 할 수 없습니다.
• 최종 변수 는 한 번만 초기화 할 수 있습니다

다른 사용법 :

• 익명의 내부 클래스가 메소드 본문 내에 정의되면 해당 메소드의 범위에서 final로 선언 된 모든 변수는 내부 클래스에서 액세스 할 수 있습니다.

정적 클래스 변수는 JVM 시작부터 존재하며 클래스에서 초기화해야합니다. 이렇게하면 오류 메시지가 나타나지 않습니다.

그만큼 final이에 사용되는 어떤 키워드에 따라 두 가지 방법으로 해석 될 수있다 :

값 유형 : 대한 int의,double 값이 변경되지 수의 등이 보장됩니다

참조 유형 : 객체에 대한 참조 final는 참조가 가 변경되지 항상 동일한 객체를 참조합니다. 객체 내부의 값이 동일하게 유지되는 것을 보장하지 않습니다.

같은 final List<Whatever> foo;보장 foo항상을 의미 같은 목록,하지만 내용 말했다 목록은 시간이 지남에 따라 변경 될 수 있습니다.

당신이 만드는 경우 foo 정적을, 다음과 같은 예처럼 (당신이 그것을 정의하거나 인라인) 클래스 생성자에서 초기화해야합니다.

클래스 생성자 (인스턴스 아님) :

private static final List foo;

static
{
   foo = new ArrayList();
}

인라인 :

private static final List foo = new ArrayList();

여기서 문제는 final수정자가 작동하는 방식이 아니라static 수정자가 작동하는 방식입니다.

final수정자는 시간 (생성자에서 초기화해야 즉) 생성자의 완료에 대한 호출을 참조의 초기화를 실행합니다.

인라인으로 속성을 초기화하면 생성자에 대해 정의한 코드가 실행되기 전에 속성이 초기화되므로 다음과 같은 결과가 나타납니다.

• 경우 foo이며 static, foo = new ArrayList()전과 실행됩니다 static{}당신이 당신의 클래스에 정의한 생성자가 실행
• 경우 foo없는 static, foo = new ArrayList()생성자가 실행되기 전에 실행됩니다

속성을 인라인으로 final초기화 하지 않으면 수정자는 속성 을 초기화하고 생성자에서이를 초기화해야합니다. 당신은 또한이 있으면 static수정을 생성자는이 클래스의 초기화 블록의 속성을 초기화해야합니다 :static{} .

코드에서 발생하는 오류 static{}는 해당 클래스의 객체를 인스턴스화하기 전에 클래스가로드 될 때 실행 되는 사실 에서 발생합니다. 따라서 foo클래스를 만들 때 초기화되지 않았습니다 .

static{}블록을 유형의 객체에 대한 생성자로 생각하십시오 Class. 이것은 당신이 당신의 초기화를 수행 해야하는 곳입니다static final 클래스 속성을 합니다 (인라인으로 수행되지 않은 경우).

사이드 노트 :

그만큼 final수정 보증한다은에서 const - 다움 만 원시 형과 참조하십시오.

final객체 를 선언 하면 얻을 수있는 것은 final 참조입니다 해당 객체에 이지만 객체 자체는 일정하지 않습니다.

무엇 선언 할 때 당신이 정말로 달성하고 final당신이 (등 특정 목적을 위해 객체를 선언하면 속성은, 그 것이다 final List당신은 변경할 수 없습니다 : 당신이 선언 한 것을)와 객체가 그 목적을 위해 사용됩니다에만 있다는 것을, List foo에 다른 항목 List이지만 List항목을 추가 / 제거하여 여전히 내용을 변경할 수 있습니다 ( List사용중인 내용은 내용이 변경된 경우에만 동일 함).

이것은 매우 좋은 인터뷰 질문입니다. 때로는 최종 객체와 불변 객체의 차이점이 무엇인지 묻기도합니다.

1) 누군가가 최종 객체를 언급하면 ​​참조를 변경할 수 없지만 상태 (인스턴스 변수)는 변경할 수 있음을 의미합니다.

2) 불변 개체는 상태를 변경할 수 없지만 참조를 변경할 수있는 개체입니다 . 전의:

    String x = new String("abc"); 
    x = "BCG";

ref 변수 x는 다른 문자열을 가리 키도록 변경할 수 있지만 "abc"값은 변경할 수 없습니다.

3) 생성자 호출시 인스턴스 변수 (비 정적 필드)가 초기화됩니다. 따라서 생성자 내에서 변수 값을 초기화 할 수 있습니다.

4) "하지만 클래스의 생성자 / 메소드에서 값을 변경할 수 있습니다." -메소드 내에서 변경할 수 없습니다.

5) 정적 변수는 클래스 로딩 중에 초기화됩니다. 따라서 생성자 내부에서 초기화 할 수 없으므로 생성자 이전에도 수행해야합니다. 따라서 선언 하는 동안 정적 변수에 값을 할당해야 합니다.

finaljava 의 키워드는 사용자를 제한하는 데 사용됩니다. java final키워드는 많은 상황에서 사용될 수 있습니다. 최종은 다음과 같습니다.

1. 변하기 쉬운
2. 방법
3. 수업

final키워드는 변수와 함께 적용 할 수있는 final, 값이없는 변수를 빈이라고 final변수 또는 초기화되지 않은 final변수입니다. 생성자에서만 초기화 할 수 있습니다. 빈 final변수는 블록에서만 static초기화 될 수 있습니다 static.

자바 최종 변수 :

당신이 어떤 변수로 한 경우 final, 당신은 값을 변경할 수 의 final(그것은 일정하게 될 것입니다) 변수를.

final변수의 예

최종 변수 속도 제한이 있습니다.이 변수의 값을 변경할 것입니다. 그러나 일단 값이 할당 된 최종 변수는 절대 변경할 수 없으므로 변경할 수 없습니다.

class Bike9{  
    final int speedlimit=90;//final variable  
    void run(){  
        speedlimit=400;  // this will make error
    }  

    public static void main(String args[]){  
    Bike9 obj=new  Bike9();  
    obj.run();  
    }  
}//end of class  

자바 최종 클래스 :

클래스를로 만들면 확장final 할 수 없습니다 .

최종 수업의 예

final class Bike{}  

class Honda1 extends Bike{    //cannot inherit from final Bike,this will make error
  void run(){
      System.out.println("running safely with 100kmph");
   }  

  public static void main(String args[]){  
      Honda1 honda= new Honda();  
      honda.run();  
      }  
  }  

자바 최종 방법 :

어떤 방법을 최종으로 만들면 무시할 수 없습니다 .

finalHonda의 run () 메소드 예제는 Bike의 run ()을 대체 할 수 없습니다.

class Bike{  
  final void run(){System.out.println("running");}  
}  

class Honda extends Bike{  
   void run(){System.out.println("running safely with 100kmph");}  

   public static void main(String args[]){  
   Honda honda= new Honda();  
   honda.run();  
   }  
}  

http://www.javatpoint.com/final-keyword 에서 공유

몇 가지 간단한 정의를 언급 할 가치가 있습니다.

수업 / 방법

final서브 클래스로 메소드를 대체 할 수 없음을 나타 내기 위해 클래스 메소드의 일부 또는 전부를로 선언 할 수 있습니다 .

변수

한 번 final변수가 초기화 된, 항상 같은 값을 포함합니다.

final 기본적으로 경우에 따라 무엇이든 (서브 클래스, 변수 "reassign") 덮어 쓰기 / 감추기를 피하십시오.

finalJava에서 사용자를 제한하기 위해 예약 된 키워드이며 멤버 변수, 메소드, 클래스 및 로컬 변수에 적용 할 수 있습니다. 최종 변수는 종종 static키워드를 Java로 선언하여 상수로 취급합니다. 예를 들면 다음과 같습니다.

public static final String hello = "Hello";

final변수 선언과 함께 키워드를 사용하면 해당 변수 안에 저장된 값을 나중에 변경할 수 없습니다.

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

public class ClassDemo {
  private final int var1 = 3;
  public ClassDemo() {
    ...
  }
}

참고 : final로 선언 된 클래스는 확장 또는 상속 될 수 없습니다 (즉, 수퍼 클래스의 하위 클래스가있을 수 없음). final로 선언 된 메소드는 서브 클래스로 대체 할 수 없습니다.

이 키워드에서는 최종 키워드를 사용할 때의 이점에 대해 설명합니다 .

빨간색과 흰색의 돈 상자가 두 개 있다고 가정합니다. 이 돈 상자에는 두 명의 자녀 만 할당하고 상자를 서로 교환 할 수 없습니다. 따라서 빨간색 또는 흰색 머니 박스 (최종)가 있으면 상자를 수정할 수 없지만 상자에 돈을 넣을 수 있습니다.

모든 답을 읽으십시오.

final키워드를 메소드 인수에서 사용할 수있는 또 다른 사용자 사례가 있습니다.

public void showCaseFinalArgumentVariable(final int someFinalInt){

   someFinalInt = 9; // won't compile as the argument is final

}

변경할 수없는 변수에 사용할 수 있습니다.

정적 최종으로 만들면 정적 초기화 블록에서 초기화되어야합니다.

    private static final List foo;

    static {
        foo = new ArrayList();
    }

    public Test()
    {
//      foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

final키워드는 변수가 한 번만 초기화 할 수 있음을 나타냅니다. 코드에서 final의 한 가지 초기화 만 수행하므로 용어가 충족됩니다. 이 문은의 단독 초기화를 수행합니다 foo. 유의 final! = 불변 그것은 유일한 수단 기준은 변경할 수있다.

foo = new ArrayList();

당신이 선언 할 때 foo같은 static final변수가 클래스가로드 될 때 초기화해야합니다 및 인스턴스에 의존 할 수 초기화 (일명 생성자에 문의)foo 정적 필드는 클래스의 인스턴스없이 사용할 수 있어야하기 때문이다. 정적 필드를 사용하기 전에 생성자가 호출되었다는 보장은 없습니다.

static final시나리오에서 메소드를 실행할 때이 시점에서 Test인스턴스화하기 전에 클래스가로드 되면 초기화되지 않았 음 t을 foo의미하는 인스턴스화가 없으므로 foo모든 오브젝트에 대해 기본값으로 설정됩니다 null. 이 시점 NullPointerException에서 항목을 목록에 추가하려고하면 코드에서 a가 발생 한다고 가정합니다 .

우선, 코드에서 초기화 (즉, 처음으로 할당)하는 foo 위치는 다음과 같습니다.

foo = new ArrayList();

foo는 List 유형의 객체이므로 int와 같은 값 유형이 아닌 참조 유형 입니다. 따라서 List 요소가 저장된 메모리 위치 (예 : 0xA7D2A834)에 대한 참조를 보유합니다. 이 같은 라인

foo.add("foo"); // Modification-1

foo 값을 변경하지 마십시오 (다시 말해 메모리 위치에 대한 참조 일뿐). 대신, 참조 된 메모리 위치에 요소를 추가하기 만합니다. 최종 키워드 를 위반하려면 다음과 같이 foo를 다시 할당해야합니다.

foo = new ArrayList();

즉 것이다 당신에게 컴파일 오류를 제공합니다.

이제 그 방법으로 정적 키워드 를 추가 할 때 어떤 일이 발생하는지 생각해보십시오 .

static 키워드가 없으면 클래스를 인스턴스화하는 각 객체에는 자체 foo 사본이 있습니다. 따라서 생성자는 빈 foo 변수의 빈 복사본에 값을 할당합니다.

그러나 static 키워드가 있으면 클래스와 연관된 메모리에 하나의 foo 만 존재합니다. 두 개 이상의 객체를 만들려면 생성자가 최종 키워드를 위반하여 매번 하나의 foo를 다시 할당하려고 시도 합니다.

1. 최종 변수는 비정 적이므로 생성자에서 초기화 할 수 있습니다. 그러나 정적 인 경우 생성자가 정적이 아니기 때문에 생성자로 초기화 할 수 없습니다.
2. 목록에 추가하는 것은 목록을 최종적으로 만들어 중단 될 것으로 예상되지 않습니다. final참조를 특정 객체에 바인딩합니다. 해당 객체의 '상태'는 자유롭게 변경할 수 있지만 객체 자체는 변경할 수 없습니다.

다음은 final이 사용되는 다른 컨텍스트입니다.

최종 변수 최종 변수는 한 번만 지정할 수 있습니다. 변수가 참조 인 경우 다른 개체를 참조하기 위해 변수를 리 바인드 할 수 없습니다.

class Main {
   public static void main(String args[]){
      final int i = 20;
      i = 30; //Compiler Error:cannot assign a value to final variable i twice
   }
}

최종 변수는 나중에 값을 지정할 수 있지만 (선언 될 때 값을 할당 할 필요는 없음) 한 번만 가능합니다.

최종 클래스 최종 클래스는 확장 할 수 없습니다 (상 속됨)

final class Base { }
class Derived extends Base { } //Compiler Error:cannot inherit from final Base

public class Main {
   public static void main(String args[]) {
   }
}

최종 메소드 최종 메소드는 서브 클래스로 대체 할 수 없습니다.

//Error in following program as we are trying to override a final method.
class Base {
  public final void show() {
       System.out.println("Base::show() called");
    }
}     
class Derived extends Base {
    public void show() {  //Compiler Error: show() in Derived cannot override
       System.out.println("Derived::show() called");
    }
}     
public class Main {
    public static void main(String[] args) {
        Base b = new Derived();;
        b.show();
    }
}

나는 여기에 업데이트되고 깊이있는 답변을 쓰는 ​​것을 생각했습니다.

final 키워드는 여러 곳에서 사용할 수 있습니다.

1. 클래스

A final class는 다른 클래스가 해당 최종 클래스를 확장 할 수 없음을 의미합니다 . Java 런타임 ( JRE )은 객체 참조가 최종 클래스의 유형 (예 : F)임을 알고 있으면 해당 참조의 값은 F 유형 만 될 수 있다는 것을 알고 있습니다.

전의:

F myF;
myF = new F();    //ok
myF = someOther;  //someOther cannot be in type of a child class of F.
                  //because F cannot be extended.

따라서 해당 객체의 메소드 를 실행할 때 가상 테이블을 사용하여 런타임에 해당 메소드 를 분석 할 필요가 없습니다 . 즉, 런타임 다형성을 적용 할 수 없습니다. 따라서 런타임은 그것에 대해 신경 쓰지 않습니다. 즉, 처리 시간이 절약되어 성능이 향상됩니다.

2. 행동 양식

final method클래스를 확장 하위 클래스가 임의의 클래스 수단의 무시할 수없는 그 마지막 방법 (들). 따라서이 시나리오의 런타임 동작은 클래스에서 언급 한 이전 동작과 상당히 동일합니다.

3. 필드, 지역 변수, 메소드 매개 변수

위에서 위와 같은 종류를 지정한 경우 final값이 이미 확정되었으므로 값을 변경할 수 없습니다 .

전의:

필드의 경우 로컬 매개 변수

final FinalClass fc = someFC; //need to assign straight away. otherwise compile error.
final FinalClass fc; //compile error, need assignment (initialization inside a constructor Ok, constructor can be called only once)
final FinalClass fc = new FinalClass(); //ok
fc = someOtherFC; //compile error
fc.someMethod(); //no problem
someOtherFC.someMethod(); //no problem

메소드 파라미터

void someMethod(final String s){
    s = someOtherString; //compile error
}

이는 단순히 final기준값을 변경할 수 없음을 의미합니다 . 즉, 하나의 초기화 만 허용됩니다. 이 시나리오에서 런타임시 JRE 는 값을 변경할 수 없음을 알고 있으므로 최종 참조의 모든 최종 값을 L1 캐시에로드합니다 . 그것은 때문에 필요하지 않습니다 에 다시로드 에서 또 다시 메인 메모리 . 그렇지 않으면 L2 캐시에로드되고 기본 메모리에서 시간에 따라로드됩니다. 성능 향상이기도합니다.

따라서 위의 세 가지 시나리오에서 final사용할 수있는 위치에 키워드를 지정 하지 않은 경우 걱정할 필요가 없습니다. 컴파일러 최적화 가 그렇게 할 것입니다. 컴파일러 최적화가 우리를 위해하는 다른 많은 것들도 있습니다. :)

무엇보다도 정확합니다. 또한 다른 사람들이 클래스에서 하위 클래스를 만들지 않게하려면 클래스를 final로 선언하십시오. 그러면 아무도 더 이상 확장 할 수없는 클래스 트리 계층의 리프 수준이됩니다. 클래스의 거대한 계층 구조를 피하는 것이 좋습니다.