[자바의 값과 자료형]

개념

자바는 값을 다룰 때 먼저 값의 종류를 구분한다.
정수인지, 실수인지, 문자 하나인지, 참과 거짓인지에 따라 저장 방식과 연산 방식이 달라지기 때문이다.
이렇게 값의 종류를 구분하는 기준이 자료형(data type)이다.

1일차에서 먼저 익혀야 하는 대표 자료형은 아래와 같다.

• byte : 1바이트 정수형
• short : 2바이트 정수형
• int : 4바이트 정수형
• long : 8바이트 정수형
• float : 4바이트 실수형
• double : 8바이트 실수형
• char : 문자 1개
• boolean : 참 / 거짓
• String : 문자열

정수형은 크기에 따라 byte, short, int, long으로 나뉜다.
실수형은 float, double이 있다.
초반에는 정수는 int, 실수는 double을 기본으로 많이 사용한다고 이해하면 된다.

자료형은 단순히 이름표가 아니다.
어떤 값을 넣을 수 있는지, 어떤 결과로 출력되는지까지 결정한다.

예를 들어 아래는 가능하다.

int num = 10;
double rate = 3.14;
char ch = 'A';

---

하지만 아래는 자료형이 맞지 않아 에러가 난다.

int num = 3.4;    // 에러

int는 정수형인데 3.4는 실수이기 때문이다.
즉, 자바는 “숫자니까 다 같다”라고 보지 않고, 정수와 실수도 다르게 취급한다.

핵심 특징

• 자바는 타입이 엄격한 언어다.
• 값을 저장할 때 자료형이 맞아야 한다.
• 정수형은 byte, short, int, long으로 나뉜다.
• 실수형은 float, double이 있다.
• 보통 정수는 int, 실수는 double을 기본으로 많이 쓴다.
• 문자 하나는 char, 문자 여러 개는 String으로 다룬다.
• 같은 값이라도 어떤 자료형으로 다루느냐에 따라 결과가 달라질 수 있다.
  
  
  
  

코드 예제

예제: VariableTest2

int intV = 10;
double doubleV = 3.14;
char charV = 65;
String strV = "유니코";

System.out.println(intV);
System.out.println(doubleV);
System.out.println(charV);
System.out.println(strV);

// 출력결과
// 10
// 3.14
// A
// 유니코

이 예제는 자료형에 따라 같은 값도 다르게 보일 수 있다는 점을 보여준다.

• intV는 정수형이라 10
• doubleV는 실수형이라 3.14
• charV는 문자형이라 65를 문자 코드값으로 해석해 A
• strV는 문자열이라 유니코

즉, 자료형은 값을 담는 공간이면서 동시에 그 값을 어떻게 해석할지 정하는 기준이다.

헷갈리기 쉬운 부분

• char는 문자형이지만 숫자를 넣을 수도 있다.
• int와 double은 둘 다 숫자형이지만 같은 것이 아니다.
• int num = 3.4;처럼 정수형 변수에 실수를 넣으면 에러가 난다.
• String은 문자 여러 개를 다루는 타입이지 char와 같은 것이 아니다.
  
  
  
  

참고

String은 뒤에서 객체를 배울 때 더 자세히 다룬다.
지금은 문자 하나는 char, 문자 여러 개는 String이라고 먼저 구분하면 충분하다.

---

[리터럴과 출력]

개념

리터럴(literal)은 코드에 직접 적는 값이다.
변수에 저장하기 전, 코드 안에 그대로 써 놓은 값 자체를 말한다.

예를 들면 아래 값들은 모두 리터럴이다.

• 10
• -10
• 10.0
• 10.0f
• 10L
• true
• false
• 'A'
• "A"

자바는 이 값을 보고 자동으로 정수인지, 실수인지, 문자형인지, 문자열인지 판단한다.

여기서 중요한 기준이 하나 있다.

