[Java] 상수 & 오버플로우 & 형변환

🚀 상수

⭐ 상수 개요

✅ 상수란?

상수(constant)는 변수와 동일하게 데이터를 저장할 수 있는 공간이다.

다만, 변수와 다른 점은 한 번 메모리에 저장된 데이터를 변경할 수 없다.

 

✅ 상수 사용 목적

1. 변경되지 않는 고정된 값을 저장할 목적으로 사용한다.

2. 초기화 이후 값 대입 시 컴파일 에러를 발생시켜 값이 수정되지 못하도록 한다.

ex) 수학 공식에 사용되는 수치, 프로그램의 기본적인 환경설정 정보(DB 정보, IP 주소정보 등)

 

⭐ 상수의 사용

상수를 사용하는 방법은 변수와 거의 동일하다.

다만 차이점은 선언 시 final 키워드를 사용한다는 부분이 다르다.

✅ 상수의 선언 및 초기화

/* 1. 상수 선언
final int AGE; // 상수 선언 시 자료형 앞에 final 키워드를 붙인다.

/* 2. 초기화 */
AGE = 20;
//AGE = 30; // 한 번 초기화 한 이후 값을 다시 대입하는 것은 불가능하다.

/* 3. 필요한 위치에 상수를 호출해서 사용한다. */
System.out.println("AGE의 값 : " + AGE); // 출력 구문에서 사용
System.out.println("AGE의 2배 : " + (AGE * 2)); // 필요 시 연산식에 호출해서 사용

 

✅ 상수의 명명 규칙

1. 모든 문자는 영문자 대문자 혹은 숫자만 사용한다.

final int AGE1 = 20;
final int AGE2 = 30;
final int age3 = 40; // 소문자로 사용은 가능하지만 변수와 구분하기 힘들기 때문에 만들어진 규칙이다.

2. 단어와 단어 연결은 언더스코어( _ )를 사용한다.

final int MAX_AGE = 60;
final int MIN_AGE = 20;
final int minAge = 30; // camel case 사용이 가능하지만 역시 변수와 구분되지 않는다.

 

---

🚀 오버플로우

⭐ 오버플로우 개요

✅ 오버플로우란?

오버플로우(overflow)란 변수가 담을 수 있는 값의 범위를 벗어나는 데이터를 담았을 때 발생하는 현상을 오버플로우라고 한다.

자료형 별 값의 최대 범위를 벗어나는 경우 발생한 carry를 버림 처리하고 sign bit를 반전시켜 최솟값으로 순환시키는 현상이다.

System.out.println("byte 값의 범위 : " + Byte.MIN_VALUE + " ~ " + Byte.MAX_VALUE);
System.out.println("char 값의 범위 : " + (int)Character.MIN_VALUE + " ~ " + (int)Character.MAX_VALUE);
System.out.println("short 값의 범위 : " + Short.MIN_VALUE + " ~ " + Short.MAX_VALUE);
System.out.println("int 값의 범위 : " + Integer.MIN_VALUE + " ~ " + Integer.MAX_VALUE);
System.out.println("long 값의 범위 : " + Long.MIN_VALUE + " ~ " + Long.MAX_VALUE);
System.out.println("float 값의 범위 : " + Float.MIN_VALUE + " ~ " + Float.MAX_VALUE);
System.out.println("double 값의 범위 : " + Double.MIN_VALUE + " ~ " + Double.MAX_VALUE);

 

✅ 오버플로우 발생 확인과 해결 방법

1. 오버플로우

byte num1 = 127;
System.out.println("num1 : " + num1); // 127 : byte의 최대 저장 범위
num1++; // 1 증가
System.out.println("num1 overflow : " + num1); // -128 : byte의 최소 저장 범위

2. 언더플로우

byte num2 = -128;
System.out.println("num2 : " + num2); // -128 : byte의 최소 저장 범위
num2--; // 1 감소
System.out.println("num2 underflow : " + num2); // 127 : byte의 최대 저장 범위

3. 논리적 문제 발생과 해결 방법

/* ===== 문제 발생 ===== */
int firstNum = 1000000; // 100만
int secondNum = 700000; // 70만
int multi = firstNum * secondNum; // 7천억이 나와야 함
System.out.println("firstNum * secondNum = " + multi); // --79669248 이 나온다.


/* ===== 해결 방법 ===== */
/* 오버플로우를 예측하고 더 큰 자료형으로 결과값을 받아서 처리한다. */
long longMulti = firstNum * secondNum;
System.out.println("longMulti : " + longMulti); // 여전히 오버플로우가 발생한다.

