주인장의 프로그래밍 개발 공부방

여기를 찾아와 주시는 분들께

거신 — Thu, 18 May 2023 02:11:55 +0900

본업에 바빠서 블로그에 전혀 신경을 쓰지 못하고 있었는데

부족한 글을 읽어주시면서 다음 글을 기다리고 있다는 댓글을 보고

다시 키보드를 누르게 되었습니다

일에 치이고 바빠서 다른 곳에 신경 쓸 겨를이 없었는데

이제는 좀 여유가 생기기 시작했고 다음 글을 기다리고 있다는 말이 계속 마음에 걸려

여전히 부족한 지식이지만 누군가에게 도움이 되었으면 좋겠다는 생각으로

글을 쓰고 있습니다.

본업이 개발자이긴 하나 누군가를 가르치고 하는 사람은 아니기에

지식을 전달하는 능력이 많이 부족한 것도 사실입니다.

제 스스로도 명확하지 않거나 부족한 부분은 다시 공부하고 채워넣고 정리를 하면서

글을 쓰기 때문에 한 편을 작성할 때 시간이 많이 걸리기도 합니다.

그럼에도 가능한

잘못되거나 왜곡된 내용없이 정확한 정보만 전달하고,

애매모호한 부분은 명확하게,

프로그래밍 공부를 하는 사람이라면

누가 읽더라도 이해하기 쉽도록

작성하는 걸 모토로 글을 쓰고 있습니다.

모든 댓글에 일일이 답변을 달아드리진 못하지만

항상 부족한 글을 읽어주시는 분들께도 감사하고

거기에 댓글까지 적어주시는 분들께도 감사드립니다.

[자바 프로그래밍 기본] 3. 클래스의 구성 (2) 멤버 변수의 초기화

거신 — Thu, 18 May 2023 02:08:10 +0900

지난 시간에 클래스의 구성요소인 멤버에 대해서 알아봤다.

그렇다면 이제 멤버를 사용하는 방법에 대해서 알아봐야 할텐데

하지만 그 전에 중요한 과정이 하나 기다리고 있다.

바로 멤버 변수의 초기화다.

이전에 프로그래밍 기본 지식 과정의 첫 번째 챕터에서 다뤘던 변수에서

변수의 기본 값과 초기화에 대해서 간단히 알아본 적이 있었다.

이번 시간은 그 내용의 연장선으로서 클래스의 멤버 변수의 초기화에 대해서 자세히 알아보고자 한다.

변수의 기본값과 초기화 내용은 아래에서 확인할 수 있다.

https://colossus-java-practice.tistory.com/5

[Chapter 1 변수] 5. 변수의 기본 값과 초기화

지난 시간까지 변수가 무엇인지와 변수타입의 종류, 변수를 선언하는 방법 등을 알아봤다. 이번에는 변수의 기본 값과 초기화를 하는 방법에 대해서 알아보자. 목표 : 변수 각 타입의 기본 값이

colossus-java-practice.tistory.com

1. 멤버 변수의 초기화

이 글을 읽고 있는 사람이라면 프로그래밍에서 초기화가 무슨 의미인지

다들 알고 있을 것이라고 생각한다.

간단하게 설명하자면

변수를 선언하고 그 변수에 값을 저장하는 것을 초기화라고 한다.

멤버 변수의 초기화도 마찬가지로 동일한 의미를 가지고 있다.

멤버 변수를 선언하고 그 멤버 변수에 값을 저장하는 것이다.

그런데 일반적인 변수의 초기화와 멤버 변수의 초기화는 조금 차이점이 있다.

변수의 초기화 내용에서 전역 변수와 지역 변수에 따라서

초기화를 해도 되고 하지 않아도 된다고 한 적이 있었다.

그것이 바로 오늘 알아보는 멤버 변수의 초기화인 것이다.

멤버 변수는 클래스 안에서 선언된 변수, 즉, 전역 변수를 말하는데

전역 변수는 선언하고 초기화를 하지 않아도 문제가 발생하지 않는다.

멤버 변수는 선언함과 동시에 자동으로 변수의 타입에 맞는 기본값으로 초기화가 된다.

예시 1)

class SampleClass {
    int x;
    
    void sampleMethod() {
    	int i;
    }
}

간단한 소스코드를 작성해 보았다.

너무나도 잘 알고 있듯이 변수 x는 클래스의 멤버 변수로 전역 변수이다.

변수 i는 메소드 안에서 선언된 지역 변수이다.

위의 소스코드는 오류가 발생하는데

바로 지역 변수인 i를 초기화하지 않았기 때문이다.

하지만 변수 x는 초기화하지 않았다고 해서 문제가 발생하지 않는다.

이는 클래스가 생성되면서 클래스의 멤버 변수인 x에 자동으로 0으로 초기화가 되기 때문이다.

이와 같이 멤버 변수는 굳이 직접적으로 초기화를 하지 않더라도

알아서 초기화를 해주기 때문에 문제가 발생하지 않는다.

"하지만 의도하지 않은 값을 방지하기 위해서 가능하면

멤버 변수라도 직접 초기화를 해주는 것을 권장하는 편이다."

2. 멤버 변수의 초기화 방법

그런데 멤버 변수는 지역 변수와 다르게 초기화를 하는 방법이 여러가지 존재한다.

멤버 변수를 초기화하는 방법에는 3가지가 있는데

명시적 초기화

초기화 블럭을 이용한 초기화

생성자를 통한 초기화

로 3가지가 존재하는데

우리는 여기에서 명시적 초기화와

초기화 블럭을 이용한 초기화 방법에 대해서 자세히 알아볼 것이고

생성자를 통한 초기화 방법은 간단히 형태만 알아보고

다음 내용인 생성자에서 더 자세하게 다뤄보도록 하자.

먼저 명시적 초기화는 우리가 흔히 알고 있는 변수의 초기화 방법,

가장 기본적으로 알고 있는 초기화 방법이기도 하다.

변수를 선언하고 초기 값을 넣는 것을 명시적 초기화라고 한다.

예시 2)

class 볼펜심_설계도 {
    String 볼펜촉_모양 = new String();
    int 볼펜심_둘레 = 10;
}

예시 2) 와 같이 우리가 흔히 알고 있는 초기화 방법이 명시적 초기화인 것이다.

가장 직관적이고 기본적인 초기화 방법이지만

기본적인 만큼 단순하게 값을 넣는 것만 되는 방법이기 때문에

좀 더 복잡한 초기화 방법이 필요한 경우에는 적합하지 않다는 부분도 있다.

다음은 초기화 블럭을 이용한 초기화 방법이다.

초기화 블럭이라는 것이 다소 생소할 수도 있는데 먼저 예시로 만나보자.

예시 3)

class 볼펜심_설계도 {
    static int 볼펜심_길이;
    Color[] 잉크색;
    
    // 클래스 초기화 블럭
    static {
    	잉크색 = new Color[3];
        잉크색[0] = 검정색;
        잉크색[1] = 빨간색;
        잉크색[2] = 파란색;
        
        볼펜심_길이 = 40;
    }
    
    // 인스턴스 초기화 블럭
    {
    	볼펜심_길이 = 30;
    }
}

초기화 블럭은 { } (중괄호)를 만들고 그 안에 초기화 코드를 작성하면 된다.

초기화 블럭은 클래스 초기화 블럭과 인스턴스 초기화 블럭 2종류가 있다.

클래스 초기화 블럭은 이름대로 클래스 변수를 초기화하는 블럭이고 { } 앞에 static을 붙여주면 된다.

마찬가지로 인스턴스 초기화 블럭은 인스턴스 변수를 초기화하는 블럭이다.

클래스와 인스턴스의 개념과 동일하게

클래스 초기화 블럭은 클래스가 생성될 때 초기화 블럭이 실행이 되지만

인스턴스 초기화 블럭은 클래스의 인스턴스가 생성될 때 초기화 블럭이 실행된다.

클래스 초기화 블럭은 이름대로 클래스 멤버의 초기화만 가능하고 호출이 가능하다.

(초기화 블럭 안에서는 메소드도 호출할 수 있다.)

당연하게도 인스턴스 멤버의 초기화와 호출은 불가능하다.

반면 인스턴스 초기화 블럭의 경우에는 당연히 인스턴스 멤버의 초기화와 호출이 가능하고,

클래스 멤버의 초기화와 호출도 가능하다.

그런데 예시 3)에서 중요한 부분이 있다.

클래스 초기화 블럭과 인스턴스 초기화 블럭 안에 있는

볼펜심_길이의 경우 두 번의 초기화가 이루어지고 있다는 점이다.

초기화 블럭이 실행되는 시점을 생각해보면

기본적으로 볼펜심_길이는 40이라는 값을 가지고 있을 것이다.

그러나 볼펜심_설계도 클래스의 인스턴스가 생성되면

인스턴스 초기화 블럭이 실행되므로 볼펜심_길이의 값은 40에서 30으로 변경된다.

이렇게 클래스의 인스턴스가 생성됨에 따라서 변수의 값을 변경할 수도 있다.

하지만 반대로 클래스의 인스턴스가 생성되지 않는다면

인스턴스 초기화 블럭은 실행되지 않을테니 볼펜심_길이는 항상 40이라는 값을 가지고 있을 것이다.

이는 바로 뒤에서 설명할 초기화의 순서에서 자세하게 알아보도록 하자.

예시 4)

class 볼펜심_설계도 {
    static int 볼펜심_길이;
    
    static {
    	볼펜심_길이 = 40;
    }
    
    {
    	볼펜심_길이 = 20;
    }
    
    public static void main(String[] args) {
    	System.out.println(볼펜심_길이);
        볼펜심_설계도 설계도 = new 볼펜심_설계도();
        System.out.println(볼펜심_길이);
    }
}

이와 관련해 재미있는 예시를 하나 보자면

예시 4)와 같은 소스코드를 작성해 실행하면 콘솔에

으로 출력이 되는데

클래스의 인스턴스의 생성 시점에 따라서 변수의 값이 바뀌는 것을 확인할 수 있다.

그런데 일반적으로 인스턴스 초기화 블럭의 경우에는

그 역할과 동작이 생성자와 거의 동일하기 때문에 일반적인 초기화 방식으로는 사용되지 않고

공통으로 실행되는 코드의 중복을 방지하는 방식에서 주로 사용된다.

마지막으로 생성자를 이용한 초기화 방법이다.

클래스에 대해서 공부한다면 무조건 따라오는 것이 바로 생성자(Constructor)이다.

하지만 우리는 클래스에 대해서는 배웠지만

생성자라는 것에 대해서는 아직 공부하지 못했다.

그렇기 때문에 생성자가 무엇인지에 대해서 자세하게 알아보는 것은 다음 시간으로 아껴두고

지금은 간단하게 찍먹하는 정도로 설명하고자 한다.

예시 5)

class 볼펜심_설계도 {
	볼펜심_설계도() {}
}

예시 5)에서 클래스의 생성자를 보여주고 있는데

생성자는 클래스명과 동일하고 메소드와 비슷한 모습이지만 리턴타입이 없다.

생성자는 클래스의 인스턴스가 생성되어야만 실행이 되는 녀석이기 때문에

방금 앞에서 만났던 인스턴스 초기화 블럭과 동일한 기능을 한다.

그래서 인스턴스 초기화 블럭에 대해서 설명할 때

생성자와 거의 동일하기 때문에 일반적인 방식으로는 사용되지 않는다고 했던 것이다.

예시 6)

class 볼펜심_설계도 {
    static int 볼펜심_길이;
    Color[] 잉크색;
    
    볼펜심_설계도() {
    	볼펜심_길이 = 30;
        잉크색[0] = 검정색;
        잉크색[1] = 빨간색;
        잉크색[2] = 파란색;
    }
    
    볼펜심_설계도(int 길이) {
    	볼펜심_길이 = 길이;
    }
}

인스턴스 초기화 블럭의 예시를 수정해서

생성자로 멤버 변수의 초기화를 한 예시이다.

당연히 static이 붙은 클래스 변수와 인스턴스 변수 모두 초기화가 가능하다.

그리고 생성자는 하나의 메소드이므로 오버로딩이 가능해 여러 형태의 생성자를 만들 수 있고

매개변수로 값을 받아 초기화를 하는 것도 가능하다.

여기에서는 생성자에 대해 자세한 설명을 하지 않고 있기 때문에

설명을 들으면 조금 생소한 부분도 분명히 있을 것이다.

그렇다고 해도 지금은 그냥 그런거구나 하고 넘어가고

멤버 변수는 이런 식으로 초기화가 가능하고 이렇게 사용할 수 있구나라고만 이해해도

충분하다고 생각한다.

더 디테일한 설명들은 다음에 이어질 글에서 하나하나 등장할테니

너무 복잡하게 생각하지 않길 바란다.

3. 각 초기화 방법들의 실행 순서

지금까지 알아본 3가지의 초기화 방법과 관련해서

각 초기화 방법의 초기화 시기와 순서에 대해서 알아보자.