• 정수 리터럴은 기본적으로 int
• 실수 리터럴은 기본적으로 double

즉, 그냥 100이라고 쓰면 자바는 기본적으로 int로 해석한다.
3.14라고 쓰면 기본적으로 double로 해석한다.

그래서 큰 정수를 쓸 때는 주의해야 한다.
기본 int 범위를 넘는 큰 수는 그냥 쓰는 것이 아니라 L을 붙여 long 리터럴로 만들어야 한다.
또 실수 리터럴은 기본적으로 double로 해석되기 때문에, float로 표현하고 싶으면 뒤에 f를 붙여야 한다.

예를 들어 10.0은 double 실수 리터럴이고, 10.0f는 float 실수 리터럴이다.
즉, 눈에 보이는 숫자 모양이 비슷해도 자바가 해석하는 자료형은 다를 수 있다.

예제: LiteralTest2

System.out.println(10.0);
System.out.println(10.0f);
System.out.println(10L);

// 출력결과
// 10.0
// 10.0
// 10

이 예제에서 10.0은 기본 실수형인 double로 해석되고, 10.0f는 float 실수 리터럴로 해석된다.
또 10L은 long 정수 리터럴이다.

즉, 리터럴 뒤에 붙는 f, L은 단순한 장식이 아니라 이 값을 어떤 자료형으로 해석할지 지정하는 표시다.


출력은 보통 System.out.print()와 System.out.println()으로 한다.
둘 다 값을 보여주지만, println은 출력 후 줄을 바꾸고 print는 줄을 바꾸지 않는다.

문자열 안에서는 \n, \t처럼 특별한 기능을 하는 문자도 사용할 수 있다.
이런 문자를 이스케이프 문자라고 한다.

핵심 특징

• 리터럴은 코드에 직접 적는 값이다.
• 10은 정수 리터럴이다.
• 10.0은 실수 리터럴이다.
• 10.0f는 float 실수 리터럴이다.
• 10L은 long 정수 리터럴이다.
• 정수 리터럴은 기본적으로 int로 해석된다.
• 실수 리터럴은 기본적으로 double로 해석된다.
• println은 출력 후 줄바꿈을 한다.
• print는 출력만 하고 줄바꿈을 하지 않는다.
• \n은 줄바꿈, \t는 탭 기능을 한다.
  
  
  
  

코드 예제

예제: LiteralTest1

System.out.println(100);
System.out.println("100");
System.out.println(100 + 1);
System.out.println("100" + 1);

System.out.println(7777777777L);

// 출력결과
// 100
// 100
// 101
// 1001
// 7777777777

이 예제에서는 두 가지를 꼭 봐야 한다.

첫째, 100과 "100"은 다르다.

• 100 + 1은 숫자 덧셈이므로 101
• "100" + 1은 문자열 결합이므로 1001

둘째, 7777777777L은 큰 정수를 long으로 처리하기 위해 L을 붙인 경우다.
즉, 큰 정수는 그냥 적는 것이 아니라 자료형까지 같이 생각해서 써야 한다.

예제: LiteralTest2

System.out.println(10);
System.out.println(-10);
System.out.println(10.0);
System.out.println(10.0f);
System.out.println(10L);
System.out.println(true);
System.out.println(false);
System.out.println('A');
System.out.println("A");
System.out.println('가');
System.out.println("가");
System.out.println("ABC");
System.out.println("가나다");

// 출력결과
// 10
// -10
// 10.0
// 10.0
// 10
// true
// false
// A
// A
// 가
// 가
// ABC
// 가나다

이 예제는 여러 종류의 리터럴을 한 번에 보여준다.
숫자, 논리값, 문자, 문자열이 전부 섞여 있지만, 자바는 이들을 전부 다른 종류의 값으로 처리한다.

예제: LiteralTest2_1

