Java Language
비 접근 수정 자

소개

결정적인

Java의 final 은 변수, 메소드 및 클래스를 참조 할 수 있습니다. 세 가지 간단한 규칙이 있습니다.

• 최종 변수를 다시 할당 할 수 없습니다.
• 최종 메서드를 재정의 할 수 없습니다.
• 최종 수업은 연장 될 수 없다.

용도

좋은 프로그래밍 연습

개발자는 가능한 한 변수 최종을 표시하는 것이 좋습니다. 변수를 변경해서는 안되는 경우에는 최종 변수로 표시해야합니다.

메서드 매개 변수의 경우 final 키워드를 사용하는 것이 중요합니다. 메소드가 입력 매개 변수를 변경하지 않는다는 것을 강조하려면 특성을 최종으로 표시하십시오.

public int sumup(final List<Integer> ints);

이것은 sumup 메소드가 ints 를 변경하지 않는다는 것을 강조합니다.

내부 클래스 액세스

익명의 내부 클래스가 변수에 액세스하려면 변수를 final 로 표시해야합니다.

  public IPrintName printName(){
    String name;
    return new IPrintName(){
        @Override
        public void printName(){
            System.out.println(name);
        }
    };
}

이 클래스는 변수 name 처럼 최종으로 컴파일되지 않습니다.

final static 변수

때 아래 코드는 완전히 법적 비록 final 변수 foo 아닌 static 의 경우 static 이 컴파일되지 않습니다 :

class TestFinal {
    private final static List foo;

    public Test() {
        foo = new ArrayList();
    }
}

이유는, 다시 반복하자. 최종 변수를 재 할당 할 수 없기 때문 이다. foo 는 정적이므로 TestFinal 클래스의 모든 인스턴스에서 공유됩니다. TestFinal 클래스의 새 인스턴스가 만들어 TestFinal 생성자가 호출되므로 컴파일러에서 허용하지 않는 foo가 다시 할당됩니다. 이 경우 변수 foo 를 초기화하는 올바른 방법은 다음 중 하나입니다.

class TestFinal {
    private static final List foo = new ArrayList();
    //..
}

또는 정적 이니셜 라이저를 사용하여 :

class TestFinal {
    private static final List foo;
    static {
        foo = new ArrayList();
    }
    //..
}

final 메소드는 기본 클래스가 파생 클래스가 변경하지 않아야하는 중요한 기능을 구현할 때 유용합니다. 가상 테이블 개념이 없으므로 비 최종 메서드보다 빠릅니다.

Java의 모든 래퍼 클래스는 Integer , Long 등과 같이 최종 클래스입니다.이 클래스의 제작자는 Integer를 자신의 클래스로 확장하고 Integer 클래스의 기본 동작을 변경할 수 있기를 원하지 않았습니다. 클래스를 불변으로 만드는 요구 사항 중 하나는 서브 클래스가 메서드를 재정의 할 수 없다는 것입니다. 가장 간단한 방법은 클래스를 final 로 선언하는 것입니다.

휘발성 물질

volatile 수정자는 다중 스레드 프로그래밍에 사용됩니다. 필드를 volatile 으로 선언하면 스레드는 로컬 캐시 된 값이 아니라 최신 값을 읽어야한다는 신호입니다. 게다가, volatile 읽기와 쓰기는 원자 적으로 (비 volatile long 또는 double 대한 액세스는 원자 적이 지 않음) 보장되므로 다중 스레드 간의 읽기 / 쓰기 오류를 피할 수 있습니다.

public class MyRunnable implements Runnable
{
    private volatile boolean active;
 
    public void run(){ // run is called in one thread 
        active = true;
        while (active){
            // some code here
        }
    }
    
    public void stop(){ // stop() is called from another thread
        active = false;
    }
}

공전

static 키워드는 클래스, 메소드 또는 필드에서 사용되어 클래스의 모든 인스턴스와 독립적으로 작동하게합니다.

