Java 기본 용어 정리 - 🧐 자주 함께 쓰이는 static과 final

 

 

< 이전 포스팅 - 인스턴스, 생성자 그리고 매개변수와 인자의 차이점>

 

기본 용어 정리 - 🧐 인스턴스, 생성자 그리고 매개변수(Parameter)와 인자(Argument)의 차이

 

 

---

 

 

🪽

"틀린 내용이 있을 수 있습니다."

 

 

 

► static

• static은 정적인, 고정된 이라는 뜻을 지녔다.
• 주로 변수나 메서드에 붙인다.
• 객체 생성 없이 사용가능하다. 
• 메모리에 적재되면 프로그램이 종료되어야 해제된다.
• static을 많이 사용하게되면 메모리에 과부하가 올 수 있다.
• static을 붙이면 static 영역에(메모리) 할당된다. ► 값이 고정적으로 유지된다.

 

 

 

Q. static이 붙었을 때와 붙지 않았을 때 코드가 어떻게 다른가?

A. 첫번째 예제는 변수에 static을 붙였을때와 아닐때를 보여주겠다.

 

<static 영역에 올라가 값이 고정적으로 유지되는 것을 보여주는 예제>

class Counter {

    // static을 붙인 변수 count
    // 변수 count를 0으로 초기화했다.
    static int count = 0;

    // 메서드 Counter
    // 메서드가 호출되면 변수 count는 ++증가한다.
    Counter() {
        count++;
        System.out.println("Count : " + count);
    }
}

public class Main {
    public static void main(String[] args) {
    	
        // 인스턴스 c1과 c2, c3가 생성되었다.
        // Counter 메서드가 실행되고, 메서드 내 count++;도 실행된다.
        Counter c1 = new Counter();  // Count: 1
        Counter c2 = new Counter();  // Count: 2
        Counter c3 = new Counter();  // Count: 3
        
    }
}

 

위의 예제에서는 static이 붙은 변수에 대해 보여주고 있다. static은 static 영역에 할당되어 값이 고정적으로 유지된다고 했다. 그 말은 위의 예제처럼 c1과 c2, c3가 개별적으로 증가하는 것이 아닌 모든 객체가 동일한 count 값을 가지게 되는 걸 알려준다.

 

class Counter {

    // static이 제거된 변수
    // 인스턴스 변수가 되었다.
    int count = 0;  

    // 메서드 Counter
    // 메서드가 실행되면 변수 count가 증가한다.
    Counter() {
        count++;
        System.out.println("Count: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
    	
        // 인스턴스 c1, c2, c3가 생성되며 Counter 메서드가 실행된다.
        Counter c1 = new Counter();  // Count: 1
        Counter c2 = new Counter();  // Count: 1
        Counter c3 = new Counter();  // Count: 1
    }
}

 

변수에서 static이 사라진 예제다. 변수에 static이 없기 때문에 변수 값이 공유되지 않는다. 그렇기에 인스턴스 c1과 c2, c3는 개별적으로 움직이게 되고 count는 개별적으로 올라가서 1이라는 값이 출력된다.

 

 

 

 

 

두번째 예제는 메서드에 static이 올라갈 경우 어떤식으로 차이가 있는지 살펴보겠다.

 

< 객체 생성 없이 사용하는 것을 보여주는 예제 >

class Add {
   
    // 메서드 add에 static이 붙었다.
    static int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
    
        // 객체를 생성하지 않아도 메서드 호출이 가능하다.
        int sum = Add.add(10, 20);  
        System.out.println(sum);  // 30
    }
}

 

 

메서드에 static을 붙이니 Add.add(10,30)으로 객체 생성 없이 결과값이 출력되었다.

	Add num = new Add();
	int sum = num.add(10, 20);
	System.out.println("Sum : " + sum);

 

만약 메서드에 static이 없어지면서 인스턴스 메서드로 변경되었다. 그렇기에 객체를 생성해야하고 그 후 객체를 통해 호출해야 오류 없이 결과가 제대로 출력될 수 있다.

 

 

 

 

Q. 왜 static이 붙은 변수나 메서드가 많아지면 메모리 과부화를 유발할까?

A. 메모리 구조를 잠깐 살펴보자면 [ heap 영역 /  stack 영역  /  static 영역 ] 이렇게 세가지가 존재한다. heap 영역은 인스턴스를 주로 관리한다고 보면 되고, stack 영역은 매개변수 혹은 지역변수를 관리하고 있고, static 영역은 static이 붙은 변수나 메서드를 관리한다.

 

heap 영역은 Garbage Collector가 있어서 쓰지 않고 있는 객체를 알아서 정리해준다. 하지만 static은 Garbage Collector가 없기 때문에 한 번 메모리에 적재되면  프로그램이 종료되기 전까지 해제되지 않는다. 그렇기 때문에 static을 무분별하게 사용하게되면 그만큼 메모리를 계속 사용하기 때문에 과부하가 발생할 수 있는 것이다.

 

 

 

 

---

 

 

 

► final