System.out.print(10);
System.out.print(-10);
System.out.print(10.0);
System.out.print(10.0f);
System.out.print(10L);
System.out.print(true);
System.out.print(false);
System.out.print('A');
System.out.print("A");
System.out.print('가');
System.out.print("가");
System.out.print("ABC");
System.out.print("가나다");

// 출력결과
// 10-1010.010.010truefalseAA가가ABC가나다

이 예제는 print를 사용했기 때문에 출력 결과가 한 줄에 계속 이어진다.
즉, println과 print의 핵심 차이는 줄바꿈 여부다.

예제: LiteralTest3

System.out.println("123456789t123456789t123456789");
System.out.println("123456789\t123456789\t123456789");
System.out.println("123\t123\t123");
System.out.println("123456789n123456789n123456789");
System.out.println("123456789\n123456789\n123456789");
System.out.println("123456789\n\n123456789\n\n123456789");
System.out.println("\n\n\n");
System.out.println('가');
System.out.println('나');
System.out.println('다');
System.out.println("\n\n\n");
System.out.print('가');
System.out.print('나');
System.out.print('다');

// 출력결과
// 123456789t123456789t123456789
// 123456789	123456789	123456789
// 123	123	123
// 123456789n123456789n123456789
// 123456789
// 123456789
// 123456789
//
// 123456789
//
// 123456789
//
//
//
// 가
// 나
// 다
//
//
//
// 가나다

이 예제에서는 \t, \n이 실제로 어떻게 동작하는지 확인할 수 있다.

• \t는 탭 간격을 만든다.
• \n은 줄을 바꾼다.
• 그냥 t, n은 아무 기능 없는 문자다.

환경에 따라 \가 원화 기호처럼 보일 수도 있지만, 중요한 것은 모양이 아니라 역할이다.
\n, \t처럼 앞에 \가 붙어야 특수 기능이 생긴다.

헷갈리기 쉬운 부분

• print와 println을 자주 헷갈린다.
• t, n만 쓰면 그냥 문자다.
• \t, \n처럼 앞에 \가 붙어야 특별한 기능이 생긴다.
• 큰 정수는 L이 필요할 수 있다.
• 3.14는 기본적으로 double이라서 float 변수에 바로 넣으면 안 될 수 있다.
  
  
  
  

참고

이스케이프 문자는 더 많지만, 1일차에서는 \n, \t 정도만 먼저 익혀도 충분하다.

---

[문자와 문자열]

개념

자바는 문자와 문자열을 분명하게 구분한다.

• 문자 : 글자 하나
• 문자열 : 글자 여러 개

그래서 아래 둘은 모양은 비슷해도 완전히 다르다.

• 'A'
• "A"

작은따옴표는 문자, 큰따옴표는 문자열이다.

문자를 저장하는 대표 자료형은 char이고,
문자열을 저장하는 대표 타입은 String이다.

문자는 정확히 한 글자만 저장할 수 있다.
문자열은 0개 이상의 문자를 담을 수 있다.

그래서 아래는 가능하다.

char ch = 'A';
String str = "A";
String name = "ABC";
String empty = "";

반대로 아래는 안 된다.

char ch = 'AB';   // 에러

왜냐하면 char는 한 글자만 저장할 수 있기 때문이다.

또 "100"처럼 숫자처럼 보여도 큰따옴표가 붙는 순간 문자열이 된다.
즉, 자바에서는 눈에 보이는 모양보다 따옴표의 종류와 타입 해석 방식이 중요하다.

핵심 특징

• 작은따옴표 ' '는 문자 리터럴이다.
• 큰따옴표 " "는 문자열 리터럴이다.
• 문자는 정확히 1개여야 한다.
• 문자열은 0개 이상의 문자를 담을 수 있다.
• "100"은 숫자가 아니라 문자열이다.
• 문자와 문자열은 출력 결과가 비슷해 보여도 타입이 다르다.
• 문자열에서 +는 숫자 덧셈이 아니라 이어붙이기가 될 수 있다.
  
  
  
  