/* 이미 오버플로우 처리된 결과를 가지고 변수에 담기 때문에 위에 결과랑 별 차이가 없다.
* 그럼 어떻게 해결을 해야 하나?
* 계산이 처리 되기 전에 long 타입으로 자료형을 변경해주어야 한다. (강제 형변환 이용)
* */
long result = (long) firstNum * secondNum;
System.out.println("result : " + result); // 정상적으로 7천억이 출력될 것이다.

 

---

🚀 형변환

⭐ 형변환 개요

✅ 형변환이란?

자바 형변환(casting)이란 변수 또는 리터럴을 다른 타입으로 변환하는 것을 말한다.

형변환을 하는 이유는 프로그램에서 변수에 값을 넣거나 연산을 수행할 때는 같은 타입끼리만 가능하기 때문이다.

 

✅ 형변환의 종류 및 규칙

1. 자동 형변환 (묵시적 형변환)

컴파일러가 자동으로 수행해 주는 타입 변환이다.

데이터 손실 가능성이 없는 경우 자동으로 타입을 맞춰준다.

출처: fakerdeft

/* ========== 작은 자료형에서 큰 자료형으로는 자동 형변환 된다. ========== */
/* 1. 정수끼리의 자동 형변환 */
/* 점점 더 큰 자료형으로 데이터를 옮겨도 문제 없이 자동 형변환 처리된다. */
byte bNum = 1;
short sNum = bNum;
int iNum = sNum;
long lNum = iNum;
/* 연산 시에도 자동으로 큰 쪽 자료형에 맞춰서 계산한다. */
int num1 = 10;
long num2 = 20;
//int result1 = num1 + num2; // 자동으로 큰 쪽 자료형인 long으로 변경 후 계산하기 때문에 int형 변수에 값을 담을 수 없다.
long result1 = num1 + num2; // int + long은 서로 다른 자료형이라 데이터 손실이 발생하지 않는 int-> long 변환을 자동 수행 후 연산한다.
System.out.println("result1 : " + result1);
/* 2. 실수 끼리의 자동 형변환 */
float fNum = 4.0f;
double dNum = fNum;
/* 연산 시에도 자동으로 큰 쪽 자료형에 맞춰서 계산된다. */
double result2 = fNum + dNum;
System.out.println("result2 : " + result2);


/* ========== 정수는 실수로 자동 형변환 된다. ========== */
/* 정수를 실수로 변경할 때 소수점 자리수가 없어도 실수 형태로 표현이 가능하다. 
* 이 때 데이터 손실이 없기 때문에 자동 형변환이 가능하다.
* 실제 값을 저장하는 매커니즘을 가진 것과 달리 실수형은 지수부와 가수부를 따로 나눠서 작성하기 때문에
* 바이트 크기 보다 훨씬 더 많은 값을 표현할 수 있다.
* */
//long eight = 888888888888888888888; // 이것도 지동으로 형변환 된 것이다. (int 범위 벗어나면 에러 발생)
long eight = 8;
float four = eight;
System.out.println("four : " + four);
/* 따라서 실수와 정수의 연산은 실수로 연산 결과가 반환된다. */
float result3 = eight + four;
System.out.println("result3 : " + result3);


/* ========== 문자형은 int형으로 자동 형변환 된다. ========== */
char ch1 = 'a';
int charNumber = ch1;
System.out.println("charNumber : " + charNumber);
/* int로 type이 정해지지 않은 리터럴 형태의 정수는 char 형 변수에 기록 가능하다. */
char ch2 = 65;
System.out.println("ch2 : " + ch2);


/* ========== 논리형은 형변환 규칙에서 제외된다. ========== */
/* 어느 자료형이든 boolean을 형변환 해서 담을 수 없다. */
boolean isTrue = true;
//byte b = isTrue;
//short s = isTrue;
//int i = isTrue;
//long l = isTrue;
//char c = isTrue;
//float f = isTrue;
//double d = isTrue;

2. 강제 형변환 (암시적 형변환)

형변환(casting) 연산자를 이용한 강제적으로 수행하는 형변환이다.

자동 형변환의 조건과 정반대인 경우 강제 형변환을 사용한다.

