8/1 JAVA - 자바의 기본 데이터 타입
[자바의 기본 데이터 타입 8가지]
* 1. 기본 데이터타입(8가지)
---------------------------------------------------------------------------------
* 1Byte(8bit) 2Byte(16bit) 4Byte(32bit) 8Byte(64bit)
---------------------------------------------------------------------------------
* 논리형 boolean
* 정수형 byte short int long
* 실수형 float double
* 문자형 char
---------------------------------------------------------------------------------
[JAVA 0801]
char 타입과 byte & short 타입 간의 관계
- byte 타입 (1Byte = 8bit) : - 128 ~ + 127
- short 타입 (2Byte = 16bit) : - 32768 ~ + 32767
- char 타입 (2Byte - 16bit) : 0 ~ 65535
- char 타입의 경우 문자 표현을 위해 양수로만 표현하므로 byte 타입과 short 타입에 비해 양수 표현 범위가 크다.
또한, byte 타입과 short 타입은 음수까지 표현이 가능하므로 char 타입에 비해 음수 표현 범위가 크다.
=> 따라서, char 타입과 byte 또는 short 타입 양방향 간에는 자동 형변환이 지원되지 않으며, 반드시 강제 형변환 필수!
package type_conversion;
public class Ex2 {
public static void main(String[] args) {
byte b = 100;
short s = 65;
char ch;
// byte 타입 -> char 타입으로 변환
// ch = b; // 오류 발생! byte <-> char 명시적 형변환(강제형변환) 필수!
ch = (char)b; //char 타입으로 강제 형변환
System.out.println(ch);
//a = 97 , b = 98 , c = 99 , d = 100
//char 타입 -> byte 타입으로 변환
// b = ch; // 오류 발생! byte <-> char 명시적 형변환 필수!
b = (byte)ch; // byte 타입으로 강제 형변환
System.out.println(b);
System.out.println("------------------------------------------");
// short 타입 -> char 타입으로 변환
// ch = s; // 오류 발생! short <-> char 명시적 형변환이 필요함.
ch = (char)s; // char 타입으로 강제 형변환
System.out.println(ch);
// char 타입 -> short 타입으로 변환
// s = ch; // 오류 발생! short <-> char 명시적 형변환 필수!
s = (short)ch; // short 타입으로 강제 형변환
System.out.println(s);
System.out.println("==========================================");
}
}[operator : 연산자]
package operator;
public class Ex {
public static void main(String[] args) {
/*
* 산술연산자(+, -, *, /, %)
* - 일반적인 사칙연산과 동일
* - % 연산자 : 나머지 연산자 (또는 퍼센트 연산자)라고 하며,
* 나눗셈 결과에 대한 나머지를 계산하는 연산자
* (/ 연산자는 나눗셈 결과에 대한 몫을 계산하는 연산자)
*
*/
// 출력문에 연산식을 기술하면 연산 결과를 출력
System.out.println(10 + 2); // 10 + 2 결과인 12 출력됨
System.out.println(10 - 2); // 10 - 2 결과인 8 출력됨
System.out.println(10 * 2); // 10 * 2 결과인 20 출력됨
System.out.println(10 / 2); // 10 / 2 결과인 5 출력됨
System.out.println(10 % 2); // 10 / 2 결과의 나머지인 0이 출력됨
System.out.println("-----------------------------------------");
// int형 변수 a에 10을 저장하고, b에 2를 저장
int a = 10, b = 2; //같은 데이터타입이면 한줄에 여러개 적을 수 있음)
System.out.println(a + b); // 10 + 2 결과인 12 출력됨
System.out.println(a - b); // 10 - 2 결과인 8 출력됨
System.out.println(a * b); // 10 * 2 결과인 20 출력됨
System.out.println(a / b); // 10 / 2 결과인 5 출력됨
System.out.println(a % b); // 10 / 2 결과의 나머지인 0이 출력됨
}
}연산 결과를 변수에 저장 후 출력
int c; // 연산 결과를 저장할 변수 c 선언
// a 와 b의 덧셈 결과를 변수 c에 저장
c = a + b;
System.out.println(a);
System.out.println(a + " + " + b + " = " + c);
System.out.printf("%d + %d = %d\n", a,b,c);
c = a-b;
System.out.println(a + " - " + b + " = " + c); // 10 - 2 = 8
System.out.printf("%d - %d = %d\n", a,b,c);
c = a * b; // 곱셈
System.out.println(a + " * " + b + " = " +c); // 10 * 2 = 20
c = a / b; // 나눗셈(몫)
System.out.println(a + " / " + b + " = " + c); // 10 / 2 = 5
c = a % b; // 나눗셈(나머지)
System.out.println(a + " % " + b + " = " + c); // 10 % 2 = 0산술 연산 시 자동 형변환
* - 연산 수행 시 피연산자(항)끼리의 데이터타입을 일치시킨 후 연산을 수행
* 규칙 1) int 타입 보다 작은 타입 (byte, short, char)끼리의 연산은 모두 int 타입으로 변환 후 연산을 수행
* => 즉, 결과값이 무조건 int 타입이 됨
* ex) byte + byte = (int) byte + (int) byte = int + int = int
* ex2) char + int = (int)char + int = int + int + int
* 규칙 2) int 타입보다 큰 타입과의 연산은 큰 타입으로 변환 후 수행
* => 즉, 결과값이 무조건 큰타입이 됨
* ex) int + long = (long)int + long = long + long
* ex2) long + float = (float)long + float = float + float = float
byte b1 = 10;
byte b2 = 20;
byte b3;
b1 과 b2 의 연산 결과를 byte 타입 변수 b3에 저장 할 때 문제 발생!
b3 = b1 + b2; // 오류 발생! byte + byte = int + int + int 이므로
=> Type mismatch : cannot convert from int to byte
=> 저장하려는 변수 데이터타입이 byte 라서 문제가 발생!
=> int 타입을 byte 타입으로 저장하려면 강제 형변환(byte)필요
b3 = (byte)b1 + (byte)b2;다시 각 각 int 로 변환되므로 또 오류 발생!
=> (int)(byte)b1 + (int)(byte)b2 = (int)b1 + (int)b2 => int
연산 결과에 형변환 연산자를 적용하여 byte 타입으로 변환해야한다!
b3 = (byte)(b1 + b2);// (int)byte + (int)byte = (byte)int = byte
//연산 결과에 형변환 연산자를 적용하여 byte 타입으로 변환해야한다!
b3 = (byte)(b1 + b2); // (int)byte + (int)byte = (byte)int = byte
System.out.println(b3);
//short s = b1 + b2; //오류 발생! byte + byte = int + int = int 이므로
// short 타입 변수 s 에 저장 (자동 형변환) 불가!
short s = (short)(b1+b2);char ch = 'A';char 타입 변수 ch2에 ch 값에 2를 더한 결과를 저장
char ch2 = ch + 2; //오류 발생! char + int = (int)char + int 이므로
=> 결과값이 int가 되어 char 타입 변수에 저장 불가!
char ch2 = (char)(ch+2); // 연산 결과를 char 타입으로 변환
=> 'A' + 2 = 65 + 2= 67 이므로 결과 값이 char 타입으로 변환하면
=> 67에 해당하는 문자 'C' (67을 char 타입으로 변환한 데이터)가 저장됨
System.out.println(ch2); => C 출력
System.out.println(ch + 2);=> 67 출력 ch(65) + 2 = int
=> ch='A'라는 값을 가지고 있었는데, int로 변환했더니 65라는 값을 가짐
=> ch='A' -> int(65) + 2 = 67
=> ch + 2 의 결과값은 int형이므로 문자 'C' 대신 67 출력
=> 이 결과값을 다시 char 타입으로 변환하면 문자 'C'가 출력 됨
System.out.println((char)(ch + 2));=> C 출력 됨
int i = 100;
long l = 200;int 형 변수 i2 에 i + l 결과값을 저장
int i2 = i + l; // int + long = long 이므로 int 타입 변수에 저장 불가
int i2 = (int)(i + l); // int 타입으로 강제형변환
System.out.println(i2);
//300 나옴float f = 3.14;오류발생!
3.14는 더블데이터타입의 3.14니까 float 타입에 못 넣는다
float f = (float)3.14;오류 발생 x
일일이 넣기 힘들다면, 숫자 뒤에 f 만 붙이면 됨 => float f = (float)3.14
float f = 3.14f;
long + float 은 float 이므로, long 으로 변환
System.out.println(l2); // 203 나옴 . 원래는 203.14이지만 정수만 쓰는 것
long l2 = (long)(l + f);System.out.println(3 / 2);
나눗셈 연산은 몫을 계산하며, int / int = int가 되어 3/2 의 연산 결과는 정수 1이 출력이 된다.
만약, 3/2 결과를 1.5의 결과값으로 얻고 싶을 경우, 정수가 아닌 실수 형태의 나눗셈 연산으로 연산을 수행해야 함.
따라서, 최소한 피연산자 중 하나를 실수로 변환 후 연산을 수행.
=> 규칙 2)에 의해서 int형 보다 큰 데이터 타입을 따라감
System.out.println((double)3 / 2);
=> double / int => double
System.out.println(3/2.0); int / double => double
=> 주로, 수치 데이터는 .0을 붙여서 실수로 변환하고
실수형 변수는 형변환 연산자로 변환을 한다.
실수 끼리의 연산 (flaot 과 double 간의 연산)
float f1 = 0.1f;
double d1 = 0.1;
System.out.println(d1);
System.out.println(f1 + d1);
float => double 로 변환하여 double + double = double 이 된다.
따라서, 0.1f + 0.1 = 0.1 + 0.1 = 0.2 인데,
근사치 표현에 의해 잘못된 결과가 발생 할 수 있다!
=> double -> float 타입으로 강제 변환 후 연산을 수행하거나
두 실수 모두 정수로 변환하여 연산 수행 후 다시 실수로 변환
System.out.println(f1 + (float)d1);
System.out.println((int)((f1*10) + (int)(d1*10)) /10.0);
리터럴끼리 연산 시에는 자동 형변환이 발생하지 않는다!
byte b4 = 10 + 20; // byte 타입 범위 내의 정수는 byte 타입 그대로 연산
System.out.println(b4);
단, 리터럴끼리의 연산이라도 표현 가능 범위를 초과하면 오류 발생
byte b5 = 10 + (byte) 200;
byte 타입 범위 (-128 ~ 127) 를 초과하므로 int 로 취급 됨
문자열에 대한 덧셈연산자(+) = 연결(결합)연산자
* - 어떤 데이터를 문자열과 덧셈연산자로 연산할 경우
* 산술연산의 덧셈이 아닌 단순 문자열 결합(연결)으로 사용됨
* 이 때, 어떤 데이터를 문자열 타입으로 변환하여 두 문자열을 연결
* ex) "문자열" + "문자열" = "문자열문자열"
* int + "문자열" = "int" + "문자열" = "int문자열"
*
*
*
*
*/
int a = 10, b = 20;
System.out.println(a + b); // 일반 산술연산(덧셈 기능)
System.out.println("a = " + a); //"문자열 + 정수 = "문자열정수"
String str = "a =" + a;
System.out.println(str);
System.out.println("b = " + b); // "b = " + 20 = "b = 20"
int c = a + b;
System.out.println(a + " + " + b + " = " + c);
// 1. a + " + " 를 수행하여 "10 + " 문자열 생성
// 2. "10 + " 문자열과 + b 를 수행하여 "10 + 20" 문자열 생성
// 3. "10 + 20" 문자열과 + " = " 를 수행하여 "10 + 20 = " 문자열 생성
// 4. "10 + 20 = " 문자열과 + C 를 수행하여 "10 + 20 = 30" 문자열 생성
System.out.println("덧셈결과 : " + c);
System.out.println(10 + 20); // 30(일반 산술연산 = 덧셈)
System.out.println(10 + "20"); // "1020" 문자열 결합
System.out.println("10" + 20); // "1020" 문자열 결합
System.out.println(10 + "20" + 30); // 102030
System.out.println("10" + 20 + 30); // 102030
System.out.println(10 + 20 + "30"); // 3030
=> 10 + 20 덧셈을 먼저 수행하여 정수 30이 되고,
정수 30과 문자열 "30"을 결합하여 "3030" 문자열이 됨
String 타입 변수 name 에 자신의 이름을 저장
int 타입 변수 age 에 자신의 나이를 저장
String name = "강진석";
int age = 20;
// 주민번호 표현 시
// int jumin = 901010-1234567; // 결과 값 잘못 됨. => 뺄셈으로 취급 됨.
// int jumin = 9010101234567; // 오류 발생! int 타입으로 표현 불가능함
// long jumin = 9010101234567L; // long 타입으로 표현하거나,
String jumin = "901010-1234567";
이름 : 강진석
나이 : 20
주민번호 : 901010-1234567
System.out.println("이름 : " + name);
System.out.println("나이 : " + age);
System.out.println("주민번호 : " + jumin);