코드 예제

예제: LiteralTest1

System.out.println(100);
System.out.println("100");
System.out.println(100 + 1);
System.out.println("100" + 1);

// 출력결과
// 100
// 100
// 101
// 1001

이 예제는 숫자와 문자열이 어떻게 다르게 동작하는지 보여준다.

• 100 + 1은 숫자 덧셈이므로 101
• "100" + 1은 문자열 결합이므로 1001

즉, 큰따옴표가 붙는 순간 값은 숫자가 아니라 문자열로 처리된다.

예제: LiteralTest2

System.out.println('A');
System.out.println("A");
System.out.println('가');
System.out.println("가");
System.out.println("ABC");
System.out.println("가나다");

// 출력결과
// A
// A
// 가
// 가
// ABC
// 가나다

화면에 보이는 결과만 보면 비슷해도 의미는 다르다.

• 'A'는 문자 1개
• "A"는 문자열
• "ABC"는 문자열
• "가나다"도 문자열

즉, 자바는 문자와 문자열을 서로 다른 것으로 다룬다.

헷갈리기 쉬운 부분

• 'A'와 "A"는 절대 같은 것이 아니다.
• "100"은 숫자처럼 보여도 문자열이다.
• 문자열에 +를 쓰면 숫자 덧셈이 아니라 결합이 될 수 있다.
• 'AB'처럼 문자 두 개를 char에 넣으면 에러가 난다.
• 빈 문자열 ""은 가능하지만, 문자는 한 글자여야 한다.
  
  
  
  

참고

String은 뒤에서 더 깊게 다룬다.
지금은 한 글자는 char, 여러 글자는 String이라고 구분하면 충분하다.

---

[변수와 값의 저장]

개념

리터럴은 코드에 직접 적는 값이다.
하지만 프로그램에서는 값을 잠깐 저장해두고 다시 써야 하는 경우가 많다.

예를 들어,

• 같은 값을 여러 번 써야 할 때
• 계산 결과를 다시 사용해야 할 때
• 입력받은 값을 저장해둘 때

이럴 때마다 값을 다시 적거나 계산을 반복하면 비효율적이다.
그래서 자바에서는 값을 저장하기 위해 변수를 사용한다.

변수는 쉽게 말해 값을 저장하는 공간이다.
자바에서는 보통 아래처럼 선언한다.

자료형 변수명 = 값;

즉, 변수는
1. 어떤 값을 저장할지 자료형을 정하고
2. 변수 이름을 만들고
3. 값을 넣어 사용한다

는 흐름으로 이해하면 된다.


변수는 단순한 상자가 아니라
값을 다시 꺼내 쓰고, 바꾸고, 재사용하는 도구다.

예를 들어 아래처럼 정수형 변수에 정수를 넣는 것은 가능하다.

int num = 3;

하지만 아래처럼 문자열을 넣으려 하면 자료형이 맞지 않아 에러가 난다.

int num = "3";   // 에러

또 변수를 만들어 놓고 실제로 사용하지 않으면 경고가 뜰 수 있다.
에러는 아니지만, 선언만 하고 사용하지 않는 변수는 좋은 습관이 아니다.

핵심 특징

• 변수는 값을 저장하는 공간이다.
• 변수는 사용하기 전에 먼저 선언해야 한다.
• 변수에는 자료형과 이름이 필요하다.
• 변수는 자료형에 맞는 값만 저장할 수 있다.
• 같은 계산 결과를 여러 번 써야 할 때 변수가 유용하다.
• 사용하지 않는 변수는 경고 대상이 될 수 있다.
• 변수는 코드의 중복을 줄이고 읽기 쉽게 만든다.
  
  
  
  

코드 예제

예제: VariableTest1

int num = 3;
System.out.println(num);

// 출력결과
// 3

이 예제는 변수의 가장 기본적인 사용 형태다.