먼저 클래스가 처음 생성되는 시점에서 만들어지는 클래스 변수부터 살펴보자면

그림 1)

클래스 변수 초기화 순서

클래스 변수의 초기화 순서는 그림 1)과 같이 실행이 된다.

가장 첫 번째는

변수가 선언되고 생성되면서 해당 변수의 타입의 기본값으로 초기화가 되고

명시적 초기화를 했을 경우 명시적 초기화가 실행되고

마지막으로 클래스 초기화 블럭이 있다면

클래스 초기화 블럭의 내용으로 초기화가 실행된다.

여기에서 명시적 초기화가 있더라도 기본값으로의 초기화가 실행이 되는데

이는 클래스가 처음 생성되고

변수가 생성되는 시점에서 실행이 되기 때문에

명시적 초기화가 있다고 해서 바로 명시적 초기화로 실행이 되는 것이 아니라

일단은 기본값으로의 초기화가 실행이 된다는 점을 알고 있기를 바란다.

사실 자바의 내부 동작과 관련된 부분이라서

그렇게 자세하게 알 필요는 없지만 그래도 알고 있다고 해서 손해볼 건 없으니까?

예시 7)

class 볼펜심_설계도 {
    
//  static int 잉크양;		// 1. 변수가 선언되면 해당 타입의 기본값으로 자동 초기화
    static int 잉크양 = 100;	// 2. 명시적 초기화가 있다면 해당 값으로 초기화
    
    // 3. 이후 클래스 초기화 블럭이 있다면 초기화 블럭의 내용으로 초기화 
    static {
    	잉크양 = 200;
    }
    
    public static void main(String[] args) {
    	System.out.println(볼펜심_설계도.잉크양);
    }
}

예시 7)과 같이 소스코드를 작성해서 실행하면

콘솔에 200이라는 값이 출력된다.

여기에서 클래스 초기화 블럭이 없다면 결과는 100으로 출력될 것이다.

다음은 클래스의 인스턴스가 생성되는 시점에서 실행되는

인스턴스 변수의 초기화 순서이다.

그림 2)

인스턴스 변수 초기화 순서

인스턴스 변수 초기화는 클래스 변수 초기화와 동일하게

기본값으로 초기화, 명시적 초기화 후에 초기화 블럭을 통한 초기화가 실행된다.

그리고 클래스 변수 초기화에서는 없었던 생성자에 의한 초기화가 추가되었다.

다시 말해, 생성자는 클래스의 인스턴스가 생성되어야 동작하는 것이다.

예시 8)

class 볼펜심_설계도 {
    static int 잉크양 = 200;	// 1. 클래스 변수의 명시적 초기화
//  int 볼펜심_길이;		// 1. 기본값 초기화
    int 볼펜심_길이 = 40;	// 2. 명시적 초기화
    
    // 3. 인스턴스 초기화 블럭으로 초기화
    {
    	잉크양 = 300;
    	볼펜심_길이 = 60;
    }
    
    // 4-1. 생성자로 초기화
    볼펜심_설계도() {
    	볼펜심_길이 = 10;
    }
    
    // 4-2. 매개변수가 있는 생성자로 초기화
    볼펜심_설계도(int ink) {
    	잉크양 = ink;
    }
    
    public static void main(String[] args) {
    	System.out.println("2 잉크양 : " + 볼펜심_설계도.잉크양);
        
        // 매개변수가 없는 생성자로 인스턴스를 생성
        볼펜심_설계도 설계도_인스턴스1 = new 볼펜심_설계도();
        System.out.println("3 잉크양 : " + 볼펜심_설계도.잉크양);
        System.out.println("4-1 볼펜심_길이 : " + 설계도_인스턴스1.볼펜심_길이);
        
        // 매개변수가 있는 생성자로 인스턴스를 생성
        볼펜심_설계도 설계도_인스턴스2 = new 볼펜심_설계도(100);
        System.out.println("4-2 볼펜심_길이 : " + 설계도_인스턴스2.볼펜심_길이);
    }
}

// 클래스의 인스턴스가 생성되기 전
2 잉크양 : 200

// 클래스의 인스턴스가 생성된 후
3 잉크양 : 300
4-1 볼펜심_길이 : 10

// 매개변수를 가지고 인스턴스가 생성된 후
4-2 볼펜심_길이 : 100

예시 8)의 내용이 조금 길어서 이해가 잘 되지 않을 수도 있을텐데

위와 같이 소스코드를 작성하면 아래의 결과가 출력되는 것을 확인할 수 있다.

클래스 변수 초기화의 경우에는 클래스가 생성되는 시점에서 실행되기 때문에

순서대로 진행되더라도 마지막에 초기화한 값으로 출력이 되지만

인스턴스 변수 초기화의 경우에는 클래스의 인스턴스 생성 유무 순서에 따라서

다른 값을 출력하는 경우도 발생할 수 있으니 이 부분을 잊어선 안되겠다.

마찬가지로 생성자에 따라서도 달라질 수 있다는 점도 알고 있기를 바란다.

4. 마무리

클래스의 멤버에는

멤버 변수와 멤버 메소드가 있는데 그 중 멤버 변수의 초기화 방법에 대해서 알아봤다.

변수는 선언을 하고 초기화를 해줘야 하는데

변수의 초기화에서는 변수가 지역 변수냐, 전역 변수냐에 따라서

초기화를 해줘야 하고 해주지 않아도 되는 경우가 있다.

멤버 변수의 경우에는 선언과 동시에 초기화를 하지 않아도

해당 변수의 타입에 맞는 기본값으로 자동으로 초기화가 된다.

이렇듯 선언과 동시에 초기화를 하지 않아도 되기 때문에

멤버 변수를 초기화하는 방법이 다양하게 존재한다.

멤버 변수의 초기화 방법에는 3가지가 있는데

명시적 초기화

초기화 블럭을 이용한 초기화

생성자를 통한 초기화

가 그것이다.

명시적 초기화는 우리가 흔히 알고 있는 변수의 초기화 방법으로

int a = 10; 처럼 변수에 직접 값을 넣는 방법이다.

직접적이면서도 간단한 방법이기 때문에 가장 기본적인 초기화 방법이지만

복잡한 방식의 초기화가 불가능하다는 부분이 있다.

이렇게 가려운 부분을 긁어줄 수 있는 것이 바로 초기화 블럭과 생성자가 되겠다.

초기화 블럭은 클래스 안에서 { } (중괄호)를 만들어 그 안에 초기화 내용을 작성한다.

초기화 블럭은 클래스 초기화 블럭과 인스턴스 초기화 블럭으로 나뉘는데

인스턴스 초기화 블럭은 { }를 그대로 사용하지만

클래스 초기화 블럭은 { } 앞에 static을 붙여준다.

클래스 초기화 블럭은 인스턴스 생성여부와 상관없이

클래스가 생성되는 시점에서 함께 실행이 된다.

그렇기 때문에 멤버 변수 중에서 static이 붙은 변수의 초기화만 가능하다.

반대로 인스턴스 초기화 블럭은 이름대로 클래스의 인스턴스가 생성되는 시점에서 실행되며

변수의 static 유무와 상관없이 모든 멤버 변수의 초기화가 가능하다.

생성자는

클래스명과 동일한 리턴타입이 없는 메소드의 형태를 하고 있는데

인스턴스 초기화 블럭과 마찬가지로 클래스의 인스턴스가 생성되는 시점에 실행이 된다.

역시 모든 멤버 변수의 초기화가 가능하고

생성자는 메소드이기 때문에 매개변수를 받을 수도 있는데

인스턴스 생성 시 전달받은 매개변수로 멤버 변수를 초기화할 수도 있다.

마지막으로 각 초기화 방법이 실행되는 순서는

클래스 변수 초기화의 경우

1. 기본값으로 초기화 -> 2. 명시적 초기화 -> 3. 클래스 초기화 블럭

의 순서로 실행이 된다.

여기에서 명시적 초기화의 경우에는 명시적 초기화를 하더라도

일단 변수가 생성되는 시점에서 기본값으로 초기화가 되고

이후 명시적 초기화의 유무에 따라서 해당 값으로 초기화가 된다.

인스턴스 변수 초기화의 경우

1. 기본값으로 초기화 -> 2. 명시적 초기화 -> 3. 인스턴스 초기화 블럭 -> 4. 생성자

의 순서로 실행이 된다.

그리고 클래스 변수 초기화는 클래스가 처음 생성되는 시점에서 실행이 되기 때문에

최초 한 번 실행이 되지만

인스턴스 변수 초기화는 클래스의 인스턴스가 생성될 때 마다 실행이 된다는 것을 잊지 말아야 한다.

여기까지 클래스의 멤버 중 멤버 변수에 대해서 알아보고

멤버 변수를 초기화하는 방법까지 알아봤으니

클래스의 멤버 중 다른 녀석인 멤버 메소드와 생성자에 대해서 알아보기 위해

메소드가 무엇인지에 대해서 간단히 살펴보도록 하자.

[자바 프로그래밍 기초] 7. 난수를 뽑아주는 Random 클래스

거신 — Tue, 31 Jan 2023 02:44:58 +0900

지난번에 자바에서 난수를 뽑아내는 방법으로 Math.random()이라는 메소드에 대해서 알아봤었다.

[자바 프로그래밍 기초] 6. 난수를 뽑아주는 Math.random()

이번 시간에는 자바에서 난수를 만들어야 할 때 유용하게 사용할 수 있는 Math.random()에 대해서 살펴보도록 하자. 1. 난수 난수(亂數)란 정의된 범위 내에서 무작위로 추출된 수를 일컫는다. 난수

colossus-java-practice.tistory.com

그리고 이번에는 자바에서 난수를 뽑아내는 다른 방법인

Random 클래스를 이용한 방법에 대해서 알아보도록 하자.

1. Random 클래스

그렇다면 일단 Random 클래스에 대해서 먼저 알아보자.

Random 클래스는 클래스의 이름 그대로 난수와 관련된 메소드들로 구성되어 있는 클래스이다.

(자바 레퍼런스 문서나 JDK 내에서 확인해보면 알겠지만

Random 클래스에는 필드가 없고 생성자와 메소드만 있다.)

Math.random()은 단순히 double 타입의 난수를 뽑아주는 것만 가능하지만

Random 클래스는 난수와 관련된 메소드들이 포함되어 있기 때문에

다양한 조건의 난수를 뽑아내는 것이 가능하다.

그리고 Math.random()을 뜯어보면 Random 클래스를 이용해 만들어진 녀석이다.

(오??)

거두절미하고 일단 앞서 Math.random()을 이용해서 난수를 뽑아낸 것과 동일하게

Random 클래스를 이용해 난수를 뽑아보자.

예시 1)

double randNum = Math.random(); // 0.xxxxx.....

int num_1 = (int) (randNum * 5);     // 0 ~ 4 사이의 숫자를 뽑아냄
int num_2 = (int) (randNum * 5) + 1; // 1 ~ 5 사이의 숫자를 뽑아냄

// 여기까지가 Math.random()을 이용해 난수를 뽑아내는 방법

// 여기부터가 Random 클래스를 이용해 난수를 뽑아내는 방법
Random random = new Random();

random.nextDouble();		// Math.random()과 동일한 결과 형태 출력

int num_1 = random.nextInt(5);			// (int) (randNum * 5) 와 동일한 결과 형태 출력
int num_2 = random.nextInt(5) + 1;		// (int) (randNum * 5) + 1 와 동일한 결과 형태 출력

비교를 위해서 앞의 내용이었던 Math.random()의 내용과 함께 작성해 보았다.

주석의 내용에서 알 수 있듯이 Random 클래스를 이용해 동일한 결과 형태를 출력하는

소스로 작성해 보았다.

우선 Random 클래스를 사용하기 위해선

Random 클래스의 인스턴스를 먼저 생성해줘야 한다.

Math.random()과는 다르게 각각의 메소드들이 static이 아니기 때문에

예시 1)과 같이 인스턴스로 생성해서 사용해야 한다는 것을 먼저 잊지 말자.

(심심풀이로 Random 클래스 내부를 살펴보면 도움이 될 것이다.

~~귀찮으면 어쩔 수 없고~~)

그리고 Random 클래스도 Math.random()과 같이 그냥 사용할 수는 없고

역시 소스파일 내에서 java.util.Random을 import 해야 한다는 것도 함께 알고 있자.

예시 1)을 이용해 하나씩 살펴보면

Math.random()과 동일한 형태의 결과를 출력해 주는 random.nextDouble()은

Math.random()과 똑같이 double형의 임의의 숫자를 리턴하고,

리턴하는 숫자의 범위 또한 0.0 이상 1.0 미만이 되겠다.

실제로 Java docs 등의 문서에서 Math.random()을 찾아보면

참고 항목으로 Random.nextDouble() (<- 사실 이 표현 잘못된 표현이다.)

을 표시하고 있고 반대로 Random 클래스에서 nextDouble()을 찾아보면