• 변수, 메서드, 클래스에 사용된다.
• final과 함께 선언되면 그 대상의 변경을 금지한다.
• final과 함께 선언된 변수는 상수가 된다.
• final과 함께 선언된 메서드는 오버라이드를 금지한다.
• final과 함께 선언된 클래스는 상속을 금지한다.

 

 

Q. final과 함께 사용된 변수의 경우는?

 

A.  final이 붙은 변수의 값을 변경하려 할 경우 오류가 발생하는지 예제를 통해 살펴보겠다.

현재 예제는 final이 붙지 않은 변수를 변경하는 예제이다.

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

           // final이 붙은 변수
           final int a = 10;
           
           // 평범한 변수
           int b = 20;
           
           System.out.println("a : " + a); // a : 10
           System.out.println("b : " + b); // b : 20

           // 변수 b의 값만 바꿔보았다.
           b = 2;

           // final이 붙지 않은 변수 b는 잘 출력되었다.
           System.out.println("update b : " + b); // update b : 2

        }
    }

 

결과가 잘 출력되었다.

 

 

그렇다면 이번엔 final이 붙은 변수를 바꿔보도록 하겠다.

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

           // final이 붙은 변수
           final int a = 10;
           
           // 평범한 변수
           int b = 20;
           
           System.out.println("a : " + a); // a : 10
           System.out.println("b : " + b); // b : 20

           a = 1;
           b = 2;

           System.out.println("update a : " + a);
           System.out.println("update b : " + b); 

        }
    }

 

fianl 변수(variable) a에는 값을 할당할 수 없다는 문구와 함께 오류가 발생했다.

 

 

 

 

Q. final과 함께 사용된 메서드의 경우는?

 

A. 오버라이드가 불가하다. 오버라이드란 쉽게 말해 상속받은 메서드를 인스턴스 메서드로 재정의하는 것이다. 쉽게 설명하자면 메서드에 쓰인 이름을 동일하게 가져가서 값만 바꿔 사용한다고 생각하면 될 것 같다. 물론 무작정 이름을 똑같이 정의할 수 있는 것은 아니다. 매개변수 타입 혹은 갯수가 동일하지 않아야한다는 조건이 있다. (그 외에도 있음)  

 

class Parent {

    // final 메서드인 fail
    public final void fail() {
        System.out.println("과연 오류가 발생할까?");
    }
}

// 자식 클래스
class Child extends Parent {

    // fail 메서드를 재정의 했다.
    @Override
    public void fail() {
        System.out.println("오류가 발생할 것이다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.fail();
    }
}

 

이렇게 오류가 발생했다. 오류 메세지를 살펴보면 Child 클래스 안에 있는 fail( )은 Parent 클래스 안에 있는 fail 메서드를 재정의 할 수 없습니다, 재정의된 메서드는 final입니다. 라고 되어있다. 클래스에 final이 붙은 경우는 상속이 불가한 경우니 넘어가도록 하겠다.

 

 

 

 

Q. 그렇다면 주로 final과 static을 함께 쓰는 이유가 무엇일까?

A. final과 static이 변수에 선언되어있다면 그 의미는 이 값은 클래스 내에 다 공유되고 있으며, 이 값은 변경할 수 없어 라는 의미가 된다. 그렇다면 주로 어디에 사용이될까? 다양한 곳에 활용되겠지만, 몇 가지 예를 생각해보면 원주율과 같은 수학적인 부분도 있고 프로그램 최대 사용자의 수를 지정해야할 경우에도 사용할 수 있을 것 같다. 

final과 static이 메서드에 선언되었다면 객체를 만들 필요없이 클래스 이름을 써서 바로 호출하면서 이 메서드를 다른 곳에서 사용하거나 바꿀 수 없다는 의미가 된다. 쉽게 말해 객체 없이 호출하고 재정의할 필요가 없을 때 쓴다는 것이다. 활용되는 곳에 대해 생각해보면 회원가입 시, 이메일을 적으라고 했을 경우 그 이메일의 형식이 맞는지 검증할 때 쓰일 수 있겠다. 

 

결론, 프로그램 전체에서 일관된 값을 유지할 때 사용한다.

 

 

 

 

 

 

혼자 공부하면서 이해하고 쓴 내용이라 틀린 내용이 있을 수 있습니다.

댓글로 적어두시면 수정하도록 하겠습니다. 🍀

 

[ 블로그에 쓴 내용들의 출처는 아래에 적어둘테니

들어가서 읽어보시면 더욱 도움이 되실 듯 합니다 ]

 

 

 

 

 

---

 

- static 출처

[JAVA] Static? 그거 왜 붙이는건데?

 

 

- static 출처

[Java] static을 언제 사용할까?

 

 

- static 예제 출처

[JAVA] static(정적) 변수와 메소드

 

 

-final 출처

[Java] final 을 알아보자

 

 

- 오버라이드 출처

8. 오버로딩, 오버라이드 : Overloading, Override & 다형성

 

 

- static과 final을 같이 사용하는 이유 출처

자바의 static과 final 키워드 깊게 이해하기