• int형 변수 num 선언
• 3 저장
• num의 값 출력

즉, 변수는 값 그 자체가 아니라
값을 담아두는 이름 붙은 공간이다.

예제: VariableTest3

System.out.println(1+2+3+4+5 + 10);
System.out.println(1+2+3+4+5 - 10);
System.out.println((1+2+3+4+5) * 10);
System.out.println((1+2+3+4+5) / 10);
System.out.println((1+2+3+4+5) % 10);

int num = 1+2+3+4+5;
System.out.println(num + 10);
System.out.println(num - 10);
System.out.println(num * 10);
System.out.println(num / 10);
System.out.println(num % 10);

// 출력결과
// 25
// 5
// 150
// 1
// 5
// 25
// 5
// 150
// 1
// 5

위쪽 코드는 1+2+3+4+5를 계속 반복해서 계산한다.
아래쪽 코드는 한 번 계산한 결과를 num에 저장한 뒤 다시 사용한다.

결과는 같지만 아래 방식이 더 읽기 쉽고 효율적이다.
또 이 예제에서는 /가 정수끼리 계산되면 몫만 남고, %는 나머지를 구한다는 점도 함께 볼 수 있다.

헷갈리기 쉬운 부분

• 변수명과 변수 안의 값은 다르다.
• 변수는 값을 직접 나타내는 것이 아니라 값을 저장하고 있는 이름이다.
• 같은 계산식을 여러 번 써도 되지만, 변수에 담는 편이 더 낫다.
• int num = "3";처럼 자료형에 맞지 않는 값을 넣으면 에러가 난다.
• 사용하지 않는 변수는 경고 대상이 될 수 있다.
  
  
  
  

참고

변수 이름 짓는 규칙은 뒤에서도 계속 중요하다.
지금은 무슨 값을 저장하는지 알 수 있게 이름을 짓는 것부터 익히면 된다.

---

[변수 선언과 초기화]

개념

변수를 사용할 때는 선언, 초기화, 값 변경을 구분해서 이해하는 것이 좋다.

• 선언 : 변수를 만드는 것
• 초기화 : 변수에 처음 값을 넣는 것
• 값 변경 : 이미 값이 들어 있는 변수에 새로운 값을 다시 넣는 것

변수선언

int num;

은 변수를 만든 상태이고,

초기화

num = 1000;

은 그 변수에 처음 값을 넣은 상태다.
이때는 초기화라고 본다.

값 변경

num = 10 + 20;

처럼 다시 다른 값을 넣으면,
이것은 초기화 이후 값을 변경한 것이다.

즉, 변수는 방만 만들어 놓고 끝나는 것이 아니라,
값을 넣고, 필요하면 다시 다른 값으로 바꾸면서 사용하는 것이다.

자바에서는 선언만 해두고 값을 넣지 않은 변수를
마치 값이 있는 것처럼 바로 사용할 수 없다.

int num;
System.out.println(num);   // 에러

왜냐하면 자바는 값이 없는 상태에서 값을 꺼내 쓰는 것을 허용하지 않기 때문이다.


여기서 같이 알아둘 개념이 l-value, r-value다.

• l-value : 값을 저장하는 대상, 즉 방으로 쓰이는 변수
• r-value : 값을 꺼내 쓰는 대상, 즉 값으로 쓰이는 변수

예를 들어

num = 1000;

여기서 왼쪽 num은 값을 넣는 자리이므로 l-value다.

System.out.println(num);

여기서 num은 저장된 값을 꺼내 쓰는 것이므로 r-value다.

즉, 변수는 상황에 따라 방으로도 쓰이고 값으로도 쓰인다.

핵심 특징

• 변수를 사용하려면 먼저 선언해야 한다.
• 선언만 하고 초기화하지 않은 변수는 바로 사용할 수 없다.
• 초기화는 변수를 처음 사용할 수 있게 만드는 과정이다.
• 초기화한 뒤에는 새로운 값을 다시 넣어 값 변경이 가능하다.
• 변수는 상황에 따라 l-value, r-value로 사용될 수 있다.
  
  
  
  