참고 항목으로 Math.random()을 표시하고 있다.

그리고 잠깐 지나가는 내용이었지만 좀 자세히 봤던 사람들이라면

이 부분이 기억이 날 것이다.

예시 2)

public static double random() {
     return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

예시 2)는 Math.random()의 메소드 구현부인데 호출한 메소드가 nextDouble()이다.

여기에서의 nextDouble()이 예시 1)에서 봤던 random.nextDouble()과 동일한 메소드이다.

(JDK 안에서 찾아가 보면 똑같은 곳에 당도할 수 있을 것이다.)

그리고 등장한 메소드가 바로 random.nextInt()이다.

2. Random 클래스의 메소드

우리가 Math.random()을 이용했을 때 뽑아낸 난수를 정수형태로 변환하기 위해서

일련의 복잡한 계산식을 이용하고 강제 캐스팅까지 해야 했던 것을

한 번에 해주는 메소드가 바로 random.nextInt()이다.

random.nextDouble()과 같이 random.nextInt()는 메소드명 그대로 int형의 임의의 숫자를 뽑아낸다.

그런데 여기서 주의할 점은

random.nextInt()가 리턴하는 숫자의 범위이다.

random.nextInt()는 다른 메소드와는 다르게 int 타입의 범위 전체를 대상으로

임의의 정수를 리턴한다는 점이다.

다시 말해, random.nextInt()의 숫자의 범위는

–2,147,483,648 ~ 2,147,483,647

인 것이다.

정말 어마어마한 범위 내에서 임의의 숫자를 뽑아주는데

현재의 우리에겐 이 정도의 숫자는 필요하지 않는다는 걸 다들 알고 있을 것이다.

그래서 Random 클래스에서는 이렇게 무지막지한 숫자가 아닌

도가 지나치지 않는 정도의 숫자를 뽑아낼 수 있도록 다른 메소드를 제공하고 있다.

random.nextInt()에서 매개변수를 추가하여 오버로딩된 메소드인

random.nextInt(int bound)을 제공하고 있다.

여기에서 매개변수 bound는 난수의 범위를 지정하는 변수가 되겠다.

즉, 0에서 bound - 1까지의 범위를 지정할 수 있는 것이다.

Math.random()에서 우리가 뽑아낸 난수에 *(곱하기)를 하는 것과 동일한 기능이다.

생성한 임의의 수에 곱하는 수는 뽑아낼 숫자의 개수라고 했는데

여기에서는 bound가 이 역할을 하고 있는 것이다.

뒤에 더하기는 Math.random()에서와 동일하게

뽑아낼 숫자의 범위에서 시작하는 숫자를 말하는 것이다.

이렇듯 Random 클래스에서는 생각보다 다양하게 난수를 뽑아내는

메소드들을 제공하고 있다.

물론 위의 예시들이 Math.random()같이

Random 클래스의 메소드들을 활용해 동일한 기능처럼 작성한 것이기 때문에

그게 그거 같아 보일 수도 있겠지만

분명한 것은 Math.random()보다 Random 클래스가 활용도가 더 높다는 점이다.

아직은 크게 잘 느껴지지 않을 수도 있는데

일단 더 심오하게 알아보기 전에 활용도가 조금은 느껴지도록

Random 클래스의 주요 메소드들을 살펴보도록 하자.

표 1)

리턴타입	메소드	설명	리턴 숫자의 범위
int	nextInt()	int 타입 난수 리턴	–2,147,483,648 ~ 2,147,483,647
int	nextInt(int bound)	0 ~ bound - 1 사이의 난수 리턴	0 ~ (bound - 1)
long	nextLong()	long 타입 난수 리턴	-9223372036854775808 ~ 9223372036854775807
float	nextFloat()	float 타입 난수 리턴	0.0F ~ 0.999.....F
double	nextDouble()	double 타입 난수 리턴	0.0D ~ 0.999......D
double	nextGaussian()	표준정규분포형으로 난수 리턴	표준정규분포 (평균이 0이고, 표준편차가 1인 범위)
boolean	nextBoolean()	true 또는 false를 랜덤으로 리턴	true / false
void	nextBytes(byte[] bytes)	byte 배열에 난수의 byte로 채움
void	setSeed()	시드 지정

표 1)에서도 확인할 수 있듯이

다양한 타입의 난수를 리턴하는 메소드들을 제공하고 있다.

그렇기 때문에 따로 계산을 한다든가, 캐스팅 등의 변환을 하지 않고

Random 클래스의 인스턴스를 이용해

다양한 타입의 난수를 만들어 낼 수 있다.

거기에 true 또는 false까지 랜덤으로 뽑아낼 수 있도록

boolean 타입의 메소드까지 제공하고 있으니 이 얼마나 활용도가 높지 않을 수 있겠는가!

심지어 표준정규분포형의 난수까지 제공해주고 있다.

~~(사실 저게 얼마나, 어디에 활용될지는 모르겠지만....)~~

아무튼 위와 같이 다양한 메소드들을 제공하고 있고

우리들은 필요에 맞게 메소드들을 활용만 하면 되는 것이다.

물론 이렇게 다양한 메소드들을 제공한다고 해서

무조건 Random 클래스가 좋다는 의미는 아니다.

필요에 따라선 간단하게 난수를 뽑아낼 때는 인스턴스 생성 없이

바로 Math.random()을 호출해서 난수를 뽑아내는 것도 좋은 방법이다.

그런데 이렇게만 보면 Random 클래스든 Math.random()이든 별 차이가 없어 보이지만

위의 표에 얼굴을 잠깐 비춘 녀석 때문에

Random 클래스와 Math.random()의 차이가 나타나고

Random 클래스의 활용도를 나타낼 수 있다고 볼 수 있겠다.

그것이 바로

setSeed()

라는 메소드이다.

[자바 프로그래밍 기초] 6. 난수를 뽑아주는 Math.random()

거신 — Fri, 6 Jan 2023 09:41:03 +0900

이번 시간에는 자바에서 난수를 만들어야 할 때 유용하게 사용할 수 있는

Math.random()에 대해서 살펴보도록 하자.

1. 난수

난수(亂數)란 정의된 범위 내에서 무작위로 추출된 수를 일컫는다.

난수는 누구라도 그 다음에 나올 값을 확신할 수 없어야 한다.

-출처 : 위키백과-

난수의 의미를 찾아보면 이렇게 설명하고 있는데

한마디로 랜덤한 숫자란 뜻이다.

우리가 가끔씩 프로그램을 개발할 때 난수가 필요한 경우가 있다.

대표적으로 로또번호 생성기나 추첨기, 암호키 생성 등과 같이

우리가 전혀 추측할 수 없는 숫자나 값을 뽑아내야 할 때가 바로 그 경우인데

이런 걸 구현할 수 있도록 자바에서는 Math.random()라는 메소드를 제공하고 있다.

그리고 Random클래스라는 랜덤객체를 생성할 수 있는 클래스도 제공하는데

지금 알아보려는 Math.random()와는 비슷하면서도 다르기 때문에

바로 Math.random()에 대해서 먼저 알아보고 이어서 알아보도록 하자.

(사실 Math.random()은 Random클래스를 이용한다.)

다시 본론으로 돌아와 난수의 뜻이 뭔지는 알겠으니

이제 그 난수인지 뭔지 하는 걸 한 번 뽑아보자.

2. Math.random()

자바에서 난수를 뽑아내는데 가장 간단한 방법이

Math.random()라는 메소드를 사용하는 것이다.

아래의 코드를 살펴보자.

예시 1)

public class RandomNumberTest {
	public static void main(String[] args) {
    	
        double randNum = Math.random();	// 0.xxxxxx.....
        System.out.println(randNum);
        
    }
}

예시 1)이 Math.random()를 사용하는 방법이 되겠다.

Math.random()는 double형의 임의의 숫자를 리턴하는데

숫자의 범위는 0.0 ~ 0.99999.....가 되겠다.

다시 말해, 0.0이상 1.0 미만의 임의의 숫자를 리턴하는 것이다.

(간혹 인터넷에서 Math.random()에 대해서 검색하다 보면

출력되는 수의 범위가 0.0에서 1.0까지라고 설명하는 글들이 있는데

정확히는 1.0 미만이기 때문에 1은 절대로 나올 수 없다.)

예시 2)

public static double random() {
     return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

Math 클래스에서 random()를 찾아보면

예시 2)와 같은 내용을 확인할 수 있을 것이다.

해당 내용이 중요한 것은 아니고 메소드가 어떻게 되어 있는지 참고용으로 넣어봤다.

예시 2)에서 알 수 있듯이 Math.random()는 static 메소드이므로

인스턴스를 생성하지 않고 Math.random()의 형태로 클래스명으로 바로 호출할 수 있다.

물론 이클립스 같은 IDE에서 작성하면 자동으로 추가되겠지만

일단은 소스파일 내에서 java.lang.Math를 import 해야 한다는 건 기본으로 알고 있자.

그런데 이렇게만 놓고 봐서는 막상 써먹으려면 어찌해야 하나 싶다.

리턴을 0.0에서 0.999999.... 이 사이의 수를 하나 뽑아낸다고 하는데

아무리 봐도 이 숫자를 그대로 사용하기엔 난감하다.

그래서 조금 다듬어서 어딘가에 활용하기에 좋은 형태로 만들어 보겠다.

예시 3)

double randNum = Math.random(); // 0.xxxxx.....

int num_1 = (int) (randNum * 5);     // 0 ~ 4 사이의 숫자를 뽑아냄
int num_2 = (int) (randNum * 5) + 1; // 1 ~ 5 사이의 숫자를 뽑아냄

Math.random()로 뽑아낸 임의의 숫자를

0 ~ 4 사이의 수로 변환하는 방법과

1 ~ 5 사이의 수로 변환하는 방법이다.

예시 3)의 방법을 잘 보면 대충 감을 잡았을 것이라 생각하는데

생성한 임의의 수에 곱하는 수는 뽑아낼 숫자의 개수를 말하는 것이고

뒤에 더하는 숫자는 뽑아낼 숫자의 범위에서 시작하는 숫자라고 눈치챘을 것이다.

Math.random()는 최솟값이 0.0이므로 시작하는 숫자는 0일 것이고

곱하는 수는 뽑아낼 숫자의 개수라고 했으니

5를 곱하면 0부터 5개의 숫자

즉, 0 ~ 4 사이에서 임의의 숫자를 뽑아내는 것이다.

그리고 뒤에 더하는 숫자는 뽑아낼 숫자의 범위에서 시작하는 숫자라고 했으니

1을 더하면 1부터 시작하니 숫자의 범위는 1 ~ 5가 되는 것이다.

만약 -3을 더하게 되면 숫자의 범위는 -3 ~ 1이 된다.

그리고 뽑아낸 숫자를 int 타입으로 강제 캐스팅을 하는데

앞에서도 설명했듯이 Math.random()의 리턴타입은 double이다.

그렇기 때문에 우리는 쓸데없는 소수점을 없애고 정수로만 사용하기 위해

int 타입으로 강제 캐스팅을 한 것이다.

물론 int 뿐만 아니라 long, float, short과 같이 숫자로 사용할 수 있는 타입으로 캐스팅도 가능하다.

예시 4)

int lottoNumber = (int) (Math.random() * 45) + 1;

흔한 로또번호 생성기 코드이다.

위의 공식만 기억한다면 난수 생성하는 건 별로 어렵지 않다.

3. 정리

이번 시간에는 자바에서 난수를 뽑아내는 방법 중 하나인

Math.random()를 사용하는 방법과 간단한 예시를 알아봤다.

Math.random()은 자바에서 난수를 뽑아내는데 가장 간단한 방법이고

static 메소드이기 때문에 클래스명인 Math를 앞에 붙이고

인스턴스 생성 없이 Math.random()의 형태로 바로 호출할 수 있다.

(소스파일 내에서 java.lang.Math가 import 되어 있어야 정상작동 한다.)

Math.random()은 double 타입의 값을 리턴하는데

리턴하는 값의 범위는 0.0 ~ 0.9999.... 까지이다.

이를 좀 더 효과적으로 사용하기 위해 가공을 하는 방법으로는

Math.random()으로 뽑은 수에 뽑아내려는 숫자의 개수를 곱하고

해당 수의 범위에서 시작하는 숫자를 더해주면 된다.

그리고 필요에 따라서 숫자로 사용할 수 있는 타입,

int, float, long, short 등의 타입으로 강제 캐스팅을 해서

좀 더 효과적으로 사용할 수도 있겠다.

Math.random()에 대해서 알아봤으니

다음에는 Random 클래스를 이용해 난수를 뽑아보도록 하겠다.

[자바 프로그래밍 기본] 2. 클래스의 구성 (1) 멤버

거신 — Thu, 5 Jan 2023 21:39:30 +0900

지난 시간에는 클래스(Class)가 무엇인지에 대해서 알아봤고

