1.1 이스케이프(Escape) 코드
· 이스케이프 코드는 문자열 안에서 탈출함을 뜻합니다.
· 역슬래쉬(\)가 붙은 문자를 사용합니다.
이스케이프 코드의 종류
| 이스케이프 문자 | 설명 |
| \t | 출력 시 탭만큼 띄움 (넓은 간격으로 띄어쓰기) |
| \n | 출력 시 줄바꿈(라인피드) (엔터 효과) |
| \r | 출력 시 캐리지 리턴 |
| \" | " 문자 포함 |
| \' | ' 문자 포함 |
| \\ | \ 문자 포함 |
| \u16진수 | 16진수 유니코드에 해당하는 문자 포함 |
\" 예시
· 나는 "자바"를 좋아합니다.
System.out.println("나는 \"자바\"를 좋아합니다.");1.2 실수 타입
· 실수는 소수점 표기가 가능합니다.
실수 타입의 종류
| float | double |
double : 대표적 실수 타입
실수 리터럴
· 소스 코드에서 소수점이 있는 실수는 10진수로 인식합니다.
ex) 0.25, -3.14
· 알파벳 e 또는 E가 포함된 숫자 리터럴은 지수 및 기수로 표현됩니다.
· 소수점 있는 10진수는 실수로 인식됩니다.
ex)
· e4 → 10의 4승 → 10000
· E-4 → 10의 마이너스 4승 → 0.0001
· 5e2 → 5.0 x 10의 2승 → 500.0
· 0.12E-2 → 0.12 x 10의 마이너스 2승 → 0.0012
· double 타입은 소수점 15자리 이하 표기가 가능합니다.
double rate = 12.33;
double d1 = 654.111;
double d2 = 35e-3; // 35.0 * 1/1000· 실수끼리도 연산이 가능합니다.
System.out.println(rate + rate); //실수끼리도 연산도 가능
System.out.println(d1 * d1);
System.out.println(d2 * d2);· float 타입에 실수를 저장할 때는 값 뒤에 f를 붙여줍니다.
float f1 = 12.33f; // float 타입에 실수를 저장할때는 뒤에 f를 붙여준다.
System.out.println(f1);1.3 논리 타입
· 참과 거짓을 의미하는 True와 fasle를 논리 리터럴(논리 타입의 값)로 사용합니다
· 대표적 논리 타입은 boolean입니다.
· True와 fasle은 예약어이기 때문에 변수명으로 사용할 수 없습니다.
boolean state = true;
boolean flag = false;
System.out.println(state);
System.out.println(flag);1.4 타입 변환
타입 변환의 종류
| 자동 타입 변환 | 강제 타입 변환 |
자동 타입 변환
· 값의 허용 범위가 작은 타입이 큰 타입으로 저장될 경우에 자동 타입 변환됩니다.
자동 타입 변환◀────┐
큰 타입 = 작은 타입
기본 타입의 허용 범위 순서
byte < short, char < int < long < float < double
· double 타입 변수 = int 타입 변수 (자동 타입 변환 가능)
ex) double 타입 변수 - 150.0 = int 타입 변수 - 150
· int 타입 변수 = double 타입 변수 (자동 타입 변환 불가능)
ex) int 타입 변수 - 150? 151? ≠ double 타입 변수 - 150.5
정수 타입(int) - 실수 타입(double) 간의 자동 타입 변환 관계
int num1 = 10; // 정수형
int num2 = num1; // 정수형
double num3 = num2; // 실수형(double) = 정수형(int) 자동 변환 가능int num4 = 30; // 정수형 변수
double num5 = 30.333; // 실수형 변수
// int num6 = 30.333; // 정수형 변수 = 실수형 변수 (자동 타입 변환 X , 정수 < 실수)
double num7 = 30; // 실수형 변수 = 정수형 변수 (자동 타입 변환 O)
double num8 = 30.0; // 실수형 변수 = 실수형 변수 (자동 타입 변환 O)
// int num9 = num5; // 정수형 변수 = 실수형 변수 (자동 타입 변환 X , 정수 < 실수)
// int num10 = num7; // 정수형 변수 = 실수형 변수 (자동 타입 변환 X , 정수 < 실수(num7 = 30.0))
// - double num7은 30.0 소수점이 포함된 30.0으로 인식실수 타입(float) - 실수 타입(double) 간의 자동 타입 변환 관계
// float f1 = 12.3; // 컴퓨터에서 실수의 값은 대표적인 타입인 double 타입으로 인식하기 때문에 float 타입의 값은 뒤에 f를 붙여야 합니다.
// 따라서 float 타입 = double 타입 (자동 타입 변환 X)
float f1 = 12.3f; // float 타입에는 값 뒤에 f를 붙여야 함
double d1 = f1; // double 타입 = float 타입 (자동 타입 변환 O)실수 타입(int) - 문자 타입(char) 간의 자동 타입 변환 관계
char c1 = '나'; // char 문자 하나를 담는다.
System.out.println(c1);
int i1 = c1; // int 타입 = char 타입 (자동 타입 변환 O)
// char 타입의 출신은 정수형 변수(유니코드)
// int 가 char보다 큼 (char < int)
강제 타입 변환
· 큰 허용 범위 타입을 작은 허용 범위 타입으로 쪼개어서 저장하는 것을 말합니다.
· 캐스팅 연산자로 괄호()를 사용하는데, 괄호 안에 들어가는 타입은 쪼개는 단위입니다.
강제 타입 변환 ◀───────────┐
작은 허용 범위 타입 = (작은 허용 범위 타입) 큰 허용 범위 타입
정수 타입(int) → 문자 타입(char) 간의 강제 타입 변환 관계
char c2 = '다'; // char 문자 1개 입력 시, ''작은 따옴표로 감싸야 합니다.
int i2 = c2; // 타입 비교 : 더 큰 int 타입 = 더 작은 char 타입 (자동 타입 변환 O)
int i3 = 45234; // '다'(문자)의 값이 45234(유니코드-정수)로 바뀝니다.
char c3 = (char)i3; // 작은 char = 큰 int 타입 (강제 타입 변환 O)
System.out.println(c3) // 45234(정수)에 해당하는 유니코드가 강제 변환되어 '낲'이라는 문자값이 출력실수 타입(double) → 정수 타입(int) 간의 강제 타입 변환 관계
double d2 = 123.123;
int i4 = (int)d2; // 작은 int 타입 = 큰 double 타입 (강제 타입 변환 O)
System.out.println(i4); // 소수점이 날라간 123이 출력
//(int는 정수형 타입이라 실수형의 소수점을 커버할 수 없다)
// double 을 int 로 강제 변환 시, 소수점 전체 버림 (0.123 데이터 손실)문자열 변환
· String → 숫자 변환
· 문자열이 숫자로 바꿀 수 있게 생겨야 합니다. (숫자+문자 섞여 있으면 안됩니다.)
ex) 변환 가능 : "12345" , "525.333" / 변환 불가능 : "155dda", "가나다33333"
문자열 타입(String) → 정수 타입(int) 간의 문자열 변환 관계
· 변환 코드 : Integer.parseInt(문자열 형태);
String str1 = "654";
int i6 = Integer.parseInt(str1); // Integer.parseint(str1); str1을 int로 변환
System.out.println("str1 의 값 : " + str1); // 문자와 숫자의 차이 : 연산할때 값에 붙기 유/무
System.out.println(str1 + 46); // "654"(문자열) + 46(숫자) = 65446
System.out.println("i6 의 값 : " + i6); // "654"(문자열)이 숫자로 변환되어 i6는 654라는 숫자로 변환
System.out.println(i6 + 46); // 654(숫자) + 46(숫자) = 700
int i7 = Integer.parseInt("123123");
// int i8 = Integer.parseInt("1aa22"); //"문자열"이 숫자 형태가 아니라서 불가능문자열 타입(String) → 실수형(double) 간의 문자열 변환 관계
· 변환 코드 : Double.parseDouble(문자열);
String str2 = "90.9";
double d4 = Double.parseDouble(str2); //str2를 double 타입으로 변환
System.out.println(d4); //d4의 값은 실수형으로 변환되어 90.9가 출력
double d5 = Double.parseDouble("99.99");
// double d6 = Double.parseDouble("99edfd.99") //숫자 형태가 아니라서 불가능
double d6 = Double.parseDouble("550"); // 숫자 550을 실수 550.0이라고 인식해서 가능
// int i8 = Integer.parseInt("122.222"); // 실수형을 int로 변환 불가숫자 → 문자열(String) 간의 변환 관계
· 변환 코드 : String.valueOf(바꿀값);
int i3 = 45234; // 정수형 숫자 45234
double d5 = Double.parseDouble("99.99"); // 문자열 "99.99"를 실수형 숫자 99.99로 변환
String str3 = String.valueOf(4214); // 정수형 숫자 4214를 문자열로
String str4 = String.valueOf(304.929); // 실수형 숫자 304.929를 문자열로
String str5 = String.valueOf(i3); // 정수형 변수 i3를 문자열로
String str6 = String.valueOf(d5); // 실수형 변수 d5를 문자열로
System.out.println(str3); // 문자열 4214
System.out.println(str4); // 문자열 304.929
System.out.println(str5); // 문자열 45234
System.out.println(str6); // 문자열 99.99
연산할 때의 타입 변환
· 연산에 참여한 타입들 중에 큰 타입으로 변환됩니다.
// 정수 대표 int
// 실수 대표 double
int a = 10;
int b = 20;
int c = a + b; // 10 + 20
byte d = 10;
byte e = 20;
// byte f = d + e; // 컴파일 에러 : 대표 int로 인식 ← (정수형)30 ← 숫자 10 + 숫자 20
// 작은 타입 byte = 큰 타입 int
// 연산에 참여한 타입들 중에 큰 타입으로 변환
int g = a + d; // 10 + 10 int + byte → int (int와 byte를 더하면 int가 된다.)
System.out.println(g);
double d1 = 1.9;
double d2 = 2.2;
double d3 = d1 + d2; // double + double → double (double끼리 더하면 double이 된다.)
// int i1 = d1 + d2; // double + double → double
double d4 = a + d1; // int + double → double (연산에 참여한 타입들 중에 큰 타입으로 변환했기 때문)
System.out.println(d4);
double d5 = a + b; // double 타입 = int타입 ← int + int
// 30 → 30.0 // d5 = 30.0
// 1) (int)double + double
// int i1 = (int)d1 + d2; // int타입 = double 타입 ← double + double
// int + double → double
// 2) (int)(double + double)
int i1 = (int)(d1 + d2);
//4(소수점 내림) int(4.1) ← 1.9 + 2.2 ← (d1 + d2)
// (int)double ← (double + double)
// 3) (int)double + (int)double
int i2 = (int)d1 + (int)d2;
// 3 1 + 2
// int + int → int
// 논리적 오류 : double 이 int로 바뀔 때 소수점이 날라가는 문제로 인해 데이터 손실로 이상이 생길 수 있음
//사용자의 의도에 따라 사용정수 타입(int) → 실수 타입(double) 간의 연산 관계
· 실수형 = 정수형 / 정수형 → 실수형이기 때문에 정수에 소수점이 추가됩니다.
· 실수형 = 정수형 / 실수형 ┐
· 실수형 = 실수형 / 정수형 │→ 연산에 참여 시, 큰 타입으로 변환되기 때문에 실수형이 됩니다.
· 실수형 = 실수형 / 실수형 ┘
int x = 1;
int y = 2;
double z = x / y ; // 실수형 = 정수형 / 정수형
// 0.0
System.out.println(z);
double z2 = 1 / 2;
// 정수 / 정수 → 정수
// int / int → int 0
// double 타입 = 0 (정수)
// 값은 0.0 (double이 실수이기 때문에 소수점이 추가된다)
System.out.println(z2);
//현재 연산 : 정수형 / 정수형
// 계산 결과가 0.5 가 되도록 실수형이 되도록
// 정수형 / 정수형 → 정수형 double z = x /y ;
// 정수형 / 실수형 → 실수형 double z = x / (double)y ;
// 실수형 / 정수형 → 실수형 double z = (double)x / y ;
// 실수형 / 실수형 → 실수형 double z = (double)x / (double)y ;
// 안되는 케이스 : (double)(x / y) 뒤늦게 변화하는 경우
// 이미 x / y 단계에서 소수점이 사라짐. 정수 / 정수 → 1 / 2 → 0.5 → 정수 0문자열 +연산
· 문자열에 +연산 시, 이어붙인 다음 해당 값이 문자열로 변환됩니다.
· 연산은 ()괄호가 아닌 이상, 앞에서 순서대로 진행됩니다.
· 숫자 + 숫자 + 문자열의 경우 숫자계산 이후 문자열이 붙습니다.
ex) 10 + 10 + "30" → 20 + "30" → 2030 (출력 시엔 2030으로 표시 되지만, 문자열의 형태로 변환된 상태입니다.)
· 문자열 뒤에 있는 숫자들은 모두 문자열이 됩니다.
ex) "10" + 20 + 30 → 102030
int num1 = 10;
int num2 = 20;
String s1 = "30";
System.out.println(num1 + num2); // 10+30 = 30
System.out.println(num1 + s1); // 10+"30" = "1030"
System.out.println("num1 : " + num1); // num1 : 10
int num3 = num1 + num2;
String s2 = s1 + num2; // String + int → "30" + 20 → "3020"
String s3 = String.valueOf(num1 + num2); // 결과가 int인데 String으로 만들고 싶으면
// 숫자 → 문자열 변환 코드 : String.valueOf(바꾸려는 숫자 변환명);
String s5 = num1 + num2 + "";
// 숫자 + 숫자 + 문자열
// 30 + "" = "30"
String s4 = num1 + num2 + s1; // 숫자 + 숫자 + 문자열 → 10 + 20 + "30"
// (10 + 20) + "30" → 3030 계산은 앞에서부터 계산된다.
System.out.println(s3);
System.out.println(s4);
System.out.println(num1 + num2 + s1); // int int String
// 10 + 20 + "30" → 3030
System.out.println(num1 + s1 + num2); // int String int
// 10 + "30" + 20 → "1030" + 20 → 103020
System.out.println(s1 + num1 + num2); // String int int
// "30" + 10 + 20 → "3010" + 20 → 301020
System.out.println(s1 + (num1 + num2) );
// "30" + (10 + 20) → "30" + 30 → 3030
