🌊 ._.sori🪽

< 이전 정리 글  - 자주 함께 쓰이는 static과 final >

< 자바 완전 정복_ 10장 클래스의 상속과 다향성 >

🪽

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

1. 기본적인 오버라이딩

class A {
    void print() {
         System.out.println("A 클래스")
    }
}

class B extends A {
    @Override
    void print() {
         System.out.println("B 클래스")
    }
}

public class MethodOverrideing_1 {
     public static void main(String[] args) {
         
         A aa = new A();
         aa.print();
         
         B bb = new B();
         bb.print();
         
         A ab = new B();
         ab.print();
     }
}

이 코드는 '자바 완전 정복'의 코드다. 전에 배웠던걸 복습해보자면, A aa = new A( );는 A 클래스의 생성자이자 A 타입이다. aa.print( )를 실행하면 A 클래스에 있는 print 메서드가 실행된다.

그 다음 A 객체가 생성된 후 B bb = new B( );가 생성되니 메서드 영역에 저장된 A의 print 메서드를 덮고 B의 print 메서드가 올라타게 된다. 그러니 bb.print( )가 실행되면 "B 클래스"가 출력된다.

이제 A ab = new B( );를 살펴보자. 해당 코드는 A 타입의 참조 변수 타입을 가지고 있다. 그렇다는 말은 ab.print( )는 "A 클래스"가 출력되야한다는 것이다. 하지만 아까 위의 코드에서 이미 B bb = new B( );로 A 객체가 가리키는 print 메서드가 B 클래스의 print( ) 메서드로 오버라이딩이 되었다. A ab = new B( );는 B의 print( )가 실행되고 "B 클래스"가 출력된다.

2. 업캐스팅과 다운캐스팅

class A {
    void print() {
        System.out.println("A 클래스");
    }
}

class B extends A {
    @Override
    void print() {
        System.out.println("B 클래스");
    }
    
    void printB() {
        System.out.println("B에만 있는 메서드");
    }
}

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

        A aa = new A();   
        B bb = new B();   

        A ab = new B();  
        ab.print();       

        // ab.printB();  

        B b2 = (B) ab;    
        b2.printB();     
    }
}

업캐스팅은 아까 기본 오버라이딩에서 했다. A ab = new B( );가 업캐스팅한 케이스다. 업캐스팅이란, 자식 클래스(B 클래스)가 부모 클래스(A 클래스) 타입으로 참조하는 것을 의미한다. 쉽게 설명하자면, B 클래스를 인스턴스로 가져도 B 클래스에 있는 모든 메서드와 필드를 사용하는 것이 아니라 결국 타입은 A이기에 A 클래스에 있는 메서드와 필드만 사용할 수 있다고 이해하면 된다.

그러면 printB( ) 메서드는 B 클래스에만 있고 A 클래스에 없기 때문에 사용할 수 없다. 이런 경우 printB를 사용하고 싶다면, 참조 타입도 실체 객체도 B인 B bb = new B( );를 통해 사용하거나 ab를 다운 캐스팅하면 된다.

다운 캐스팅은 타입을 다시 B b2 = (B) ab로 바꿔주면 된다. 이것을 형변환이라고 부른다.

3. super( ), this( )

class A {
    A() {
        this(3);
        System.out.println("A 생성자1")
    }
    
    A(int a) {
        System.out.println("A 생성자2")
    }
}

class B extends A {
    B() {
         this(3);
         System.out.println("B 생성자1")
    }
    
    B(int a) {
         System.out.println("B 생성자2")
    }
}

A aa1 = new A();
A aa2 = new A(3);

B bb1 = new B();
B bb2 = new B(3);

클래스의 이름과 똑같은 메서드가 있다면 그것은 생성자이다. 그러면 A aa1 = new A( ); 이것은 생성자 호출 코드이다. super와 this는 생성자 안에서 사용된다. super는 부모 클래스 생성자를 호출시키며, 만일 생성자에 super나 this가 없다면 컴파일러가 자동으로 super를 포함시켜준다. 그리고 this는 같은 클래스 내부에 있는 다른 생성자를 호출시킨다.(생성자가 2개 이상 있어야 사용가능하다.) 즉 this는 부모 클래스에 있는 생성자로 가지 않게 해준다.