코드 예제

예제: VariableTest6

System.out.println(100);
int num;
num = 1000;
System.out.println("연산 전 : " + num);
num = 10 + 20;
System.out.println("연산 후 : " + num);

// 출력결과
// 100
// 연산 전 : 1000
// 연산 후 : 30

이 예제는 선언, 초기화, 값 변경을 한 번에 보여준다.

• int num; → 선언
• num = 1000; → 초기화 (l-value)
• System.out.println(num); → 값 사용 (r-value)
• num = 10 + 20; → 값 변경

즉, 변수는 한 번 값을 넣고 끝나는 것이 아니라
필요에 따라 다른 값으로 다시 바꿔가며 사용하는 공간이다.

예제: VariableTest1

int num = 3;
System.out.println(num);

// 출력결과
// 3

이 코드는 선언과 초기화를 한 줄에서 동시에 한 예제다.
실제로는 이런 방식이 가장 자주 쓰인다.

헷갈리기 쉬운 부분

• 선언과 초기화는 같은 것이 아니다.
• 선언만 했다고 바로 출력할 수 있는 것은 아니다.
• 초기화와 값 변경도 구분할 필요가 있다.
• 변수의 이름을 쓰는 것과 변수의 값을 쓰는 것은 다르다.
• l-value, r-value는 결국 “방으로 쓰는가, 값으로 쓰는가”의 차이다.
  
  
  
  

참고

조건문을 배우면
“어떤 경우에는 초기화되고, 어떤 경우에는 초기화되지 않는 변수” 때문에 생기는 에러도 만나게 된다.
지금은 먼저 초기화되지 않은 변수는 사용할 수 없다는 규칙을 확실히 잡으면 된다.

---

[자료형에 따른 차이와 형변환 맛보기]

개념

같은 값이라도 어떤 자료형에 담느냐에 따라 결과가 달라질 수 있다.
또 연산을 하면 결과 자료형이 바뀌는 경우도 있다.

예를 들어 65라는 값을

• char에 넣으면 문자처럼 보일 수 있고
• int에 넣으면 정수로 보이며
• double에 넣으면 실수처럼 보인다

또 char + char처럼 문자끼리 연산해도 결과가 그대로 char가 되는 것이 아니라 자바 규칙에 따라 int로 바뀔 수 있다.


이 과정에서 필요한 것이 형변환이다.

형변환은 쉽게 말해
어떤 값을 다른 자료형으로 바꿔 해석하게 만드는 것이다.

핵심 특징

• char에 숫자를 넣으면 문자 코드값으로 해석될 수 있다.
• int에 넣으면 정수 그대로 보인다.
• double에 넣으면 소수 형태로 보일 수 있다.
• byte, short, char처럼 int보다 작은 타입끼리 연산하면 결과가 int가 된다.
• 연산 결과를 다시 작은 타입 변수에 넣으려면 형변환이 필요할 수 있다.
• 문자도 내부적으로는 코드값을 가진다.
• ++는 1만 증가시키고, +=는 원하는 수만큼 증가시키는 데 사용할 수 있다.
  
  
  
  

코드 예제

예제: VariableTest4

char v1 = 65;
int v2 = 65;
double v3 = 65;

System.out.println(v1);
System.out.println(v2);
System.out.println(v3);
System.out.print(v1);
System.out.print(v2);
System.out.print(v3);
System.out.println();
System.out.print(v1+" ");
System.out.print(v2+" ");
System.out.print(v3);

// 출력결과
// A
// 65
// 65.0
// A6565.0
// A 65 65.0

이 예제는 같은 값 65가 자료형에 따라 다르게 보일 수 있다는 점을 보여준다.