간단하게 클래스를 생성하는 방법에 대해서 알아봤었다.

그런데 클래스를 생성한다고 해도 클래스는 무엇으로 구성되어 있으며,

무엇을 어떻게 넣어야 하는지 알아야

만들어서 써먹든지 말든지 할 수 있을 것이다.

스티브 잡스가 무대에 나와서 "iPhone"이라고 했을 때

관객들은 환호하겠지만

잡스가 거기에서

아이폰이 정작 무엇인지, 뭘 할 수 있는지, 무슨 기능이 들어있는지 설명하지 않고 발표를 끝냈다면

환호하던 관객들은 순식간에 대략 정신이 멍해졌을 것이다.

그러니 주인장도 이 글을 읽는 여러분들의 정신이 멍해지지 않도록

클래스가 무엇인지에서 끝내지 않고

클래스 안에는 무엇이 들어있으며,

어떤 걸 할 수 있으며,

어떻게 만드는지

에 대해서 알려주려고 한다.

그래서 이번 시간에는 클래스 안에는 어떤 것들이 있는지

그리고 어떤 역할을 하는지에 대해서 알아보고자 한다.

이들을 클래스의 멤버라고 지칭할 텐데

클래스의 멤버를 이해하고 나면 클래스를 생성하는 것부터 시작해

어떻게 이용할 것인가에 대한 전반적인 이미지가 그려질 것이라고 생각한다.

목표 : 클래스의 멤버에 대해서 이해하고

전역 변수, 지역 변수, 클래스 멤버, 인스턴스 멤버가 무엇인지 이해할 수 있다.

1. 클래스의 구성

그렇다면 클래스가 무엇으로 구성되어 있는지부터 살펴보자.

앞서 만들어놨던 볼펜심 설계도를 가져오겠다.

예시 1)

class 볼펜심_설계도 {
    int 볼펜심_길이;
    String 볼펜심_형태;
    int 볼펜심_둘레;
    String 볼펜촉_모양;
    Color 잉크색;
    int 잉크양;

    public void 잉크를_뽑아냄() {
        
    }
}

여기에서 우리는 볼펜심_길이, 볼펜심_형태, 잉크양 등이

변수(Variable)라는 것도 이미 알고 있고

잉크를_뽑아냄()은

메소드(Method, 함수)라는 것도 이미 알고 있을 것이다.

이 두 개가 바로 클래스를 구성하고 있는 요소가 되겠다.

이렇듯 클래스 내부에 필요한 변수와 메소드를 넣어두고

클래스를 인스턴스로 생성할 때 필요한 변수를 불러와서 값을 이용하거나

메소드를 호출해 해당 기능을 사용할 수 있는 것이다.

위와 같이 변수와 메소드들을 클래스의 멤버(Member)라고 지칭하며,

여기에서 변수와 상수를 하나로 묶어 멤버 필드(Member Field)라고 하며

그중 변수를 멤버 변수(Member Variable)라고 하고

메소드를 멤버 메소드(Member Method)라고 한다.

그림을 이용해서 좀 더 직관적으로 표현하자면 아래와 같이 표현할 수 있겠다.

그림 1)

우리가 객체지향, 클래스, 객체에 대해서 알아보면서 클래스가 어떤 역할을 했는지 앞에서 알아봤었는데

좀 더 압축해서 한 문장으로 설명한다면

설계도 역할을 하는 클래스는 자바 프로그램의 기본 단위라고 할 수 있겠다.

이렇듯 클래스라는 틀 안에서 코드가 생성되고 프로그램이 동작하는 것이기 때문에

자바를 처음 배울 때 만났던 변수와 메소드 등이 전부 클래스 안에 있어야 한다는 걸 어느 정도 눈치챘을 것이다.

변수든 메소드든 절대 클래스 밖에선 존재할 수 없는 것들이다.

2. 변수의 유효 범위(Variable Scope)

우리는 이전까지 변수라는 녀석에 대해서 단순히 하나의 값을 저장하는 것으로만 알고 있었는데

클래스에 대해서 알아가고 있기 때문에

여기에서는 변수를 이용할 수 있는 유효 범위(Variable Scope)에 대해서 알아보려고 한다.

변수는 어디에 선언되느냐에 따라서 유효 범위가 달라지게 된다.

여기에서 유효 범위란 선언된 그 변수를 호출해서 사용할 수 있는 범위를 말하는 것이다.

즉, 선언된 위치가 클래스 안에 멤버 변수로 선언되느냐,

아니면 메소드 안에서 변수로 선언되느냐에 따라서 어디에서는 호출할 수 있고

어디에서는 호출할 수 없는 것이다.

범위를 생각해보면 당연히 메소드는 클래스 안에 포함되어 있을 테니

클래스가 메소드보다 범위가 더 넓을 것이고

변수도 멤버 변수가 호출할 수 있는 범위가 더 넓을 것이라고 예상할 수 있을 것이다.

반대로 메소드 안에 선언된 변수는 사용할 수 있는 범위가 극히 좁을 것이다.

여기에서 클래스에서 선언된 멤버 변수를 전역 변수라고 표현한다.

그리고 메소드 안에서 선언된 변수를 지역 변수라고 표현한다.

단어 그대로 클래스 내부 전역에서 사용할 수 있기 때문에 전역변수,

메소드라는 국한된 지역 내에서만 사용할 수 있기 때문에 지역변수인 것이다.

그림 2)

그림에서도 알 수 있듯이 전역 변수의 경우에는 선언된 클래스 안에서라면

어디에서든 호출하고 사용할 수 있지만

지역 변수의 경우에는 선언된 메소드 안에서만 사용이 가능하고

메소드의 범위를 벗어나면 사용할 수 없다.

이렇듯 변수를 선언할 때 사용할 수 있는 유효 범위가 있으니

어디에 어떻게 선언할 것인가에 대한 부분을 생각하면서 프로그램을 작성해야 한다.

그런데 전역 변수는 변수가 생성되는 시점에 따라 두 가지로 나눌 수 있다.

그것이 바로 클래스 변수와 인스턴스 변수인데

이 둘은 자바 프로그램이 실행될 때 생성이 되는 시점도 다르고

올라가는 메모리의 위치도 다르다.

3. 클래스 멤버와 인스턴스 멤버

여기에서 우리는 static이라는 녀석을 만나게 된다.

static, 말 그대로 정적인 무언가를 지칭하는 자바의 예약어이다.

static은 변수에만 붙을 수 있는 것이 아니라 메소드에도 붙을 수가 있는데

이를 클래스 변수, 클래스 메소드라고 하고 합쳐서 클래스 멤버라고 표현한다.

혹여나 하는 말이지만 앞의 내용과 혼동하면 안 되는데

앞에서는 클래스"의" 멤버를 알아본 것이고 "클래스 멤버"에 대해서 설명한 것이 아니다.

그렇기 때문에 단순히 클래스 안에 선언된 변수와 메소드 전부가

클래스 멤버라고 오해하면 안 된다.

이 들은 단순히 "멤버"인 것이지 "클래스 멤버"가 아니다.

정확하게 구분해서 이해할 필요가 있다.

(분명히 헷갈릴 가능성이 높기 때문에 가능하면 제대로 구분해서 이해하고 있길 바란다.)

다시 돌아와서 클래스 멤버는 멤버 필드나 멤버 메소드를 선언할 때

앞에 "static"을 붙여주면 된다.

이는 우리가 가장 많이 만나는 main 메소드에서 잘 나타나는데

main 메소드 안에 클래스 변수 값을 출력하는 코드를 간단하게 작성해 보았다.

예시 2)

public class Test {
    static String testText = "Hello World!";
   
    public static void main(String[] args) {
    	System.out.println(testText);
    }
}

예시 2)와 같이 선언하려는 변수 또는 메소드 앞에 static을 붙여주면

그 멤버는 클래스 멤버가 되는 것이다.

자바 프로그램의 시작점인 main 메소드가 바로 대표적인

클래스 메소드, 정적 메소드, static 메소드이다.

(전부 똑같은 말이다.)

앞에서도 잠깐 언급을 했지만 여기에 static이 붙으면서

인스턴스 변수와는 다르게 프로그램이 실행되면서 메모리에 올라가는 시점이 달라진다고 했었다.

이 블로그의 프로그래밍 기본 지식의 변수 챕터에서

참조형 변수를 다루면서 잠시 메모리 구조에 대해서 알아본 적이 있는데

그 그림에서 표현되지 않은 Static영역(클래스 영역, 메소드 영역)이라는 곳이 존재하는데

바로 클래스 멤버가 프로그램이 실행될 때 올라가는 위치인 것이다.

즉, 프로그램이 실행되고 종료되기 전까지 계속해서 남아있는 멤버인 것이다.

그림 3)

Stack위에 공간 있어요!!!!!!!

(그림이 그렇다는 거지 실제 메모리 구조가 이러한 형태로 되어 있는 게 아니다.)

반대로 인스턴스 변수, 인스턴스 멤버는 Static영역이 아닌 Stack영역, Heap영역에 위치하고

이는 인스턴스로 생성이 되거나 호출이 되면 그제서야 만들어지는 멤버라는 뜻이기도 하다.

이러한 특징 때문에 클래스 멤버와 인스턴스 멤버를 혼용해서 코드를 작성할 때 제약조건이 생기게 된다.

예시 3)

public class Test {
    String testText = "Hello World!";
   
    public static void main(String[] args) {
    	System.out.println(testText);
    }
}

위의 코드는 멤버 변수인 testText에서 static을 지운 것뿐인데

해당 코드는 에러를 뿜뿜하게 된다.

생각해보면 정말 간단한 이유 때문이다.

main 메소드는 static으로 만들어진 클래스 메소드, 정적 메소드이다.

즉, 프로그램이 실행되면 Static영역에 위치하는 메소드인 것이다.

그런데 main 메소드의 내부를 잘 살펴보니 어라?

testText라는 인스턴스 변수가 위치하고 있다.

인스턴스 변수, 인스턴스 멤버는 인스턴스가 생성되어야 생성이 된다고 했으니

프로그램이 실행되고 Static영역에 위치하는 시점에서는 testText가 생성조차 되지 않은 상태인 셈이다.

그러니 만들어지지도 않은 녀석을 메모리에 위치시키려고 하니 여기에서 에러가 발생하는 것이다.

그래서 코드를 작성하는 컴파일러 단계에서

이거 백퍼 프로그램 실행하면 에러 나니까 testText를 지우든지, 아님 static으로 선언하든지 해라라고

알려주는 것이다.

이렇게 해당 멤버의 생성 시점에 따라서 오류가 발생할 수도 있으니 꼭 이해해주길 바란다.

예시 4)

public class Test {
    static String testText = "Hello World!";
    int testNumber = 10;
   
   // 인스턴스 메소드의 경우에는 내부에 클래스 변수든 인스턴스 변수든 뭘 써도 상관없다.
    public void start() {
    	System.out.println(testText);
        System.out.println(testNumber);
    }
}

반대로 이를 제외한 경우에는 문제가 없다는 것도 알아만 보고 넘어가자.

여기까지 이해했다면 예시 4)에 왜 문제가 없는지 잘 알 것이라고 믿어 의심치 않는다.

4. 정리

앞서 클래스와 객체에 대해서 알아봤으니 이제 클래스를 직접 만들어보기 위해서

우선 클래스가 어떻게 구성되어 있는지에 대해서 살펴봤다.

클래스는 자바 프로그래밍의 기본 단위이기도 한데

우리가 알고 있던 변수와 메소드들은 모두 클래스에 포함되어 있는 요소인 셈이다.

이들을 우리는 클래스의 멤버라고 표현하는데

클래스 안에 선언된 변수와 상수를 통틀어 멤버 필드라고 하며,

특히 변수는 멤버 변수라고 지칭한다.

메소드는 멤버 메소드라고 하며 이들 멤버는 절대 클래스 밖에선 존재할 수 없다.

멤버 필드, 멤버 변수의 경우에는 클래스 내부에서 이용될 수 있는

유효 범위가 존재하는데 어디에서 선언되느냐에 따라서 범위가 달라지게 된다.

클래스 상에 선언된 변수는 선언된 클래스 내부 어디에서나 접근이 가능하고

사용이 가능한데 이를 전역 변수라고 한다.

그리고 클래스 내부의 멤버 메소드 내부에서 선언된 변수는

해당 멤버 메소드 내에서만 접근과 사용이 가능하고 멤버 메소드 외에서는 사용할 수 없다.

그리고 이 변수를 지역 변수라고 한다.

그리고 전역 변수와 멤버 메소드는

생성되는 시점에 따라서 각각 클래스 멤버, 인스턴스 멤버로 구분할 수 있는데

변수나 메소드를 선언할 때 앞에 static을 붙여 선언하면 클래스 멤버(정적 멤버, Static 멤버)로 생성할 수 있다.

클래스 멤버는 프로그램이 실행될 때 메모리의 Static 영역에 올라가서 생성되고

프로그램이 종료되기 전까지 계속 남아있게 되고