B bb1 = new B( );를 살펴보자.

1) this(3)으로 인해 같은 클래스 안에 있으면서, 3이라는 인자를 받을 수 있는 B(int a)가 실행된다.
2) 그런데 B(int a) 생성자는 this가 없기 때문에 컴파일러가 자동적으로 super를 넣어줄 것이다.
3) super로 인해 부모클래스에 있는 기본 생성자(A)로 가게 된다.
4) A 클래스의 기본 생성자 A에 this(3)이 있으니, int형 인자 하나를 받는 A 생성자가 실행될 것이다.
5) A(int a)가 실행되어 드디어! "A 생성자2"가 출력될 것이다.
6) 그러면 다시 A 클래스의 기본 생성자 A로 돌아와 "A 생성자 1"이 출력된다.
7) 또 전으로 돌아가 B 클래스의 B(int a)의 "B 생성자 2"가 호출되고
8) 마지막으로 가장 처음 호출되었던 B 클래스의 기본 생성자 B의 "B 생성자 1"이 호출된다.

만약에 A ab = new B( ); 코드를 넣어본다면 어떻게 될까? 결국 자식 클래스 B의 B( )가 실행되기 때문에 호출과정부터 답까지 모두 같다.

4. 문제 

- 수제비 정보처리기사 2023 책 문제 발췌

class Parent {
    public Parent() {
        System.out.print("A");
    }
    public void fn() {
        System.out.print("B");
    }
    public void fnA() {
        System.out.print("C");
    }
}

class Child extends Parent {
    public Child() {
        System.out.print("D");
    }
    public void fn() {
        System.out.print("E"); 
    }
    public void fnB() {
        System.out.print("F");
    }
}

Child c = new Child( );
c.fn( );
c.fnA( );

1) Child c = new Child( );로 Child 생성자가 호출되었으니 Child( )가 호출될 것이다. 
2) 그런데 Child( ) 내부에 this가 없다. (물론 this를 쓸 수 없다, 생성자가 1개라서)
3) 컴파일러가 자동적으로 super를 넣어 부모 클래스 Parent의 생성자를 호출한다.
4) Parent 생성자가 호출되어 "A"가 출력된다.
5) 다시 Child 생성자로 돌아와서 "B"가 출력된다.

6) c.fn( );은 Child 클래스에 fn 메서드가 있으니 "E"가 출력된다.
7) c.fnA( );은 fnA가 Parent 클래스에 있지만 Child가 Parent 클래스를 부모 클래스로 받고 있기 때문에 문제 없이 Parent 클래스의 fnA가 실행되어 "C"가 출력된다.

1.
Parent cp = new Child();
cp.fn();
cp.fnA();

2.
Child pc = new Parent():
cp.fn();
cp.fnA():

3.
Parent p = new Parent();
cp.fnB();

위의 경우는 어떨까?

1번의 경우 문제없이 다 실행이 된다.

그런데 2번의 경우 Child pc = new Parent( );에서 컴파일 오류가 발생한다. 참조 변수는 하위 클래스인 Child인데 하위 클래스인 참조 타입 안에 상위 클래스인 Parent 객체를 넣을 수 없기 때문이다.

3번도 실행될 수 없다. Parent는 부모 클래스로 하위 클래스인 Child의 메서드를 사용할 수 없다. 그 이유는 다양하지만, 코드의 안정성을 위함이 있다. 메서드 호출은 참조변수 타입을 기준으로 접근하게 한다는 것을 알아두면 좋을 듯 하다.

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

🪽

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

► 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 출처

- static 출처

- static 예제 출처

-final 출처

- 오버라이드 출처

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

< 이전 포스팅 - 변수>

🪽

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

► 인스턴스

• 클래스가 설계도, 인스턴스는 설계도는 보고 만든 물건이다.
• 실체화된 객체를 인스턴스라고 부른다.
• 즉 메모리에 할당되어 생성된 객체를 인스턴스라 부른다.
• 객체 내에 인스턴스라는 개념이 포함되어있다.
• 하지만 객체와 인스턴스를 구분하는 것이 크게 의미있진 않은 것 같다...