/* ====== 큰 자료형에서 작은 자료형으로 변경 시 강제 형변환이 필요하다. ====== */
/* 1. 정수 끼리의 강제 형변환 */
long lNum = 8;
//int iNum = lNum; // 데이터 손실 가능성을 컴파일러가 알려준다. (에러남)
int iNum = (int) lNum; // 변경하려는 자료형을 명시하여 강제 형변환을 해야 함
short sNum = (short) iNum;
byte bNum = (byte) sNum;
/* 2. 실수 끼리의 강제 형변환 */
double dNum = 8.0;
//float fNum = dNum; // 데이터 손실 가능성을 컴파일러가 알려준다. (에러남)
float fNum = (float) dNum;
System.out.println(fNum);


/* ====== 실수를 정수로 변경 시 강제 형변환이 필요하다. ====== */
float fNum2 = 4.0f;
//long lNum2 = fNum2; // float는 4byte, long은 8byte임에도 자동 형변환 불가능 (소수점 자리 이하 데이터 손실 가능성)
long lNum2 = (long) fNum2; // 강제 형변환의 의미는 '내가 데이터 손실을 감안할테니 형변환 해줘~' 라는 의미이다.


/* ====== 문자형을 int미만 크기의 변수에 저장할 때 강제 형변환이 필요하다. ====== */
char ch = 'a';
byte bNum2 = (byte) ch; // 당연히 char 자료형보다 작은 크기이니 강제형변환을 해야한다.
short sNum2 = (short) ch; // 같은 2byte이지만 부호비트(sign bit)로 인한 값의 범위가 다르기 때문에 강제 형변환을 해 주어야 한다.
/* 추가적으로 정수를 char 자료형에 강제 형변환해서 대입하기 테스트 */
int num1 = 97;
int num2 = -97;
char ch2 = (char) num1;
char ch3 = (char) num2; // 음수도 강제 형변환 하면 대입할 수 있다.
System.out.println("ch2 : " + ch2);
System.out.println("ch3 : " + ch3);


/* ====== 논리형은 강제 형변환 규칙에서도 제외된다. ====== */
boolean isTrue = true;
// byte b = (byte) isTrue;
// short s = (short) isTrue;
// int i = (int) isTrue;
// float f = (float) isTrue;
// double d = (double) isTrue;
// char c = (char) isTrue;

 

✅ 자동 형변환과 강제 형변환을 이용한 연산

1. 서로 다른 자료형끼리의 연산

/* 다른 자료형 끼리 연산은 큰 자료형으로 자동 형변환 후 연산 처리 된다. */
int iNum = 10;
long lNum = 100;

/* 자바에서는 같은 자료형끼리만 연산이 가능하다.
* 따라서 서로 자료형이 다른 두 자료를 연산할 때 자료형이 같아지도록 형변환을 해 주어야 한다.
*/
/* 방법1. 두 수의 연산 결과를 int 형으로 변환 후 int 자료형 변수에 리턴받는다. */
//int iSum = iNum + lNum; // 그냥은 안된다. 두 자료형의 연산 결과는 큰 쪽 자료형인 long이 되고, long형 값은 int형 변수에 담길 수 없다.
int iSum = (int) (iNum + lNum);
System.out.println("iSum : " + iSum);

/* 방법2. long 형 값을 int로 강제 형변환 한다. */
int iSum2 = iNum + (int) lNum;
System.out.println("iSum2 : " + iSum2);

/* 방법3. 결과 값을 long형 자료형으로 받는다(자동 형변환 이용) */
long lSum = iNum + lNum;
System.out.println("lSum : " + lSum);

2. 형변환을 이용한 연산 시 주의사항

/* 주의! int 미만의 연산의 처리 결과는 int형 이다. */
byte byteNum1 = 1;
byte byteNum2 = 2;
short shortNum1 = 3;
short shortNum2 = 4;
int result1 = byteNum1 + byteNum2;
int result2 = byteNum1 + shortNum1;
int result3 = shortNum1 + byteNum1;
int result4 = shortNum1 + shortNum2;
System.out.println("result1 : " + result1);
System.out.println("result2 : " + result2);
System.out.println("result3 : " + result3);
System.out.println("result4 : " + result4);

3. 의도하지 않은 데이터 손실

출처: fakerdeft

int iNum = 290;
byte bNum = (byte) inum;
System.out.println("iNum : " + iNum);
System.out.println("bNum : " + bNum); // 비트 앞부분 손실로 예측 어려움

4. 의도한 데이터 손실

double height = 175.5;
int floorHeight = (int) height;
System.out.println("height : " + height);
System.out.println("floorHeight : " + floorHeight); // 소수점 절삭에 이용할 수 있다.