인스턴스 멤버는 인스턴스가 생성되거나 호출되는 시점에서 생성되기 때문에

메모리의 Stack 영역이나 Heap 영역에서 생성된다.

마지막으로 클래스 멤버와 인스턴스 멤버는 생성되는 시점이 다르기 때문에

클래스 변수를 인스턴스 변수 또는 인스턴스 메소드에 포함할 수 없다는 특징도 있다.

여기까지 읽으면서 궁금한 점이 많이 생겼을 것이라 생각한다.

이제 클래스의 멤버에 대해서 알아봤고

각 멤버들의 생성되는 시점과 변수의 유효 범위까지 알아봤으니

다음번에는 멤버 변수를 초기화하는 방법에 대해서 알아보도록 하자.

[자바 프로그래밍 기본] 1. 클래스와 객체

거신 — Mon, 19 Dec 2022 03:52:54 +0900

우리가 이전 글에서 객체지향이 무엇을 의미하는지와 장단점에 대해서 알아봤고
마지막에서 객체지향이 지니고 있다는 특징 4가지를 포장지를 뜯진 않고 껍데기만 잠깐 살펴봤었다.
이번 시간에는 그 4가지 중에서 하나를 가져와 포장을 뜯어서 내용물을 확인"해 보려고" 했지만
그 포장지를 뜯기 위해선 먼저 진행해야 할 선행 퀘스트가 있어서 일단 그 퀘스트부터 처리하고자 한다.

목표 : 클래스와 객체에 대해서 정확하게 구분하고 각각의 의미를 이해할 수 있다.

클래스를 이용해 객체를 생성하는 방법을 알 수 있다.

1. 클래스와 객체

객체지향에 대해서 알아보면서 우리는 객체(Object)가 어떤 존재인지 간단하게 알아봤는데

객체를 볼펜을 구성하고 있는 각각의 부품이라고 했었다.
그리고 그 객체들을 뚝딱뚝딱 조립하여 하나의 프로그램으로 만드는 것을

객체지향 프로그래밍이라고 했다.

그렇다면 이제 우리는 그 볼펜 부품을 만들어 내는 존재에 대해서 알아보도록 하자.

당연하게도 부품이라는 게 하늘에서 뚝 떨어지는 게 아니라면

분명 그 부품을 만들어 내는 무언가가 존재할 것이다.

자바에서는 그 존재가 바로 클래스(Class)라는 존재이다.

처음 듣는 이름이라서 조금 생소할 수도 있겠지만

의외로 클래스는 자바를 공부하는 우리들의 곁에 항상 같이 있는 녀석이기도 하다.

잠깐 머리도 식힐 겸 자바 프로그램의 시작점인 main 함수를 작성해 보자.

예시 1)

public class Test {
    public static void main(String[] args) {
    	System.out.println("Hello World!");
    }
}

우리가 자바로 맨 처음에 소스 코드를 작성하면 예시 1)과 같이 맨 처음 작성할 것이다.

이 소스를 작성하기 위해서 여러분들은

자바 프로젝트를 생성하고 소스 폴더 안에 패키지를 만들고

Test.java 파일을 만들기 위해 새로 만들기로 "Java 클래스"를 만들었을 것이다.

여기에서 클래스가 우리가 지금 알아보려는 클래스와 동일한 녀석이다.

예시 1)의 소스 코드에서도 볼 수 있듯이

바로 public "class" Test와 같이 클래스는 우리와 항상 함께 하고 있는 것이다.

이와 같이 Test.java파일을 생성하는 동작을 우리는 클래스를 생성한다라고 표현한다.

자 그러면 클래스가

우리의 자바 프로젝트 안에!

우리의 가슴속에!

하나가 되어 살아가고 있다!

는 건 알겠는데 그렇다면 걔가 무슨 역할을 하는 녀석인지 찬찬히 살펴보도록 하자.

2. 클래스(Class)

간단하게 클래스를 한 마디로 표현하자면

객체의 설계도이다.

그러니까 클래스가 있어야만 객체가 만들어질 수 있는 것이다.

클래스에 대한 정보를 찾아보거나 어딘가에서 설명을 들었거나 했을 때

무조건 한 번쯤은 봤을 비유가 바로바로 붕어빵과 붕어빵 틀일 것이다.

간단하게 생각하면 가장 설명하기 쉬운 비유라고 생각하지만

내 생각엔 붕어빵과 붕어빵 틀의 관계로는 클래스를 설명한다는 게

뭔가 채울 수 없는 부분이 존재한다고 생각하기에

나는 역시 킹나미 갓펜을 가지고 설명하도록 하겠다.

~~(사실 힙스터라서 남들이 하는 대로 똑같이 하기 싫은 건 함정)~~

클래스가 객체의 설계도라고 했으니

다시 말해, 클래스는 볼펜 부품의 설계도인 셈이다.

그림 1)

여기 볼펜심이 하나 있다.

간단하게 생긴 볼펜심이라도 이걸 만들어내기 위해선

심의 길이는 얼마나 되어야 하고,

잉크를 채워 넣는 부분은 어떤 형태로 만들어야 하며,

잉크는 얼마나 넣고,

볼펜 촉은 또 어떤 모양으로 생겼으며,

잉크는 어떤 방식으로 뽑아내는지 등과 같이

다양한 요소들이 설계되어야 한다.

그리고 그 설계를 토대로 하나의 볼펜심이 만들어지는 것이다.

반대로 이런 설계 없이는 볼펜심을 만드는 것은 불가능하다.

즉, 객체를 생성하기 위해서 꼭 필요한 존재가 바로

객체의 설계내용을 담고 있는 클래스인 것이다.

객체는 클래스가 있어야 만들어낼 수 있고

그 클래스 안에는 볼펜심의 길이나 잉크의 양, 잉크를 뽑아내는 방식 등과 같이

객체의 각종 정보, 할 수 있는 기능 등이 포함되어 있는 것이다.

여기에서 간단하게 코드 형태로 한 번 알아보자.

예시 2)

class 볼펜심_설계도 {
    int 볼펜심_길이;
    String 볼펜심_형태;
    int 볼펜심_둘레;
    String 볼펜촉_모양;
    Color 잉크색;
    int 잉크양;

    public void 잉크를_뽑아냄() {
        
    }
}

간단하게 볼펜심을 만들 수 있는 클래스를 작성해 보았다.

이 클래스 안에는 두 가지 형태로 구성되어 있다는 것을 알 수 있을 텐데

볼펜심_길이, 볼펜심_형태, 잉크색과 같이 변수로 되어 있는 항목들과

잉크를_뽑아냄과 같이 함수로 되어 있는 항목들이 있다.

이런 변수와 함수가 객체의 내용을 구성해서 하나의 객체를 생성할 수 있게 되는 것이다.

그렇다면 클래스가 대충 어떤 것이며, 어떤 역할을 하며,

무엇으로 구성되어 있는지 알아봤으니

이제는 직접 객체를 생성하는 방법에 대해서 알아보도록 하자.

설계도를 어느 정도 읽을 줄 알게 되었으니

그 설계도를 이용해 해당 물건을 찍어낼 수 있는 기계를 사용해보자는 말이다.

3. new 연산자와 인스턴스

자! 설계도를 읽을 줄 알게 되었으니(만드는 방법은 나중에 더 상세하게)

이제 이 설계도를 이용해 물건을 찍어낼 수 있는 기계를 한 번 사용해보자.

볼펜심 설계도를 가지고 있더라도

그에 맞는 재료와 가공할 수 있는 기계가 없다면

볼펜심을 만드는 것은 불가능할 것이다.

그래서 자바에서는 당신이 설계도만 가지고 있다면

객체를 만들 수 있도록 재료와 가공할 수 있는 기계를 제공해주고 있다.

그것이 바로 new 연산자이다.

예시 3)

볼펜심_설계도 검은색_볼펜심 = new 볼펜심_설계도();

예시 3)과 같이 new 연산자를 이용해서 검은색_볼펜심이라는 객체를 하나 생성하였다.

복잡한 표현 없이 간단하게 new 클래스명()으로 객체를 만들 수 있다.

그리고 우리는 이를 클래스의 인스턴스를 생성한다고 표현한다.

아니 방금 전까지 new 연산자를 이용해서 객체를 생성했다고 했는데

뜬금없이 인스턴스를 생성했다니? 인스턴스는 또 뭔데?

그렇다면 객체와 인스턴스는 똑같은 말인가?

엄연히 따지면 세세한 부분에서 둘은 다른 단어이다.

어딘가에선 둘을 혼용해서 설명할 수도 있다고 생각하는데

적어도 여기에서는 둘을 구분해서 좀 더 정확한 의미로 여러분들에게 전달하고자 한다.

객체와 인스턴스는 클래스를 이용해 생성한 것들을 말한다.

이렇게만 본다면 객체와 인스턴스는 동일한 단어라고 생각할 수 있지만

여기에는 표현의 방법이 숨겨져 있다.

예시 3)에서 만든 검은색_볼펜심을 가지고 알아보자면

검은색_볼펜심은 객체이다.

그리고 검은색_볼펜심은 볼펜심_설계도의 인스턴스이다.

여기에서 차이를 느낄 수 있겠는가?

바로 클래스와의 관계성의 포함 유무에 따라서 표현하는 방법이 달라지는 것이다.

검은색_볼펜심 자체만 가지고 말한다면 객체라고 표현할 수 있다.

그리고 검은색_볼펜심을 볼펜심_설계도와의 관계를 따진다면

검은색_볼펜심은 볼펜심_설계도의 인스턴스라고 표현한다.

그럼에도 객체와 인스턴스를 혼용해서 사용한다고 해서 의미가 크게 달라지는 것이 아니기에

딱히 혼용한다고 해서 그것이 잘못되었다고 말을 할 수는 없겠지만

적어도 필자가 여기에서 작성할 때에는

확실하게 구분해서 작성하도록 노력하겠다.

4. 정리

우리가 객체지향에 대해서 알아보면서 객체지향에서 핵심인 객체(Object)에 대해서 알아봤고

그 객체를 생성하는데 필요한 클래스에 대해서 자세하게 알아봤다.

클래스는 객체의 설계도라고 표현했는데

그 단어 의미대로 객체를 생성할 때 필요한 요소들을 포함하고 있고

이는 자바에서 변수와 함수로 표현하고 있다.

그리고 객체를 생성하기 위해서는 new 연산자가 필요한데

new 클래스명()을 이용해서 객체를 생성할 수 있다.

그리고 new 연산자를 이용해서 객체를 생성하는 것을

자바에서는 인스턴스를 생성한다라고 표현한다.

객체와 인스턴스는 큰 의미로는 같은 의미로 사용될 수 있지만

클래스와의 관계에 따라서 둘을 명확하게 구분해서 표현할 수 있다.

[자바 프로그래밍 기본] 0. 서론 (feat. 객체지향 언어)

거신 — Wed, 14 Dec 2022 02:36:57 +0900

이 블로그에서 대부분 다루는 내용들을 몇 번 읽어본 사람들이라면

내용의 배경을 자바라는 언어를 가지고 설명하고 있다는 것을 다들 알고 있을 것이다.

하지만 설명을 자바로 한 것 뿐이지 다른 언어를 사용하고 있거나 배워본 사람들이라면

다른 언어들을 가져와 설명하더라도 특정 부분들을 제외하곤 대부분 다 비슷하다는 걸 느낄 것이다.

그래서 여기에서는 자바라는 언어와 그나마 직접적으로 관련이 있는 내용들을 다뤄보려고 한다.

다른 카테고리인 자바 프로그래밍 기초에서는

자바로 코딩이나 프로그래밍을 할 때 소스 코드를 "작성"할 때 유용한 내용들을 다룬다면

자바 프로그래밍 기본과 자바 프로그래밍 심화에서는

다른 사람들이 작성한 자바 소스 코드를 "분석"할 때

이게 무슨 의미인지, 왜 이렇게 작성했는지를 이해하는 지식을 전달하는 것에 초점을 맞추려고 한다.

물론 이 글은 자바 프로그래밍을 이제 막 공부하기 시작한 사람과

아직 미숙한 사람들을 위해 전공지식처럼 복잡하고 어려운 부분을 가능한 간단하고

최대한 이해하기 쉽게 작성하는 것이 목표이기 때문에

이 글을 읽어서 면접 준비를 한다든가 취준을 하는데 사용하는 그런 심오한 일은 삼가해주길 바란다.

본인이 그렇게 이용하겠다면 말리진 않겠지만 지식에서 누락된 부분에 대해선

그 부분까진 필자가 책임을 질 순 없다.

1. 객체지향 (Object-oriented)

자바에 대해서 공부하다보면 한번쯤은 봤을 법한 단어이다.

바로 객체지향이라는 단어인데 자바를 설명할 때 꼭 등장하는 단어이기도 하다.

그런데 객체지향이 뭘 말하는걸까?

단어 그대로를 파악해보자면