Q. 클래스가 설계도며 인스턴스가 설계도를 보고 만든 물건이라는데, 그게 무슨 말인가?

A. 자동차와 관련된 설계도가 있다고 가정하겠다.

// 출처 - jongtachi님

// 자동차를 만들 설계도(클래스)
class Car {
    String brand;
    String model;

    // 설계도를 따라 자동차를 만드는 방법(생성자)
    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }
}

public class Main {
    public static void main(String[] args) {
    
        // 실제 차를 만드는 과정(인스턴스)
        Car myCar = new Car("Toyota", "Camry");

        System.out.println("브랜드: " + myCar.brand);
        System.out.println("모델: " + myCar.model);
    }
}

► 생성자

• 생성자의 이름은 클래스 이름과 동일해야한다.
• 리턴타입이 없다.
• 매개변수 조건에 따라 여러개 생성 가능하다. (오버로딩)
• 생성자 코드가 없으면 자동으로 기본생성자를 생성하지만, 생성자 코드가 하나라도 있을 시 기본생성자를 생성하지 않는다.

Q. 매개변수 조건에 따라 여러개 생성 가능하다라는 말이 무슨 말일까?

A. 매개변수 조건에 따라 여러개 생성 가능하다라는 말은 생성자 오버로딩을 의미한다. 

아래 예제처럼 생성자의 매개변수(year, model)에 따라 오버로딩이 가능하다.

주의해야할 점은 위의 코드처럼 같은 타입의 매개변수가 있을 경우 오류가 발생하니 타입을 변경하거나 매개변수의 갯수가 달라야한다.

// 출처 - jongtachi님의 코드 수정

class Car {
    int year;
    String model;

    // 년도만 받는 생성자
    public Car(int year) {
        this.year = year;
        this.model = "받지 않음";
    }

    // 모델만 받는 생성자
    public Car(String model) {
        this.year = 0;
        this.model = model;
    }

    // 년도, 모델 받는 생성자
    public Car(int year, String model) {
        this.year = year;
        this.model = model;
    }

    public void resultPrint() {
        System.out.println("Year: " + year + "   " + "Model: " + model);
    }
}

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

            // 년도만 아는 경우
            Car car1 = new Car(2024);
            car1.resultPrint();

            // 모델만 아는 경우
            Car car2 = new Car("Camry");
            car2.resultPrint();

            // 년도와 모델만 아는 경우
            Car car3 = new Car(2024, "Camry");
            car3.resultPrint();


        }
    }

Q. 생성자 코드가 하나라도 있을 시 기본 생성자를 생성하지 않는다는 것은 무슨 말인가?

A.  새로운 인스턴스를 생성했고 어떤 생성자도 없으면 프로그램은 자동으로 기본생성자를 만들어낸다. 

// 자동차를 만들 설계도(클래스)
class Car {
    int year;
    String model;

	// 어떤 생성자도 존재하지 않는다.
    
    public void resultPrint() {
        System.out.println("Brand: " + year + "   " + "Model: " + model);
    }
}

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

            // car1 인스턴스 생성
            Car car1 = new Car();
            car1.resultPrint();


        }
    }

오류가 발생할 것 같지만 결과값은 출력된다.

자동으로 생성자를 만들어낸 것이다.

그런데 생성자를 하나라도 만들게 되면 기본 생성자도 개발자가 직접 만들어야한다.

// 자동차를 만들 설계도(클래스)
class Car {
    int year;
    String model;


    // 기본 생성자
    public Car() {

    }


    // 브랜드, 모델 받는 생성자
    public Car(int year, String model) {
        this.year = year;
        this.model = model;
    }

    public void resultPrint() {
        System.out.println("Brand: " + year + "   " + "Model: " + model);
    }
}

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

            // 기본 생성자를 이용할 인스턴스
            Car car1 = new Car();
            car1.resultPrint();


            Car car2 = new Car(2024, "Camry");
            car2.resultPrint();


        }
    }

만약 안 만들게 되면?

// 자동차를 만들 설계도(클래스)
class Car {
    int year;
    String model;