• 정적 필드는 클래스의 모든 인스턴스에 공통입니다. 그들에게 접근하기 위해 인스턴스가 필요 없습니다.
• 정적 메소드는 자신이 속한 클래스의 인스턴스없이 실행될 수 있지만, 그 클래스의 정적 필드에만 액세스 할 수 있습니다.
• 정적 클래스는 다른 클래스 내부에서 선언 될 수 있습니다. 그들은 인스턴스화 될 클래스의 인스턴스를 필요로하지 않습니다.

public class TestStatic
{
    static int staticVariable;

    static {
        // This block of code is run when the class first loads
        staticVariable = 11;
    }

    int nonStaticVariable = 5;

    static void doSomething() {
        // We can access static variables from static methods
        staticVariable = 10;
    }

    void add() {
        // We can access both static and non-static variables from non-static methods
        nonStaticVariable += staticVariable;
    }

    static class StaticInnerClass {
        int number;
        public StaticInnerClass(int _number) {
            number = _number;
        }

        void doSomething() {
            // We can access number and staticVariable, but not nonStaticVariable
            number += staticVariable;
        }

        int getNumber() {
            return number;
        }
    }
}


// Static fields and methods
TestStatic object1 = new TestStatic();

System.out.println(object1.staticVariable); // 11
System.out.println(TestStatic.staticVariable); // 11

TestStatic.doSomething();

TestStatic object2 = new TestStatic();

System.out.println(object1.staticVariable); // 10
System.out.println(object2.staticVariable); // 10
System.out.println(TestStatic.staticVariable); // 10

object1.add();

System.out.println(object1.nonStaticVariable); // 15
System.out.println(object2.nonStaticVariable); // 10

// Static inner classes
StaticInnerClass object3 = new TestStatic.StaticInnerClass(100);
StaticInnerClass object4 = new TestStatic.StaticInnerClass(200);

System.out.println(object3.getNumber()); // 100
System.out.println(object4.getNumber()); // 200

object3.doSomething();

System.out.println(object3.getNumber()); // 110
System.out.println(object4.getNumber()); // 200

추상

추상화는 구현 세부 정보를 숨기고 사용자에게 기능 만 표시하는 프로세스입니다. 추상 클래스는 결코 인스턴스화 될 수 없습니다. 클래스가 추상으로 선언 된 경우 유일한 목적은 클래스를 확장하는 것입니다.

abstract class Car
{
    abstract void tagLine();
}
 
class Honda extends Car
{
    void tagLine()
    {
        System.out.println("Start Something Special");
    }
}
 
class Toyota extends Car
{
    void tagLine()
    {
        System.out.println("Drive Your Dreams");
    }
}

동기화 된

동기화 된 한정자는 특정 스레드 나 여러 스레드의 블록 액세스를 제어하는 ​​데 사용됩니다. 동기화 된 것으로 선언 된 메소드 또는 블록에는 하나의 스레드 만 입력 할 수 있습니다. synchronized 키워드는 객체의 고유 잠금에서 작동하고, 동기화 된 메소드의 경우 현재 객체 잠금과 정적 메소드가 클래스 객체를 사용합니다. 동기화 된 블록을 실행하려고하는 모든 스레드는 먼저 객체 잠금을 획득해야합니다.

class Shared
{
    int i;
 
    synchronized void SharedMethod()
    {
        Thread t = Thread.currentThread();
 
        for(int i = 0; i <= 1000; i++)
        {
            System.out.println(t.getName()+" : "+i);
        }
    }

    void SharedMethod2()
    {
        synchronized (this)
        {
            System.out.println("Thais access to currect object is synchronize "+this);
        }
    }
}
 
public class ThreadsInJava
{
    public static void main(String[] args)
    {
        final Shared s1 = new Shared();
 
        Thread t1 = new Thread("Thread - 1")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        Thread t2 = new Thread("Thread - 2")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        t1.start();
 
        t2.start();
    }
}

과도 현상

transient로 선언 된 변수는 객체 직렬화 중에 직렬화되지 않습니다.

public transient int limit = 55;   // will not persist
public int b; // will persist

엄격한

// strictfp keyword can be applied on methods, classes and interfaces.

strictfp class A{}

strictfp interface M{}

class A{  
    strictfp void m(){}
}