객체를 지향한다는 뜻인데 아니 글쎄 그러니까 그게 뭔데?라고 할 것 이다.

좀 더 풀어서 설명하자면

프로그래밍을 그냥 하지 말고 객체화해서 좀 만들어라.

뭐 그런 의미인 셈이다.

객체(Object)......

자세한 건 뒤에서 차근차근 알아가보도록 하자.

아무튼 간단하게 설명하자면 객체라는 걸 만들어서 그걸 가지고 프로그램을 만든다.

라는 말인데 좀 더 이해하기 쉽도록 비유로 이해해보자.

그림 1)

사진 출처 : 국립특수교육원 - 볼펜조립

여기에 우리가 흔히 사용하고 있는 모나미 볼펜이 있다.

이 녀석이 우리가 만들려고 하는 결과물(우리에겐 프로그램)이 되겠다.

그런데 너무나도 당연한 이야기겠지만 모나미 볼펜을 하나 만드는데 여러 부품들이 필요하다는 걸 알고 있을 것이다.

그림 2)

사진 출처 : 국립특수교육원 - 볼펜조립

이렇게 볼펜 하나에 몇 가지의 부품들이 필요하고

이 부품들을 이리저리 조립해서 그림 1)의 결과물을 만들어 내는 것이다.

여기에서 우리는 객체라는 녀석을 조금이나마 이해할 수 있다.

바로 그림 2)의 볼펜을 구성하는 각각의 부품들이

객체(Object)인 것이다.

뚜껑이라는 객체, 스프링이라는 객체, 볼펜 몸통이라는 객체 등을 만들어서

그 객체들을 뚝딱뚝딱하면 하나의 모나미 볼펜이 되는 것이다.

아마 이 정도만 설명하더라도 객체지향이라는 의미가

대충 어떤 의미인지는 이해했으리라 생각한다.

그런데 이렇게만 보면 한 가지 의문이 드는 부분이 있을 것이다.

객체지향이 뭔진 좀 알겠다.

근데 왜 객체지향으로 프로그래밍을 해야됨?

어....?

2. 객체지향 언어의 특징

앞에서 객체지향이 어떤 의미인지에 대해서 간단하게 알아봤지만

그래서 그걸 왜 써야하는지에 대해선 아직까지 물음표로 남아있다.

그래서 우리는 다시 모나미 볼펜을 조립하는 과정을 생각해 볼 필요가 있다.

그림 3)

사진 출처 : 국립특수교육원 - 볼펜조립

예를 들어서 모나미 볼펜을 만드는 방법이 왼쪽 그림과 같이 부품을 조립해서 만드는 것이 아니라

3D 프린터같은 걸로 볼펜을 모델링해서 한번에 뽑아낸다고 상상해보자.

만드는 과정이야 달라지겠지만 결과물은 비슷하게 나올 것이다.(잉크 뭐 이런 거 둘째치고)

작업 명령을 내리면 볼펜심만들고 스프링만들고 몸통만들고 뚜껑만들고 뭐 이런 식으로 진행해서

하나의 완성품이 만들어진다.

그런데 볼펜 회사 사장이 정신이 나갔는지 지금까지 검은색 볼펜만 잘 만들고 있었는데

볼펜의 다향성을 추구하기 위해 빨간색 볼펜과 파란색 볼펜을 만들라고 지시를 내렸다.

그렇다면 작업자는 빨간색 볼펜과 파란색 볼펜은 어떻게 만들어야 할까?

지금 3D 프린터로 볼펜을 만들고 있는 상황에선

어쩔 수 없이 빨간색 볼펜과 파란색 볼펜을 각각 새로 모델링을 해서

처음부터 다시 뽑아내야 할 것이다.

왜? 볼펜 하나를 만드는 공정이 그러하니까.

거기다 이제는 검은색 볼펜의 모델링과 공정 방식은 쓸모가 없어졌다.

이 상황만 놓고 봤을 때 우리는 뭔가 참신한 아이디어를 떠올리게 될 것이다.

'아니 볼펜심만 따로 만들어서 색만 다르게 하면 간단한 거 아님?'

이걸 여러분들이 당연하게 생각해냈다면

여러분들은 객체지향적인 사고를 하고 있다고 할 수 있다.

어쩌면 당연한 생각이라고 말할 수도 있겠다.

즉, 저 볼펜 하나를 만드는데 우리가 한번에 만들어내는 것이 아니라

각 부품(객체)별로 만들었다면

다른 색의 볼펜을 만드는 과정이 그렇게 번거롭지 않았을 것이다.

이것이 바로 우리가 객체지향 프로그래밍을 하고 있는 이유이기도 하다.

여기에서 객체지향의 특징과 장단점을 파악할 수 있는데

먼저 장단점부터 간단하게 살펴보자면

장점)

1. 재사용성

우리가 다른 색의 볼펜을 만들어야 하더라도 디자인이 바뀌지 않는 이상

각 부품의 형태 자체는 바뀌지 않기 때문에 여러 종류의 볼펜을 만들 때에 얼마든지 재사용할 수 있다.

심지어 볼펜심도 심에 들어가는 잉크의 종류는 달라지더라도

볼펜심의 형태 자체는 바뀌지 않기 때문에 역시 그대로 사용할 수 있다.

2. 생산성

새로운 색의 볼펜 만들겠다고 모델링부터 새로 해야하는 불상사가 사라진다.

우리는 다른 색의 볼펜심으로만 교체하면 얼마든지 다른 색의 볼펜을 만들어낼 수 있다.

3. 자연스러운 모델링

'볼펜심 색깔만 다르게 하면 되는거 아님?'

우리가 일상에서 당연하게 생각하는 것처럼 자연스럽게 구현할 수 있다.

4. 유지보수의 우수성

볼펜 하나를 만들 때 뚜껑이 잘못 만들어지면 우리는 뚜껑만 따로 다시 만들면 된다.

뚜껑을 잘못 만들었다고 볼펜 전체를 다시 만들어야 하는 불상사는 존재하지 않는다.

단점)

1. 개발 속도가 느림

근데 문제는 저렇게 볼펜을 부품화해서 만들기 위해선 일단 설계 단계에서

저렇게 계획하고 만들어야 하는데 저게 어디 하늘에서 떨어져서 뚝딱 만들어지는 건 아니니까....

저 부품들을 저 형태로 설계한 사람들은 천재가 아닐까?

2. 실행 속도가 느림

아니 3D 프린터로 한번에 쫙 뽑으면 볼펜 하나 나오는데

저건 부품들 다 만들어서 "조립"까지 해야되네???

3. 높은 난이도

설계하는 것도 시간이 오래 걸리고 아 조립도 해야되고

부품은 왜 또 저렇게 많은건지 참.... 이 부품은 어디에 쓰이는고??

이렇듯 장단점이 존재하지만 그럼에도 더 효과적인 방식이기에

현재 등장하고 있는 개발 언어들이 객체지향의 형태를 띄고 있는 것도 그러한 이유이다.

그리고 객체지향의 특징을 간단하게 살펴보면

상속(Inheritance)

캡슐화(Encapsulation)

다형성(Polymorphism)

추상화(Abstraction)

이렇게 4가지로 나타낼 수 있는데

자세한 내용은 다음 글에서 더 자세하게 살펴보도록 하자.

다음 글에서 만나자.

[Chapter 7 컴퓨터 구조] 3. 2진법의 음수 표현 (3편 - 심화 내용)

거신 — Fri, 16 Sep 2022 15:46:16 +0900

앞에서 다양한 음수 표현 방법을 알아보면서

2의 보수가 컴퓨터에서 음수를 표현하는데 얼마나 잘 어울리는지에 대해서 이해했으리라 믿는다.

이번 편에서는 앞서 미처 설명하지 못한 부분들에 대해서

언급하고 좀 더 자세히 설명할만한 부분들에 대해서 알아보는 편으로 작성한다.

1. 컴퓨터는 덧셈 밖에 할 줄 모른다.

1편에서도 언급했지만 컴퓨터의 산술 논리 장치(ALU)는 가산기로 구성되어 있고 덧셈만 연산할 수 있는 기계이다.

그렇기 때문에 뺄셈이라는 로직 자체를 구현한 것이 아닌

음수를 표현하는 방식을 채택함으로서 덧셈만으로 뺄셈도 할 수 있게 된 것이다.

이러면 논리회로를 설계함에 있어서도 복잡 다양한 논리회로 구조보단

조금이라도 더 단순한 논리회로 설계가 가능한 것이다.

이것이 수학에서의 보수라는 개념으로 컴퓨터에서 음수를 표현하게 된 이유이며,

그 중에서도 가장 효과적인 2의 보수로 음수를 표현하게 된 것이다.

2. 보수의 의미를 좀 더 명확하게

2편에서 소개한 보수의 정의는 사실 많은 부분을 함축한 상태라서

여러 부분에서 가려져 있는 것들이 있어, 이 기회에 조금이라도 더 자세하게 알아보고자 한다.

물론 필자도 지식이 부족하여 여러 군데에서 십시일반 정보를 모으고 정리해서 쓰는 것이라

두서없이, 부족한 부분 등이 있을 수도 있으니 이해해주길 바란다.

일단 본론으로 들어가기 전에 아래의 블로그의 글을 꼭 한 번 정독해주길 추천한다.

이번에 보수 표현과 관련해서 정보를 찾던 중에 설명이 잘 된 글을 발견해서 분명히 도움이 될 것이라고 생각한다.

https://fotc.tistory.com/entry/%EC%9D%8C%EC%88%98%EC%9D%98-%EB%B3%B4%EC%88%98%ED%91%9C%ED%98%84

음수의 보수표현

보수란? 보충수(數)이다. 차량 냉각수의 수위가 낮다면? 냉각수를 보충해 준다. 숫자값이 부족하다면 숫자를 보충해주는 것이다. 암산으로 더하거나 뺄 때 사용한다. 왜? 편하니까. 15 - 7 = 10 -7 +5

fotc.tistory.com

앞서 보수란

"보충해주는 수, 합해서 특정 숫자를 채우게 하는데 필요한 수"

라고 정의했는데 우리는 여기에서 수학적으로 좀 더 자세하게 알아볼 필요가 있다.

위키백과에서 보수 (수학)에 대해서 검색해보면

보수를 이용한 계산법

주판을 이용한 덧셈, 뺄셈을 할 때 5의 보수 혹은 10의 보수의 개념이 사용된다.
예를 들면 4+2를 계산할 때 +2를 4에 대한 5의 보수 1을 먼저 더한 뒤 1을 추가로 더했다고 이해할 수 있다.
즉, 처음의 수 4에 5의 보수 1을 더해서 5를 만든 뒤 나머지 1을 더해서 6이 된다고 간주할 수 있다.

이는 뺄셈일 때도 마찬가지인데, 7-3이라는 연산에서도 7=5+2로 나눌 수 있고,
2-3은 결과가 음수가 나오기에 우선 5에 대한 3의 보수 2를 구한 뒤 남은 숫자 2를 더한 값 4를 결과로 유도할 수 있다.

이런 부분을 확인할 수 있다.

우리가 눈여겨 볼 부분은 뺄셈을 하는 부분인데 글로만 읽었을 때는 잘 이해가 안 될 수도 있으니

이번에도 예시를 통해서 알아보자.

예시 1)

10진수를 바탕으로 8 - 3을 계산해보자.

그런데 뺄셈이 아니라 덧셈만으로 결과를 도출해 볼건데

여기에 보수라는 개념을 도입하면 뺄셈을 덧셈으로 바꿔서 계산이 가능해진다.

먼저 -3을 바꿀건데

=> +10 -3 -10

으로 바꿀 수 있을텐데

보수로 변환하는 방법을

"어떤 수에 합해서 해당 진법의 밑수로 만듦"

을 바탕으로 밑수인 10을 이용해 위의 식으로 변환한 것이다.

여기에서 -10은 일단 제쳐두고

예시 1)을 변환하면

8 + (10 - 3)으로 바꿀 수 있고

8 + 7 = 15로 결과를 낼 수 있다.

그리고 잠시 제쳐두었던 -10까지 계산해주면

15 - 10 = 5로

8 - 3 = 8 + (10 - 3) - 10 = 5

라는 결과를 얻을 수 있다.

여기에서 10 - 3 - 10이라는 식을 통해 보수의 공식을 얻을 수 있는데

$$ a^{n}-b-a^{n} $$

(a : 밑수, n : b보다 큰 자릿 수, b : 보수를 취하는 수)

로 표현할 수 있다.

그런데 위의 공식과 예시 1)의 풀이를 찬찬히 살펴보면

2의 보수가 어떻게 계산이 되는건지 왜 계산 후에 캐리 값을 무시할 수 있는지 이제는 이해가 될 것이다.

우리가 2의 보수를 알아볼 당시에 보수를 이렇게 정의한 적이 있다.

"어떤 수에 합해서 (해당 진법의 밑수로 만들어 "오버플로우"를 시킨 후) 0으로 만들어주는 수"