    // 브랜드, 모델 받는 생성자
    public Car(int year, String model) {
        this.year = year;
        this.model = model;
    }

    public void resultPrint() {
        System.out.println("Brand: " + year + "   " + "Model: " + model);
    }
}

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

            // 기본생성자가 없는 경우
            Car car1 = new Car();
            car1.resultPrint();


            Car car2 = new Car(2024, "Camry");
            car2.resultPrint();


        }
    }

오류가 발생하게 된다.

Q. 생성자는 왜 만드는 것인가?

A. 다양한 이유가 있지만, 객체를 생성할 때 꼭 필요한 값들을 받을 수 있도록 강제할 수 있다. 예시로 대부분 프로그램을 만들면 가장 기본적으로 회원가입 페이지를 만들게 된다. 그럴때 회원님의 성함과 아이디, 비밀번호, 주소 등 내가 만들 프로그램에 꼭 쓰일 정보를 받도록 할 수 있는 것이다. 그 외에도 유지보수면, 일관성 등이 있다.

► 매개변수(Parameter)

• 매개변수는 생성자나 메서드를 정의할 때 어떤 값을 받을지 명시하는 변수이다.

► 인자(Argument)

• 인자는 생성자나 메서드를 호출할 때 실제로 전달되는 값이다.

Q. 그래서 둘이 뭐가 어떻게 다르다는 것인가?

A. 지금까지 봐온 코드에 매개변수, 인자 모두 나타나있다.

    // 브랜드, 모델 받는 생성자
    public Car(int year, String model) {
        this.year = year;
        this.model = model;
    }

여기에서 year과 model은 매개변수이다. 매개변수는 메서드나 생성자를 정의할 때 어떤 값을 받을지 명시하는 변수라고 했고 Car는 생성자로 변수를 year은 정수형으로 model은 문자열로 받겠다고 명시한 것이다.

Car car2 = new Car(2024, "Camry");
car2.resultPrint();

그렇다면 2024와 Camry는 인자가 될 것이다. 인자는 생성자나 메서드를 호출할 때 실제로 전달되는 값이니 2024와 Camry가 된다는 걸 바로 알 수 있다. 

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

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

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

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

< 이후 포스팅 - static과 final>

- 인스턴스 출처

- jongtachi님 예제 출처

- 생성자와 매개변수 출처

- 생성자와 오버로딩 출처

- 매개변수와 인자의 차이 출처

🪽

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

► 변수

변수란, 프로그래밍에서 값을 저장하고 관리하기 위해 사용하는 이름이 붙은 메모리 공간이다.

변수는 변수가 선언된 위치에 따라 변수의 종류를 정한다.

1. 클래스 변수 (전역변수)

클래스 변수의 특징은 크게 네가지가 있다.

• 변수 타입 앞에 static을 붙인다.
• 클래스 변수는 모든 인스턴스가 공유한다.
• 모든 인스턴스가 공통된 값을 공유한다.
• 클래스 이름, 클래스 변수명을 통해 접근할 수 있다.

Q. 모든 인스턴스가 공유된다는 말이 무슨 의미인가?

A. 생성된 인스턴스는 클래스 변수를 참조한다는 것이다. 쉽게 설명하자면 클래스 변수는 마을에 놓인 우체통이고 인스턴스는 집이라고 비유할 수 있다. 집(인스턴스)는 우체통(클래스 변수)에 편지를 꺼낼수도 편지를 넣을 수도 있다. 모든 집이 똑같은 우체통을 쓰기 때문에 어떤 집에서 넣은 편지를 다른 집에서 꺼내 볼 수 있다.

// chat-GPT를 통해 예제를 만들었습니다.

class Counter {

    // static이 붙은 것을 통해 클래스 변수라는 것을 알 수 있다.
    // 클래스 변수를 0으로 초기화했다.
    static int count = 0;  

    // 생성자 Counter를 통해 new Counter()가 있으면 count 변수가 증가하도록 했다.
    Counter() {
        count++;  
    }
 