• char는 A
• int는 65
• double은 65.0
  
  
  
  

예제: VariableTest5

int num1=40;
int num2=41;
int result = num1+num2;
System.out.println(result);
System.out.println((double)result);
System.out.println((char)result);

// 출력결과
// 81
// 81.0
// Q

이 예제는 숫자 연산 결과를 다른 자료형으로 보면 어떻게 달라지는지 보여준다.

• 81은 정수 그대로 보면 81
• double로 바꾸면 81.0
• char로 바꾸면 문자 코드값 81에 해당하는 Q
  
  
  
  

예제: VariableTest5

char munja1='(';
char munja2=')';
char result2 = '@';

// result2 = munja1 + munja2; // 에러
result2 = (char)(munja1 + munja2);
System.out.println(result2);

// 출력결과
// Q

이 예제에서 중요한 점은 char + char가 그대로 char가 되지 않는다는 것이다.

문자끼리 더해도 자바는 연산할 때 int로 바꿔서 계산한다.
그래서 결과를 다시 char 변수에 넣으려면 (char) 형변환이 필요하다.

또 왜 결과가 Q인지도 볼 수 있다.

• '('의 코드값은 40
• ')'의 코드값은 41
• 둘을 더하면 81
• 코드값 81에 해당하는 문자가 Q
  
  
  
  

예제: VariableTest6

char munja = 'A';
System.out.print(munja);
munja++;
System.out.print(munja);
munja += 1;
System.out.print(munja);
munja = (char)(munja+1);
System.out.println(munja);

// 출력결과
// ABCD

이 예제는 문자도 코드값 기준으로 증가할 수 있다는 점을 보여준다.

• 처음 A
• munja++ 후 B
• munja += 1 후 C
• (char)(munja+1) 후 D

여기서 ++는 값을 1만 증가시키는 연산자다.
반면 +=는 현재 값에 오른쪽 값을 더해서 다시 저장하는 방식이다.

즉,

munja += 1;

은 의미상 아래와 비슷하다.

munja = munja + 1;

그래서 +=는 1 증가뿐 아니라, 누적해서 값을 더할 때도 자주 사용한다.

예를 들어

num += 5;

는 현재 num 값에 5를 더한 뒤 다시 num에 저장하라는 뜻이다.
이런 식으로 같은 변수에 값을 계속 더해가면 누적합을 만들 때도 쓸 수 있다.


다만 지금 단계에서는
++는 1 증가 전용,
+=는 원하는 수를 더해서 다시 저장하는 방식이라고 이해하면 충분하다.

헷갈리기 쉬운 부분

• char는 문자형이지만 숫자를 넣을 수도 있다.
• 문자끼리 더했다고 해서 결과도 자동으로 char가 되는 것은 아니다.
• char result2 = munja1 + munja2;처럼 쓰면 에러가 난다.
• 연산 결과 타입이 바뀌면 다시 원하는 타입으로 넣을 때 형변환이 필요할 수 있다.
• 형변환은 값을 다른 타입으로 해석하게 만드는 것에 가깝다.
  
  
  
  

참고

형변환과 연산자 우선순위는 뒤에서 더 자세히 다룬다.
지금은 먼저 같은 값도 자료형에 따라 다르게 보이고, 연산 결과 타입이 바뀔 수 있다는 점을 확실히 잡으면 된다.

---

[응용 예제 / 실습]

문제에서 무엇을 하려는지

응용 예제는 앞에서 배운 개념을 여러 개 함께 사용하는 문제다.
1일차에서는 전체 초를 시간, 분, 초로 나눠서 출력하는 문제가 대표적이다.

이 문제의 목적은 단순 계산이 아니라
하나의 큰 숫자를 사람이 읽기 쉬운 시간 단위로 바꾸는 것이다.

이 예제에서 사용된 개념

• 변수
• 정수 나눗셈
• 나머지 연산 %
• 문자열과 숫자 결합 출력