이는 $$ a^{n}-b $$, 즉, 10 - 3을 통해 3의 10의 보수를 구한 것이고,

보수를 이용해 계산한 후 다시 - 10을 함으로서 자릿 수를 넘어가는 캐리 값이 발생하더라도

자연스럽게 무시될 수 있는 것이다.

그리고 또 한 가지, 위의 인용글에서 언급된 내용으로

지금까지 보수를 말할 때 "3의 10의 보수를 7"이라고 표현했는데

더 정확히는 "-3의 10의 보수는 7"이라고 표현해야 한다는 것이다.

인터넷에서 2의 보수와 관련해서 검색하다보면 한 번 쯤은 볼 수 있는 그림이 있는데

그림 1)

보통은 원으로 다들 그렸을 테지만 필자는 귀차니즘으로 인해 마름모로 그렸다.

어쨌든 위의 그림 1)을 보면 1000 (2)부터 1111 (2)까지 음수로 표현하고 있고

이는 각각의 보수관계를 시각적으로 표시해주고 있는 것이다.

표로 바꿔보면 다음과 같다.

4비트의 수로 표현했기에 밑수는 16이 되고 이를 가지고 음수로 바꾼 후,

MSB가 0을 양수, 1을 음수로 표현하면 그림 1)과 매칭이 되는 것을 알 수 있다.

그렇다면 보수를 말할 때 3의 보수가 아니라 -3의 보수라고 하는 것이 정확하단 이유는

컴퓨터에서는 음수를 표현할 수 없기 때문에 보수라는 개념으로 양수를 음수처럼 사용하고 있는 것이다.

다시 말해, 양수의 보수표현은 할 수 없고 음수의 보수 표현만이 존재한다는 뜻이기도 하다.

물론 컴퓨터 구조에서 말이다.

3. 마무리

세 편의 긴글을 보면 조금은 정리되지 않고 장황하게 써놓은 것처럼 보일 수도 있을 것 같다.

물론 나도 여느 다른 글들처럼

1의 보수로 어떻게 바꾸고, 2의 보수로 어떻게 바꾸는지에 대해서만 적었으면 편했겠지만

이번 글을 작성하면서 가장 먼저 생각했던 부분은

하나의 내용을 다루더라도 시험공부마냥 핵심 내용만 전달하는 것이 아니라

정의에 대해서도 정확하게 상세한 내용을 전달함과 동시에

함축되어 있거나 복잡하게 되어 있는 부분을 최대한 풀어내고

'왜 이렇게 바뀌는건지', '왜 이런 의미인지', '왜 사용하는 것인지'처럼

의문점이 생길만한 부분을 최대한 많이 다뤄서

잘 모르는 사람이 이 글을 읽었을 때 개념을 이해하는데 조금이라도 더 도움이 되고 기억에 남았으면 하는 점이었다.

그러다보니 내용이 장황하게 길어진 부분도 있었고 어떨 때는 두서없이 진행된 부분도 있을 것이라 생각한다.

그리고 필자도 지식이 부족하다보니 수많은 정보들을 나름대로 정리하고 개인적인 생각으로 해석한 부분도 있어서

틀린 부분도 있지 않을까하는 걱정도 있다.

(오히려 내 스스로 공부를 더 많이 하게 된 것 같아서 그런 부분에서 위안을 삼고 있다.)

그렇다해도 2진법의 음수표현, 1의 보수, 2의 보수를 검색해서 우연히 들어온 사람이

이 글을 읽고 나서 머릿 속에서 조금이라도 정리가 잘 되어서

더 많은 지식을 얻어갔으면 하는 바람이 있다.

끝.

※ 혹시라도 잘못된 내용이나 부족한 부분, 또는 의문이 드는 부분이 있다면

댓글 등으로 알려주시면 수정 및 보강할 수 있도록 노력하겠습니다.

부족한 글 읽어주셔서 감사합니다.

인용 출처 : https://fotc.tistory.com/entry/%EC%9D%8C%EC%88%98%EC%9D%98-%EB%B3%B4%EC%88%98%ED%91%9C%ED%98%84

[Chapter 7 컴퓨터 구조] 2. 2진법의 음수 표현 (2편 - 1의 보수, 2의 보수)

거신 — Wed, 14 Sep 2022 16:34:47 +0900

1편에서는 2진수를 음수로 표현하는 방법 중 부호 절댓값에 대해서 간단하게 알아봤다.

2편에서는 보수라는 개념을 통해서 1의 보수와 2의 보수를 표현하는 방법,

2의 보수로 2진수를 음수로 표현하는 방법이 효과적인 이유를 설명한다.

목표 : 보수의 개념을 이해하고 1의 보수와 2의 보수를 이용해 음수로 변환 후 음수 연산을 할 수 있다.

1. 보수의 개념

1편에서 부호 절댓값에 대해서 알아봤는데 음수로 변환하는 방법은 간단하지만

그에 따른 단점이 있는 것을 알 수 있었다.

결국 우리와 함께 갈 수 없었던 부호 절댓값을 뒤로하고

우리 앞에 등장한 녀석이 바로 보수라는 개념이다.

생소한 단어일 수도 있는데 수학에서 등장하는 용어인데 수학적 의미로는

"보충해주는 수, 합해서 특정 숫자를 채우게 하는데 필요한 수"

라는 뜻인데 이를 컴퓨터 공학에서 보면

"어떤 수에 합해서 해당 진법의 밑수로 만들어 주는 수"

라는 복잡한 의미로 설명할 수 있다.

좀 더 풀어서 설명하자면

10진법을 기준으로 예를 들자면

3이라는 숫자의 보수는 더했을 때 10진법의 밑수인 10으로 만들어주는 수인

7이 3의 보수가 되는 것이다.

이를 10의 보수라고 표현할 수 있다.

사실 조금 더 수학적인 부분에서 자세히 설명하면 좋은 부분이 있으나

글이 길어질 수도 있고 지금은 우리가 필요한 부분을 중점적으로 알아가 보자.

보수라는 수학적 개념을 간단하게 알아봤으니 이제 본격적으로 1의 보수와 2의 보수를 알아보도록 하자.

2. 1의 보수

우리는 2진법을 사용하고 0과 1만을 사용하기 때문에

보수를 이용하는 데 있어서 좀 더 간편하게 이해할 수 있다는 장점이 있다.

그런데 1의 보수는 무엇이며, 2의 보수는 무엇이냐 하면

일반적으로 n진법에서의 보수는 (n-1)의 보수, n의 보수 이렇게 2가지로 사용할 수 있다는 특징이 있다.

그렇기 때문에 2진법에서는 1의 보수와, 2의 보수가 존재하고 있는 것이다.

1의 보수는 앞의 보수 개념을 이용하면 어떤 수를 더했을 때 1이 되게 해주는 수를 말하는 것일 테고

2진법에서는 0과 1만 존재하므로 두 수가 각각의 1의 보수가 된다는 것을 유추할 수 있을 것이다.

간단히 말해 1 -> 0, 0 -> 1로 바꿔주기만 하면 된다.

예시 1)

0011 1001 (2)

1100 0110 (2) <- 1의 보수

예시 1)과 같이 단순히 0과 1을 바꿔주기만 하면 되기 때문에 간단하게 1의 보수를 구할 수 있다.

※ 다른 곳에서 1의 보수의 설명에서 대부분 뺄셈식도 보여주면서 설명을 하는데 여기에서는

뺄셈식은 '가능하면' 포함하지 않고 설명하려고 한다.

그러면 이제 1의 보수를 구할 수 있게 되었으니 연산을 통해서 확인해보자.

0011 1001 (2)는 10진수로 57 (10)이고

이에 1의 보수는

1100 0110 (2)로 표현할 수 있고 -57 (10)이라는 것을 알 수 있다.

여기에 88 (10)을 더해보자.

예시 2)

1100 0110 (2)

0101 1000 (2)

-57		1	1	0	0	0	1	1	0
88	+	0	1	0	1	1	0	0	0

이렇게 연산을 하면 자릿수에서 오버플로우가 발생한 캐리 값이 발생하게 된다.

일단 캐리 값을 무시하고 결괏값만 보면

0001 1110 (2)로 30 (10)

이 나오는데 정확한 값인 31에서 1이 모자란 결과가 나온다.

여기에서 바로 캐리 값을 결괏값에 더해주면 된다.

그러면 최종 결괏값은

31 (10)이 도출되는 것을 알 수 있다.

정리하자면 1의 보수로 인해서 캐리 값이 발생했으므로 연산된 결괏값에 캐리 값을 더해주면 되는 것이다.

그렇다면 캐리 값이 발생하지 않는 경우도 있을까?

아래의 예시를 보자.

예시 3)

1100 0110 (2)

0000 1010 (2)

-57		1	1	0	0	0	1	1	0
10	+	0	0	0	0	1	0	1	0

위에서 연산된 결과는 MSB가 1이므로 부호는 - (마이너스)이므로 보수로 되어 있다는 것을 알 수 있다.

따라서 1의 보수로 바꾸면

47 (10)이 되는 것을 확인할 수 있다.

마지막으로 원래 결과의 부호가 - 였으므로

최종 결과는 -47 (10)로 캐리 값이 발생하지 않는 것도 확인할 수 있다.

이는 1의 보수의 단점을 보여주고 있는 것이기도 하다.

오버플로우로 인해 캐리 값이 발생하게 되면 추가적인 연산 작업이라는 수고스러움이 발생하게 되고

이는 논리회로의 설계를 복잡하게 만든다는 문제가 발생하게 된다.

또한 1의 보수도 앞서 알아봤던 부호 절댓값과 마찬가지로 MSB를 부호 비트로 사용하면서

0을 표현하는 데 -0과 +0으로 구분하여 표현한다는 점도 동일하다.

하지만 해당 비트를 반전 시키는 것만으로 음수를 표현할 수 있고

덧셈만으로 뺄셈을 구현할 수 있다는 특징이 있다.

이러한 장단점을 통해 우리는 1의 보수에서 조금 더 개선된

2의 보수라는 녀석을 만나러 갈 것이다.

그럴거면 뭐하러 굳이 이렇게 길게 1의 보수라는 것에 대해서 알아봐야 했는가 의문이 들 수도 있을텐데

그 이유는 2의 보수가 1의 보수의 개념이 필요하기 때문에

우리는 지금까지 그 준비 운동을 한 것이라고 생각해주면 좋겠다.

3. 2의 보수

이제 본격적으로 2진법의 세상에서 음수를 표현하는 방법과 2의 보수에 대해서 자세히 알아보도록 하자.

2의 보수는 말 그대로 어떤 수에 더했을 때 밑수 2가 되게 해주는 수라는 것을 이제는 바로 이해할 것이다.

그런데 1의 2의 보수는 1이라는 건 당연히 알겠지만 0의 2의 보수는 무엇이란 말인가?

2진법의 세계에서는 0과 1이라는 숫자 밖에 존재하지 않는데

0의 2의 보수인 수 2는 도대체 어디에 있다는 것인가.

앞서 보수의 개념의 이해를 돕기 위해 10진법을 이용해 간단하게 설명했었다.

조금 당연한 소리를 하자면 10진법에서 표현할 수 있는 수는

1 ~ 10이 아니라 0 ~ 9라는 것을 알고 있을 것이다.

보수는 더했을 때 밑수가 되어야 하니 10진법에서도 0의 10의 보수는 10이 되어야 한다고 생각하겠지만

사실 0의 10의 보수는 0이 된다.

10진법에서 10은 자릿수를 넘어가는 수가 되기 때문에 앞자리에 오버플로우가 발생하고

그 결과 0이 되기 때문에 결국 보수의 개념에서는 10 == 0 이 된다는 뜻이다.

따라서 0의 10의 보수는 0이 된다는 것도 이해가 될 것이다.

※ 다시 말하지만 보수는 수학적인 개념이 필요하기 때문에 좀 더 정확하고 깊이 들어가야 하지만

여기에서 그러기엔 너무 어렵고 복잡하기 때문에 우리는 좀 더 간단하게 이해하자.

다시 2진법의 세계로 돌아와 2의 보수를 다시 살펴보면

0과 1로만 구성되어 있는 세계에서 2라는 숫자는 오버플로우가 발생한 숫자가 되는 것이고

결국 2 == 0이라는 것을 아마 이해할 수 있을 것이다.

즉, 0의 2의 보수는 2이면서 동시에 0인 것이다.

여기에서 오버플로우라는 것에 초점을 맞춰서 생각해야 한다.

2의 보수 등을 다루는 여러 블로그의 글들을 찾아보면 2의 보수를 만드는 방법을

원래 수를 1의 보수로 바꾸고 그 수에 1을 더하면 된다고 간단하게 설명하는 것을 볼 수 있을 것이다.

이렇게만 이해하고 사용한다면 변환 방법만 이해하는 것이기 때문에

여기에서는 단순히 변환 방법만 다루지 말고