    // 현재 count가 얼마나 증가했는지 보여주는 메서드를 만들었다.
    void showCount() {
        System.out.println("Count: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
    
    	// 인스턴스 c1과 c2가 생성되었다.
    	// 생성자를 통해 count++가 실행된다.
        // c1과 c2로 count++가 총 두 번 실행되었다.
        Counter c1 = new Counter();  
        Counter c2 = new Counter();  

        // 이 c1과 c2는 showCount 메서드를 통해 결과값이 출력된다.
        // 결과값은 2가 된다.
        // 2가 나오는 이유는 동일한 클래스 변수 count를 출력하기 때문이다.
        c1.showCount();  
        c2.showCount();  
    }
}

2. 인스턴스 변수 (전역변수)

인스턴스 변수의 특징은 크게 세가지가 있다.

• 인스턴스가 생성되어야 변수가 생성된다.
• 클래스 객체와 다르게 공유되지 않는다.
• 인스턴스마다 고유한 다른 값을 가질 수 있다.

인스턴스 변수와 클래스 변수의 차이를 알아보는 예제를 찾았다.

// 출처 - sujinhope님
public class Main {

    public static class StaticTest {

	// 클래스 변수
        static int classVar = 10;
        //인스턴스 변수
        int instanceVar = 28;

    }


    public static void main(String[] args) {

	// staticTest1과 staticTest2인 인스턴스가 생성했다.
        StaticTest staticTest1 = new StaticTest();
        StaticTest staticTest2 = new StaticTest();
        
        // 실행 값은 1번과 2번 모두 10과 28이 된다.
        System.out.println("1번 " + staticTest1.classVar + ", " + staticTest1.instanceVar);
        System.out.println("2번 " + staticTest2.classVar + ", " + staticTest2.instanceVar);

	// 클래스 변수 staticTest1의 값을 12로 변경했다.
        staticTest1.classVar = 12;
        // 인스턴스 변수 staticTest1의 값을 400으로 변경했다.
        staticTest1.instanceVar = 400;

        System.out.println();
        // 1번의 출력값은 12와 400이 된다.
        // 2번의 출력값은 12와 28이 된다.
        System.out.println("1번 " + staticTest1.classVar + ", " + staticTest1.instanceVar);
        System.out.println("2번 " + staticTest2.classVar + ", " + staticTest2.instanceVar);;
    }
}

클래스 변수는 인스턴스의 모든 값을 공유하기 때문에 하나의 인스턴스 값이 바뀌면 모든 인스턴스가 값을 변경된다. 
인스턴스 변수는 인스턴스의 값을 공유하지 않기 때문에 인스턴스가 개별적으로 값을 유지하는 것이 가능하다.

Q. 클래스, 인스턴스, 클래스 변수, 인스턴스 변수가 무엇인가?

A. 비유로 예를 들어보겠다. [ 클래스는 빵틀  ,  인스턴스는 빵틀로 찍어낸 빵  ,  클래스 변수는 빵에 표식을 남기는 빵집의 시그니처(?)  ,  인스턴스 변수는 빵 안에 들어가는 잼 ]으로 생각할 수 있다.

3. 지역변수

• 메서드 내에서 선언된다.
• 메서드가 실행될 때 메모리를 할당받는다.
• 메서드가 종료되면 소멸되어 사라진다.

// 출처 - sujinhope님
public class Main {

    public static class StaticTest {

	// 전역변수 중 하나인 클래스 변수이다.
        static int classVar = 10;
        // 전역변수 중 하나인 인스턴스 변수이다.
        int instanceVar = 28;

	// 메서드인 method를 만들었다.
        public void method() {
            // 지역변수 localVar
            int localVar = -100;
            System.out.println("지역 변수 값 : " + localVar);
        }

    }


    public static void main(String[] args) {

	// localTest 인스턴스를 만들었다.
        StaticTest localTest = new StaticTest();
	// 인스턴스를 통해 method 실행한다.
        localTest.method();
    }
}

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

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

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

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

< 이후 포스팅 - 인스턴스, 생성자, 매개변수와 인자의 차이>

- 변수의 개념 정리 출처

- sujinhope님의 예제 출처

- 전역변수와 지역변수의 개념 정리 출처

- chatGPT의 도움도 받았습니다.