즉, 새로운 개념이 아니라 배운 개념을 조합해서 쓰는 문제다.

코드 흐름

1. 전체 초를 변수에 저장한다.
2. 3600으로 나눠 시간을 구한다.
3. 3600으로 나눈 나머지에서 분을 구한다.
4. 마지막 남은 값을 초로 구한다.
5. 계산한 값을 문자열과 함께 출력한다.
   
   
   
   

계산 공식 또는 풀이 원리

• 1시간 = 3600초
• 1분 = 60초

그래서 공식은 아래처럼 된다.

• 시간 = 전체 초 / 3600
• 분 = (전체 초 % 3600) / 60
• 초 = 전체 초 % 60

예를 들어 32150초라면,

• 32150 / 3600 = 8 → 8시간
• 32150 % 3600 = 3350 → 시간을 빼고 남은 초
• 3350 / 60 = 55 → 55분
• 3350 % 60 = 50 → 50초

즉,
먼저 시간으로 나누고,
남은 값에서 분을 구하고,
마지막 남은 값을 초로 보는 방식이다.

코드 예제

예제: TimeTest

int time = 32150;
int timeH = time / 3600;
int timeM = (time % 3600) / 60;
int timeS = time % 60;
System.out.print(timeH + "시간 " + timeM + "분 " + timeS + "초");

// 출력결과
// 8시간 55분 50초

이 예제는 1일차에서 배운 개념이 실제로 어떻게 합쳐져 쓰이는지를 보여준다.

• 변수로 값 저장
• /로 몫 구하기
• %로 나머지 구하기
• 문자열과 숫자를 +로 묶어서 출력하기

또 여기서 /는 정수끼리 계산하면 몫만 남긴다는 점이 중요하다.
이 문제는 바로 그 성질을 이용해 시간과 분을 구하고 있다.

헷갈리기 쉬운 부분

• time / 60만 하면 바로 분이 되는 것이 아니다.
• time % 3600은 시간을 뺀 뒤 남은 초를 구하는 과정이다.
• /는 정수끼리 계산하면 몫만 남긴다.
• % 60은 마지막 남은 초를 구하는 데 사용된다.
• 계산은 맞아도 출력 형식을 잘못 맞추면 결과가 보기 어렵게 나온다.
• 괄호가 없으면 계산 순서를 잘못 이해할 수 있다.
  * 예를 들어 (time % 3600) / 60은 먼저 시간을 제외한 나머지 초를 구한 뒤, 그 값을 60으로 나누어 분을 구하는 식이다.

---

1일차 핵심 정리

• 자바는 값을 자료형에 따라 구분해서 다룬다.
• 정수형에는 byte, short, int, long이 있고, 실수형에는 float, double이 있다.
• 코드에 직접 적는 값이 리터럴이다.
• 정수 리터럴은 기본적으로 int, 실수 리터럴은 기본적으로 double로 해석된다.
• 큰 정수는 L을 붙여 long으로 처리해야 할 수 있다.
• float로 실수를 쓰려면 f를 붙여야 한다.
• print와 println은 줄바꿈 여부가 다르다.
• \n, \t는 대표적인 이스케이프 문자다.
• 문자와 문자열은 다르다.
• 변수는 값을 저장하는 공간이다.
• 변수는 선언만으로 끝나지 않고 초기화가 중요하다.
• 변수는 상황에 따라 l-value, r-value로 사용될 수 있다.
• 같은 값도 자료형에 따라 다르게 해석될 수 있다.
• 문자형도 내부적으로는 코드값과 연결되어 있다.
• 작은 타입끼리 연산하면 결과 타입이 커질 수 있어 형변환이 필요할 수 있다.
• ++는 1 증가, +=는 원하는 수만큼 증가시키는 데 쓸 수 있다.
• 응용 문제는 배운 개념을 조합해서 푸는 연습이다.