왜 그렇게 되는 건지에 대한 부분을 조금 더 세밀하게 알아보자.

0의 10의 보수, 2의 보수가 왜 0이 되는지 알아보는 과정에서

자릿 수를 넘어가는 수, 다시 말해, 오버플로우가 발생하기 때문에

그 결과 0이 되는 것이고 0의 10의 보수, 2의 보수가 전부 0인 이유인 것이다.

조금만 더 생각해보면 보수는 단순히 보충해 주는 수가 아니라

"어떤 수에 합해서 (해당 진법의 밑수로 만들어 "오버플로우"를 시킨 후) 0으로 만들어주는 수"

라고 정리할 수 있겠다.

그렇다면 이를 바탕으로 바로 예시로 들어가 보자.

예시 4)

이라는 수가 있다면 이 수의 2의 보수를 구하기 위해선

더했을 때 오버플로우를 발생시켜 0으로 만드는 수를 찾으면 되는 것이다.

그 말인즉슨, 오버플로우 된 수에서 원래의 수를 "빼면" 우리가 찾고자 하는 2의 보수를 만날 수 있다는 뜻이기도 하다.

물론 컴퓨터 연산에서는 뺄셈 연산이 존재하지 않기 때문에

(그 때문에 이렇게 장황하게 보수를 공부하고 있기도 하고)

실제로는 존재하지 않지만 우리는 수학적인 접근으로 이해하기 위해서 뺄셈 연산을 하는 것이다.

8비트에서 오버플로우로 0이 되는 수는 아래와 같다.

이 오버플로우 수에서 예시 4)를 빼면

1	0	0	0	0	0	0	0
-	0	0	1	1	1	0	1
=	1	1	0	0	0	1	1

(2진법 뺄셈 헷갈린다면 인터넷에서 꼭 찾아보길...)

이렇게 계산한 결과

1100 0110 (2)

를 얻을 수 있다.

이제 2의 보수로 변환하는 방법으로 위의 값과 비교해 보자.

2의 보수로 변환하는 방법은 원래 수를 1의 보수로 변환한 후 +1을 하면 된다.

예시 5)

원래 수	0	0	1	1	1	0	1	0
1의 보수화	1	1	0	0	0	1	0	1

1의 보수로 변환한 예시 5)에 1을 더하면

1100 0110 (2)

가 되므로 우리가 앞서 계산했던 결과와 동일하다는 것을 알 수 있다.

이제 마지막으로 2의 보수로 연산을 해보자.

예시 4)를 2의 보수로 변환한 수

1100 0110 (2) ( == -58 (10) )

에 0101 1000 (2) ( == 88 (10) )을 연산해서 결과를 얻어보자.

예시 6)

-58		1	1	0	0	1	1
88	+	0	1	1	1	0	0
30	1	0	0	1	1	1	1

예시 6)의 결과와 같이 2의 보수로 연산한 결과는 1의 보수와는 달리

오버플로우가 발생해 이후에 캐리 값을 더해주지 않아도 정확한 값이 도출된다는 것을 알 수 있다.

이러한 특징들을 정리하자면 2의 보수에는 이런 장점들이 있다고 할 수 있다.

2의 보수는 캐리 값이 발생하더라도 추가적으로 더하는 연산이 필요 없기 때문에

1의 보수보다 논리회로 설계가 훨씬 간단해진다.

더군다나 캐리 값을 무시해도 되니 연산 속도도 빨라진다는 장점이 있다.

또한 2의 보수도 MSB를 부호 비트로 사용하면서도

부호 절댓값과 1의 보수의 단점이었던 -0, +0으로 구분하지 않고

하나의 0만을 사용하는 것도 장점이라 할 수 있겠다.

어쨌든 2의 보수로 변환하는 방법을 외우는 것이 더 효과적이지만

이 글을 통해서 어떻게 그런 변환 방법이 나타나게 되었는지에 대해서 알아가는 시간이 되었으면 한다.

3편에서 계속

[Chapter 7 컴퓨터 구조] 1. 2진법의 음수 표현 (1편 - 부호 절댓값)

거신 — Tue, 13 Sep 2022 17:32:45 +0900

최근에 달렸던 댓글에 답변을 하면서 문득 뇌리를 스친 내용이 생겨서

정말 오랜만에 간단한 컴퓨터 구조론 지식을 포스팅해보고자 한다.

이 내용을 공부한 지 오래되어서 예전에 공부했던 정보처리기사에서 정보를 얻고자 검색했는데

2020년 이후로 개정된 정보처리기사는 나에게 있어 너무 생소한 기사 자격증이 되어 버려서

잠시 정신을 잃을 뻔하다가 다시 정신을 차리고 여기저기서 공부를 하고 내 나름대로 작성해보려 한다.

잡설은 그만두고 여기에서 작성되는 내용은 직접적으로 프로그래밍을 언급하는 부분이 아니라

컴퓨터 공학과 관련된 지식을 얻고 간다는 생각으로 가볍게 읽어줬으면 좋겠다.

읽어보고 이해가 잘돼서 나의 지식이 되면 좋은 것이고 모르면 어쩔 수 없는 것이고....

설명에 있어서 최대한 풀어서 설명하는 경향이 있기에 글이 길어질 수 있으므로

여려 편으로 나눠서 설명을 진행할 계획이다.

이번 편에서는 부호 절댓값에 대해서 설명할 것이다.

목표 : 2진수의 음수 표현 방법 중 부호 절댓값에 대해서 변환하는 방법과 단점을 이해한다.

0. 서론

우리가 흔히 사용하고 있는 컴퓨터는 0과 1을 가지고 모든 데이터를 표현한다. 양자 컴퓨터 이런 건 얘기가 달라지겠지만

일단 우리가 알고 있는 컴퓨터의 구조에서는 0과 1만이 존재하고 이 2개의 숫자로 연산을 진행하는 것을

우리는 2진법이라고 말하는 것이다.

그런데 궁금한 점이 생기지 않는가?

단순히 0과 1을 이용해서 연산을 하는데 음수는 어떻게 표현할 수 있는 것일까?

비트에 부호가 있는 것도 아니고 -(마이너스)는 어떻게 표현한다는 것인가?

그리고! 도대체 컴퓨터는 어떻게 뺄셈이란 걸 할 수 있는 것인가??

알고보면 컴퓨터는 사칙연산 중에서 덧셈 밖에 할 줄 모르는 녀석이다.

컴퓨터는 논리회로로 이루어져 전기적 신호를 가지고 논리 연산을 실행하는 계산기이다.

우리가 보통 컴퓨터는 0과 1로 이루어져 있다고 하지만

우리가 숫자로 0과 1로 표현한 것이지 실질적으로 전기 신호의 ON / OFF를 말하고 있는 것이다.

이러한 전기 신호를 다양한 논리 게이트 (AND, OR, NOT, XOR, NOR 등등)를 이용해

산술 연산을 하는 기계가 바로 우리가 지금 사용하고 있는 컴퓨터인 것이다.

(혹시라도 나중에 기회가 된다면 논리 게이트에 대해서도 간단하게 알아볼 수 있도록 하겠다.)

이런 논리 게이트 조합되어 가산기가 되어 컴퓨터의 산술 논리 장치(ALU)의 부분으로 동작하는데

문제는 가산기라는 건 덧셈만 하는 기계라는 뜻이기도 하다.

그렇다면 컴퓨터에서는 어떻게 뺄셈을 연산할 수 있으며 또, 음수는 어떻게 표현할 수 있다는 것일까?

컴퓨터 구조와 관련해서 조금 더 심화된 내용을 여기에서 다루기엔

너무 복잡하고 또 이 글을 읽는 목적에도 어울리지 않기 때문에 생략하고

우리는 일단 컴퓨터에서 음수를 표현하는 방법부터 알아가보고자 한다.

컴퓨터는 덧셈만 하는 장치라고 했으니

이는 음수로 표현할 수 있는 방법만 알 수 있다면 덧셈만으로도 뺄셈을 구현할 수 있다고 유추할 수 있을 것이다.

그러므로 우리는 컴퓨터에서 음수를 표현하는 방법에 대해서

집중적으로 알아보도록 하자.

컴퓨터에서 음수를 표현하는 방법으로 3가지가 있다.

부호 절댓값, 1의 보수, 2의 보수

이렇게 총 3가지의 표현법이 있는데

현재 우리가 사용하고 있는 대부분의 컴퓨터에서는 모두 2의 보수라는 방식으로 음수를 표현하고 있다.

2의 보수가 등장하기 전에 음수를 표현하는 방법으로 고안되었던 방식인

부호 절댓값과 1의 보수는 방법은 간단하지만 단점이 분명했기 때문에

이제는 사용하지 않는 방식이다.

하지만 필요한 지식이 될 수도 있으니 하나하나 차근차근 살펴보도록 하자.

1. 부호 절댓값

컴퓨터에서 가장 간단하게 음수를 표현할 수 있는 부호 절댓값이다.

지루하게 글로 읽지 말고 예시를 가지고 좀 더 직관적으로 알아보자.

참고로 우리가 사용하는 컴퓨터의 프로세서는 32bit, 64bit 등의 연산 단위를 가지고 있는데

여기에서 32bit, 64bit 등으로 표현하면 너무 복잡하니까

우리는 간단하게 8bit를 기준으로 알아가보자.

예를 들어 11 (2)을 2진법으로 표현하면

예시 1)

이렇게 적을 수 있는데

부호 절댓값을 이용해 -11 (10)을 표현하고 싶다면

예시 2)

그림과 같이 맨 왼쪽의 비트를 1로 바꾸기만 하면 된다.

물론 8bit 이상의 자리라도 동일하게 가장 왼쪽의 비트 값을 1로 바꾸면 된다.

여기서 가장 왼쪽 비트를 MSB(Most Significant Bit), 최상위 비트라고 말하고

여기에서는 부호를 구분하는 용도로 사용했기 때문에 부호 비트라고 표현한다.

이렇듯 부호 절댓값은 비트 하나만 바꾸면 되는 방법이기 때문에 음수를 표현할 수 있는 가장 간단한 표현법이다.

하지만 지금 우리가 사용하고 있는 컴퓨터에서 음수를 표현하는 방법으로 부호 절댓값을 사용하지 않는다.

그 이유는 생각보다 간단한 이유가 있다.

2. 부호 절댓값의 함정

부호 절댓값은 가장 왼쪽 비트, 다시 말해, 최상위 비트(MSB)의 값을 바꿔서 표현하는 방법이기 때문에

사람의 입장에서는 직관적으로 파악할 수 있다는 장점이 있지만

컴퓨터에게는 너무나도 불편한 녀석이 아닐 수 없다.

가장 간단한 예시로 위의 예시 1)과 예시 2)를 더해보자.

예시 3)

11		0	0	0	0	1	0	1	1
-11	+	1	0	0	0	1	0	1	1

-22?

결과에서도 볼 수 있듯이 11 (10)과 -11 (10)을 더했는데

결괏값으로 0이 아닌 -22 (10)이 나와버렸다.

다른 예시를 살펴보자.

예시 4)

-32		1	1	0	0
-17	+	1	0	1	1
49?	1	0	1	1	1

이번에는 음수 -32 (10)와 음수 -17 (10)를 더해 보았다.

부호 비트가 두 수 모두 1이라서 덧셈을 하니 자릿 수를 넘어가버리는 오버플로우가 발생해 버렸다.

비록 부호 비트는 없어져 버렸지만 어쨌든 절댓값만 따진다면 결괏값은 49 (10)로 제대로 계산은 됐다.

혹여 두 수 모두 부호 비트가 1인 음수라면 부호 비트는 연산하지 않고 그대로 1로 두는 동작을 구현한다면

아마 이 부분은 해결이 될테지만 하드웨어로 설계할 때 아마 엔지니어의 머리는 터져 나갈 것이다.

위의 예시들을 보더라도 단순히 논리 회로들로만 구성되어 있는 컴퓨터를 설계하는데 있어서

얼마나 복잡해질지 정신이 아득해 질 것이다.

수많은 케이스를 생각하고 또 각 케이스들마다 논리회로를 구현해야 한다면....

또한 부호 비트만으로 양수, 음수를 구분하는 덕분에 0에 부호가 붙는 요상한 숫자까지 등장하게 된다.

예시 5)

+0?

-0?

부호 비트를 제외한 나머지 비트로만 숫자를 표현하게 되니 0이 2개가 존재하게 되고

부호 비트에 따라 부호가 붙게 되니 +0, -0이라는 숫자가 등장하게 되는 것이다.

결국 이러한 단점을 가진 부호 절댓값은 우리와 함께 할 수 없게 되었고

이론으로 남겨지게 되었다.

2편 1의 보수, 2의 보수 에서 계속

※ 부족한 부분과 잘못된 부분이 많아서 전체적으로 내용을 많이 수정하고 추가하였습니다.

혹시라도 잘못된 정보를 얻고 가셨던 분들에게는 양해의 말씀을 전합니다.