참조 타입이란 객체의 주소를 참조하는 타입으로 배열, 열거, 클래스, 인터페이스를 뜻함 기본 타입은 실제 값을 변수 안에 저장하지만, 참조 타입은 메모리의 주소를 변수 안에 저장한다. 주소를 통해 객체를 참조한다는 뜻에서 참조 타입이라고 부른다.
기본 타입 변수
참조 타입 변수
int age = 25; double price = 100.5;
String name = "ReBugs"; String hobby = "프로그래밍";
String은 클래스의 일종이다
위의 그림에서 보는 것과 같이 기본타입 변수는 직접 값을 저장하고 있지만, 참조 타입 변수는 힙 영역의 String 객체 주소값을 가지고 있다. 이처럼 주소를 통해 객체를 참조하기 때문에 String 클래스 변수를 참조 타입 변수라고 한다.
메모리 사용 영역
JVM은 운영체제에서 할당받은 메모리 영역을 다음과 같이 세부 영역으로 구분해서 사용함
메소드 영역
JVM이 시작할 때 생성되고 모든 스레드가 공유하는 영역
바이트코드 파일의 내용이 저장되는 영역
코드에서 사용되는 클래스들을 클래스 로더로 읽어 클래스별로 정적 필드와 상수, 메소드 코드, 생성자 코드 등을 분류해서 저장함.
그림상에는 메소드 영역 내부 클래스에 정적 필드와 정적 메소드 밖에 없지만, 인스턴스 메소드, 생성자 코드도 있다.
힙 영역
힙 영역은 객체와 배열이 생성되는 영역.
여기에 생성된 객체와 배열은 JVM 스택 영역의 변수나 다른 객체의 필드에서 참조함.
만일 참조하는 변수나 필드가 없다면 의미 없는 객체가 되기 때문에 JVM이 이것을 쓰레기로 취급하고 Garbage Collector를 실행시켜 자동으로 제거함. 따라서 개발자는 객체를 제거하기 위해 별도로 코드를 작성할 필요가 없음.
자바는 이 때문에 객체를 직접 제거하는 방법을 제공하지 않음
JVM 스택 영역
여기에서 기본 타입 변수와 참조 타입 변수가 생성되고 제거된다.
JVM 스택은 메소드를 호출할 때마다 프레임을 추가(push)하고, 메소드가 종료되면 해당 프레임을 제거(pop)하는 동작을 수행
프레임 내부에는 로컬 변수 스택이 있는데, 기본 타입 변수와 참조 타입 변수가 추가되거나 제거된다.
스택 영역에 변수가 생성되는 시점은 초기화가 될 때, 즉, 최초로 변수에 값이 저장될 때임
변수는 선언된 블록 안에서만 스택에 존재하고 블록을 벗어나면 스택에서 제거됨
JVM 스택 영역 아래는 main함수 내에서 함수의 호출이 이뤄졌으므로 메인 스레드에서 프레임이 생성된다. 스레드 n에서 함수의 호출이 이뤄지면 스레드-n에서 프레임이 생성된다.
다음과 같이 배열 변수인 scores는 스택 영역에 생성되지만 실제 10, 20, 30을 갖는 배열은 힙 영역에 생성됨. 배열 변수인 scores에는 배열의 힙영역의 주소가 저장됨. 참고로 자바에서는 배열을 객체로 취급함
int[] scores = {10, 20, 30};
정리하자면 메소드가 호출되면 JVM스택에는 프레임이 들어가고 프레임 안에는 여러 변수가 있다. 기본 타입의 경우는 변수 자체에 저장되지만, 참조 타입은 힙 영역에 객체로 생성되며 변수는 힙 영역에 생성된 객체의 주소값을 참조하고 있다. 메소드가 종료되면 JVM 스택에서 프레임이 제거된다. 힙 영역에서 객체를 참조하는 변수가 하나도 없다면 Garbage Collector가 객체를 수거한다.
참조 변수의 ==, != 연산
참조 타입 변수들 간의 ==, != 연산은 동일한 객체를 참조하는지, 다른 객체를 참조하는지 알아볼 때 사용됨 참조 타입 변수의 값은 힙 영역의 객체 주소이므로 ==, != 연산은 결국 주소 값을 비교하는 것이 됨 동일한 주소값을 갖고 있다는 것은 동일한 객체를 참조한다는 의미 반대로 다른 주소값을 갖고 있다는 것은 다른 객체를 참조한다는 의미
null과 NullPointerException
참조 타입 변수는 힙 영역의 객체를 참조하지 않는다는 뜻으로 null값을 가질 수 있음. null값도 초기값으로 사용할 수 있기 때문에 null로 초기화된 참조 변수는 스택 영역에 생성됨 참조 변수가 만약 null을 가지고 있을 경우, 참조 객체가 없으므로 변수를 통해 객체를 사용할 수 없음. 따라서 만약 null 상태에서 있지도 않은 객체의 데이터나 메소드를 사용하는 코드를 실행하면 NullPointerException이 발생함
문자열을 String 변수에 저장한다는 말은 엄밀히 말해 틀린 표현이다. 문자열이 직접 변수에 저장되는 것이 아니라, 문자열은 String 객체로 생성되고 변수는 String 객체를 참조하기 때문 자바는 문자열 리터럴이 동일하다면 String 객체를 공유하도록 되어 있음 다음과 같은 경우는 동일한 String 객체를 참조하게 됨
String A = "ReBugs";
String B = "ReBugs";
일반적으로 변수에 문자열을 저장할 경우에는 문자열 리터럴을 사용하지만, new 연산자를 사용해서 직접 String 객체를 생성시킬 수도 있음 new 연산자는 힙 영역에 새로운 객체를 만들 때 사용하는 연산자로 객체 생성 연산자라고 함
String A = new String("ReBugs");
String B = new String("ReBugs");
이 경우는 A와 B는 서로 다른 객체를 참조하고 있다.
따라서 동일한 String 객체이건 다른 String 객체이건 상관없이 내부 문자열을 비교하고 싶을 때는 String 객체의 equals()메소드를 사용해야 함 equals() 메소드는 원본 문자열과 매개값으로 주어진 비교 문자열이 동일한지 비교한 후 true 또는 false를 리턴함
연산식은 반드시 하나의 값을 산출한다. 연산자 수가 아무리 많아도 2개 이상의 값을 산출하는 연산식은 없다.
값 대신에 연산식을 사용할 수 있다.
부호 연산자에서 주의해야 할 점 부호 연산자의 결과가 int 타입이라는 점이다. 예를 들어 byte 타입 변수를 부호 연산하면 int 타입으로 변환된다. byte b = 100; byte b = -b; -> 컴파일 에러 발생, 오버 플로 int b = -b; -> 옳은 문법
package TestPakage;
public class Test {
public static void main(String[] args) {
int x = -100;
int result1 = +x;
int result2 = -x;
System.out.println("result1=" + result1);
System.out.println("result2=" + result2);
byte b = 100;
//byte result3 = -b; //int를 byte에 담으려고 하므로 오버플로
int result3 = -b;
System.out.println("result3=" + result3);
}
}
/*
result1=-100
result2=100
result3=-100
*/
증감 연산자
연산식
설
명
++
피연산자
다른 연산을 수행하기 전에 피연산자의 값을 1 증가시킴
--
피연산자
다른 연산을 수행하기 전에 피연산자의 값을 1 감소시킴
피연산자
++
다른 연산을 수행한 후에 피연산자의 값을 1 증가시킴
피연산자
--
다른 연산을 수행한 후에 피연산자의 값을 1 감소시킴
연산식에 증감 연산자만 사용된다면 증감 연산자의 위치는 상관없다 하지만 다른 연산자와 함께 사용된다면 증감 연산자의 위치에 따라 연산식의 결과가 다르게 나온다.
증감 연산자가 변수 앞에 있으면 우선 변수 값을 1증가 또는 1감소시킨 후에 다른 연산자를 처리한다. 반면 증감 연산자가 변수 뒤에 있으면 다른 연산자를 먼저 처리한 후 변수 값을 1증가 또는 1감소시킨다.
package TestPakage;
public class Test {
public static void main(String[] args) {
int x = 10;
int y = 10;
int z;
System.out.println("-----------------------");
x++;
++x;
System.out.println("x=" + x); // 12
System.out.println("-----------------------");
y--;
--y;
System.out.println("y=" + y); // 8
System.out.println("-----------------------");
z = x++;
System.out.println("z=" + z); // 12
System.out.println("x=" + x); // 13
System.out.println("-----------------------");
z = ++x;
System.out.println("z=" + z); // 14
System.out.println("x=" + x); // 14
System.out.println("-----------------------");
z = ++x + y++;
System.out.println("z=" + z); // 15 + 8
System.out.println("x=" + x); // 15
System.out.println("y=" + y); // 9
}
}
/*
-----------------------
x=12
-----------------------
y=8
-----------------------
z=12
x=13
-----------------------
z=14
x=14
-----------------------
z=23
x=15
y=9
*/
-피연산자들이 byte, short, char 타입일 경우 모두 int 타입으로 변환된 후에 연산을 수행 -피연산자들이 모두 정수 타입이고 long 타입이 포함되어 있을 경우, 모두 long 타입으로 변환된 후 연산을 수행 -피연산자 중 실수타입이 있을 경우, 값의 범위가 큰 실수 타입으로 변환된 후 연산을 수행
비교 연산자에서도 연산을 수행하기 전에 피연산자의 타입을 일치시킨다 예를 들어, 'A' == 65는 'A'가 int 타입으로 변환되어 65 = 65로 비교한다. 하지만 한 가지 예외가 있는데, 0.1 == 0.1f와 같은 경우이다. 정상적이라면 0.1f가 왼쪽 피연산자와 같은 double 타입으로 변환되어 0.1 == 0.1이 되고 true가 산출되어야 하지만, 이 결과 값은 false가 산출된다. 0.1 == 0.1f -> false 그 이유는 실수의 저장 방식인 부동 소수점 방식이 0.1을 정확히 표현할 수 없기 때문이다. 0.1f는 0.1의 근사값으로 표현되기 때문에 0.1보다 큰 값이다.
논리 연산자 AND(논리곱) / && 또는 & : 피연산자 모두가 true일 경우에만 연산 결과가 true OR(논리합) / || 또는 | : 피연산자 중 하나만 true이면 연산 결과는 true XOR(배타적 논리합) / ^ : 피연산자가 하나는 true이고 다른 하나가 false일 경우에만 연산 결과가 true NOT(논리 부정) / ! : 피연산자의 논리값을 바꿈
단축평가(short circuit evaluation) &&와 &은 산출결과는 같지만 연산 과정이 조금 다르다. &&는 앞의 피연산자가 flase라면 뒤의 피연산자를 평가하지 않고 바로 false라는 산출 결과를 낸다. 그러나 &은 두 피연산자 모두를 평가해서 산출 결과를 낸다. 따라서 &보다 &&이 더 효율적으로 동작한다.
||과 |도 마찬가지이다. ||는 앞의 피연산자가 true라면 뒤의 피연산자를 평가하지 않고 바로 true라는 산출 결과를 낸다. 그러나 |는 두 피연산자 모두 평가를 해서 산출결과를 낸다 따라서 |보다 ||가 더 효율적으로 동작한다.
이처럼 논리 연산의 식 전체의 평가가 단축되는 것을 단축평가라고 한다.
삼항연산자 삼항 연산자는 ? 앞의 조건식에 따라 콜론 앞뒤의 피연산자가 선택된다고 해서 조건 연산식이라고 부르기도 함
계산 결과가 BCD코드를 벗어날 때, 즉, 9(1001)를 초과하는 경우 계산 결과에 6(0110)을 더해준다.
EX) 69 + 85를 BCD로 바꾸어 연산한 결과는?
10의 자리와 1의 자리 모두가 9를 초과하므로 계산 결과에 0110 0110을 더해주면 된다.
3초과 코드
BCD코드로 표현된 값에 3을 더해 준 값으로 나타내는 코드
자기 보수의 성질을 갖는다.
10진수
BCD 코드
3초과 코드
0
0000
0011
1
0001
0100
2
0010
0101
3
0011
0110
4
0100
0111
5
0101
1000
6
0110
1001
7
0111
1010
8
1000
1011
9
1001
1100
EX) 10진수 13을 3초과 코드로 변환해라
10의 자리 0001 -> 3초과 코드 0100
1의 자리 0011 -> 3초과 코드 0110
따라서 13의 3초과 코드는 0100 0110
자기 보수 코드(Self Complementary Code) 스스로 보수를 만드는 코드란 뜻이다 위의 표에서 3초과 코드의 각 자리의 0을 1로, 1을 0으로 바꿔보자(1의 보수를 취해보자) 10진수 0의 3초과 코드 0과 1을 뒤집어보면 1100이고, 이는 3초과 코드의 9이다. 10진수 1의 3초과 코드 0과 1을 뒤집어보면 1011이고, 이는 3초과 코드의 8이다 이렇게 계속해서 마지막인 10진수 4의 3초과 코드 0과 1을 뒤집어 보면 0111은 3초과 코드의 5이다. 즉, 합이 9가 되는 수끼리 서로 1의 보수관계를 갖는 코드가 자기 보수 코드이다. 이 때문에 오류를 검출할 수 있는 능력이 생긴다. 자기 보수 코드는 3초과 코드, 8421 코드, 2421 코드, 51111 코드 등이 있다.
flags(-,+)에 -를 넣으면 오른쪽이 공백으로 채워짐, + 또는 생략을 하면 왼쪽이 공백으로 채워짐
전체 자릿수(width)는 표현할 전체 자릿수를 뜻함
소수 자릿수(.precision)는 소수점 이하 몇째 자리까지 표현할 것인지를 뜻함
%와 변환 문자 외에 다 생략할 수 있다.
형식화된 문자열
설명
출력 형태
정수
%d %6d %-6d %06d
정수 6자리 정수, 왼쪽 빈 자리 공백 6자리 정수, 오른쪽 빈 자리 공백 6자리 정수, 왼쪽 빈자리 0으로 채움
123 ___123 123___ 000123
실수
%10.2f %-10.2f %010.2f
소수점 이상 7자리, 소수점 이하 2자리, 왼쪽 빈 자리 공백 소수점 이상 7자리, 소수점 이하 2자리, 오른쪽 빈 자리 공백 소수점 이상 7자리, 소수점 이하 2자리, 왼쪽 빈 자리 0 채움
____123.45 123.45____ 0000123.45
문자열
%s %6s %-6s
문자열 6자리 문자열, 왼쪽 빈 자리 공백 6자리 문자열, 오른쪽 빈자리 공백
abc ___abc abc___
특수 문자
\t \n %%
탭(tab) 줄 바꿈 %
%
public static void main(String[] args) {
int value = 123;
System.out.printf("%d\n", value);
System.out.printf("%6d\n", value);
System.out.printf("%-6d\n", value);
System.out.printf("%06d\n", value);
double area = 3.14159 * 10 * 10;
System.out.printf("반지름이 %d인 원의 넓이:%10.2f\n", 10, area);
String name = "홍길동";
String job = "도적";
System.out.printf("%6d | %-10s | %10s\n", 1, name, job);
}
// 123
// 123
//123
//000123
//반지름이 10인 원의 넓이: 314.16
// 1 | 홍길동 | 도적
시스템 입력
System.in.read()의 단점이 너무 치명적이고 불편하기에 생략한다
여기서는 스캐너만 다루겠다.
Scanner scanner = new Scanner(System.in); Scanner scanner는 Scanner 타입의 변수 scanner를 선언 new Scanner(System.in)는 입력을 받는 Scanner객체를 생성했다는 뜻 합쳐서 해석하면 Scanner타입의 scanner라는 변수가 새로 생성된 Scanner 객체를 가리키고 있다는 뜻 그냥 동적할당 했다는 뜻인것 같다.(C언어적 해석)(자바는 어차피 C++기반으로 만들어졌으니 상관없지 않을까?)
inputData = scanner.nextLine(); inputData라는 변수에 scanner변수가 가리키고 있는 객체의 nextLine()이라는 메소드 실행(이 또한 C언어적 해석) Scanner객체의 메소드엔 nextLine()이라는 메소드가 있는데, 이 메소드는 엔터키가 입력되기 전까지 대기 상태가 되며, 엔터키가 입력되면 입력된 모든 내용을 문자열로 읽고 리턴함
또한 Scanner를 이용하려면 모듈을 추가해야한다.
Scanner가 포함된 모듈을 추가하려면 패키지 선언과 클래스 선언 사이에 import문으로 선언해주면 된다.
또한 자바는 기본타입의 값이 동일한지 비교할 때는 ==를 사용하고, 문자열이 동일한지 비교할 때에는 equals()메소드를 사용한다.
위의 내용이 뭔 소리인지 이해가 안 간다면 아래의 예제를 보면 조금은 더 이해가 될 수 있다.
package TestPakage; //패키지 선언
import java.util.Scanner; //스캐너를 사용하기 위한 모듈 선언
public class Test { //클래스 선언
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); //스캐너 객체 동적 할당
String inputData;
while(true) {
inputData = scanner.nextLine(); //입력 받은 문자열 저장
System.out.println("입력된 문자열 : \"" + inputData + "\"");
if(inputData.equals("q")) { // 입력된 문자열이 q라면
break; // 반복문 탈출
}
}
System.out.println("종료");
}
}
/*
출력 결과
가나다라
입력된 문자열 : "가나다라"
마바사하
입력된 문자열 : "마바사하"
자차카타
입력된 문자열 : "자차카타"
파하
입력된 문자열 : "파하"
ㅂ
입력된 문자열 : "ㅂ"
q
입력된 문자열 : "q"
종료
*/
int a = 65;
char b = (char) a;
System.out.println(b); //A 출력
주의해야 할 점은 실수 타입은 정수타입으로 자동 변환되지 않기 때문에 강제 타입 변환을 사용해야 한다.
이 경우 소수점 이하 부분은 버려지고, 정수 부분만 저장된다.
double a = 3.14;
int b = (int) a;
System.out.println(a); // 3 출력
강제 타입 변환을 하게 되면 값이 손상될 수도 있고 안 될 수도 있다.
위 그림처럼 int 타입을 byte 타입으로 강제 타입 변환을 하려 할 때, byte의 허용 범위를 넘는 값이라면 값이 손상될 수 있다.
정수 연산에서의 자동 타입 변환
정수 타입 변수가 산술 연산식에서 피연산자로 사용되면 int보다 작은 자료형의 변수는 int로 자동 타입 변환되어 연산을 수행한다.
int보다 작은 자료형의 변수끼리의 연산
byte x = 10;
byte y = 20;
byte result = x + y; //컴파일 에러
int result = x + y; // x와 y는 int로 자동 타입 변환
위 코드에서 3번째 줄은 컴파일 에러가 나는데, 이는 연산을 컴파일 단계에서 하느냐 JVM이 하느냐 문제이다. 숫자 자체가 아니라 변수끼리의 연산은 JVM에서 연산을 하기 때문에 int 타입으로 변환되어 컴파일 에러(오버플로)가 난다.
컴파일 단계에서 연산 자바는 실행 성능을 향상시키기 위해 컴파일 단계에서 연산을 수행할 수 있다. byte a = 10 + 20; 위와 같은 연산은 정수 리터럴끼리 연산이어서 컴파일 단계에서 미리 연산해서 30을 만들고, result 변수에 30을 저장하도록 바이트 코드를 생성한다. 이 경우에는 피연산자가 변수가 아니므로 int 타입으로 변환을 하지 않는다.
특별한 이유가 없는 경우 정수 연산에서는 int형을 사용하는 것이 효율적이다. 왜냐하면 이유 없이 int형을 사용하지 않으면 형변환 단계가 쓸데없이 있기 때문.
정수 연산에서 모든 변수가 int타입으로 변환되는 것은 아니다. 두 피연산자 중 값의 범위가 큰 타입으로 변환되어 연산을 한다.
int 타입보다 값의 범위가 더 큰 long 타입이 피연산자로 사용되면 다른 피연산자는 무조건 long 타입으로 변환하고 연산을 수행한다.
public static void main(String[] args) {
byte a = 10;
int b = 100;
long c = 1000L;
long result = a + b + c; // a,b,c long으로 형 변환
System.out.println(result); // 1110 출력
}
실수 연산에서의 자동 타입 변환
int타입과 double 타입을 연산해도 동일한 과정을 수행한다. int형 피연산자가 double형으로 자동 변환되고 연산을 수행
int a = 10;
double b = 5.5;
double result = a + b; // a는 double로 형변환 되어 10.0 + 5.5
자바는 소문자f 또는 대문자 F가 없는 실수 리터럴을 double 타입으로 해석함. 그렇기 때문에 연산 결과는 double 타입 변수에 저장해야 함
float result = 1.5 + 2.3; // 컴파일 에러
//1.5와 2.3 모두 double 타입으로 해석하기 때문에 오버플로
꼭 float에 저장해야 한다면 컴파일러에게 float 타입임을 알려주자
float result = 1.5f + 2.3f;
수학에서 1을 2로 나누면 0.5가 정답이다. 하지만 코드를 짤 때 조심해야 한다.
int x = 1;
int y = 2;
double result = x / y;
System.out.println(result); // 0.0을 출력
위의 코드 실행결과는 0.0이다
왜냐하면 자바에서 정수끼리의 연산 결과는 정수가 되기 때문이다.
정상적으로 0.5를 출력하려면 정수 연산이 아니라 실수 연산으로 변경해야 한다.
즉, x와 y 둘 중 하나 또는 둘 모두 double 타입으로 변환해야 한다.
int x = 1;
int y = 2;
double result = (double) x / y;
System.out.println(result); // 0.5를 출력
만약 (double) (x / y)로 잘못 수정하면 0.5가 아니라 0.0을 얻는데 그 이유는 괄호 안의 연산이 먼저 수행되어서 다시 정수끼리 연산으로 처리되기 때문이다.
+ 연산에서의 문자열 자동 타입 변환
자바에서 + 연산자는 두 가지 기능을 제공함
피연산자가 모두 숫자일 경우에는 덧셈 연산 수행
피연산자 중 하나가 문자열일 경우에는 나머지 피연산자도 문자열로 자동 변환되어 문자열 결합 연산 수행
변수를 선언할 때 주어지는 타입에 따라 변수에 저장할 수 있는 값의 종류와 허용 범위가 달라진다
자바에서 타입에는 기본 타입과 참조 타입 두 개로 나눠지며, 오늘 다룰 내용은 기본 타입이다.
자바는 정수, 실수, 논리값을 저장할 수 있는 기본(primitive) 타입을 제공한다. 자바가 제공하는 기본 타입은 8개이다.
기본 타입은 4개(정수, 실수, 논리)로 나뉘어지며 각각 5개, 2개, 1개이다
정수형(byte, char, short, int, long)(5개)
실수형(float, double)(2개)
논리형(boolean)(1개)
타입
메모리 사용 크기
저장되는 값의 허용 범위
byte
1byte
8bit
-2^7 ~ 2^7-1
-128 ~ 127
short
2byte
16bit
-2^15 ~ 2^15-1
-32,768 ~ 32,767
char
2byte
16bit
0 ~ 2^16-1
0 ~ 65,535(유니코드)
int
4byte
32bit
-2^31 ~ 2^31-1
약 -21억 ~ 약 +21억
long
8byte
64bit
-2^63 ~ 2^63-1
약 -900경 ~ 약 +900경
boolean
1byte
8bit
true 또는 false
float
4byte
32bit
(+/-)1.4X10^-45 ~ (+/-)3.4X10^38
double
8byte
32bit
(+/-)4.9X10^-324 ~ (+/-)1.8X10^308
정수 리터럴 프로그래머에 의해 직접 입력된 값을 리터럴이라고 함, 입력된 리터럴 중에서 자바가 정수로 인식하는 경우는 우리가 흔히 사용하는 10진수와 2진수, 8진수 16진수가 있다. 2진수 : 0b 또는 0B로 시작하고 0과 1로 구성됨 0b1011 -> 11 0b10100 -> 20 8진수 : 0으로 시작하고 0~7 숫자로 구성됨 013 -> 11 0206 -> 134 16진수 : 0x 또는 0X로 시작하고 0~9 숫자와 A, B, C, D, E 또는 a, b, c, d, e로 구성됨 0xB3 -> 179 0x2A0F -> 10767
특이한 점은 기본적으로 컴파일러는 정수 리터럴을 int타입으로 간주한다는 점이다.
따라서 int타입의 허용범위를 초과할 경우 long 타입임을 컴파일러에게 알려줘야 한다.
컴파일러에게 long타입임을 알려주는 방법은 정수 리터럴 뒤에 소문자 l이나 대문자 L을 붙이면 된다.
long a = 10000000000; //컴파일 에러
long b = 10000000000L; //정상
또한 실수 리터럴을 기본적으로 double 타입으로 해석하기 때문에, 실수 리터럴을 float타입으로 저장하고 싶다면 리터럴 뒤에 소문자 f나 대문자 F를 붙여 컴파일러가 float 타입임을 알 수 있도록 해야 함
float a = 3.14; //컴파일 에러
float b = 3.14F; // 정상
알파벳 소문자 e 또는 대문자 E가 포함되어 있는 숫자 리터럴은 지수와 가수로 표현된 소수점이 있는 10진수 실수로 인식함 5e2 = 5.0 X 10^2 = 500.0 0.1e3 = 0.1 X 10^3 = 100.0 500e-2 = 500 X 10^-2 = 5.0
public static void main(String[] args) {
float a = 5e2F;
float b = 500e-2F;
System.out.println(a);
System.out.println(b);
}
위 코드의 실행결과는 500.0 5.0
문자 타입 char 타입은 문자 타입이라고도 한다. 하나의 문자를 작은따옴표(')로 감싼 것을 문자 리털이라고 한다. 문자 리터럴은 유니 코드로 변환되어 저장되는데, 유니코드는 세계 각국의 문자를 0~65535 숫자로 매핑한 국제 표준 규약이다. 자바는 이러한 유니코드를 저장할 수 있도록 char 타입을 제공한다.
public class Main{
public static void main(String[] args) {
char c1 = 'A';
char c2 = 65;
char c3 = '가';
char c4 = 44032;
System.out.println("c1 : " + c1);
System.out.println("c2 : " + c2);
System.out.println("c3 : " + c3);
System.out.println("c4 : " + c4);
}
}
/*
c1 : A
c2 : A
c3 : 가
c4 : 가
*/
참고로 char 타입의 변수에 어떤 문자도 대입하지 않고 단순히 초기화를 할 목적으로 공백이 아닌 빈 문자를 대입하면 컴파일 에러가 발생한다.
