[23] 230131 Java Ch. 2 변수와 타입: 3. 타입 변환, 4. 변수와 시스템 입출력 [K-디지털 트레이닝 23일]

230131 Tue 23rd class

Ch. 2 변수와 타입
진도: p. 72 ~ (교재: 혼자 공부하는 자바, 저자: 신용권)

혼자 공부하는 자바

오늘 배운 것 중 기억할 것을 정리했다. 

---

지난 수업 때 배운 것 중 다시 기억할 것

• Widening Casting (automatically) - converting a smaller type to a larger type size
  byte → short → char → int → long → float → double
  Widening casting is done automatically when passing a smaller size type to a larger size type.

    int myInt = 9;
    double myDouble = myInt; // Automatic casting: int to double

    System.out.println(myInt);      // Outputs 9
    System.out.println(myDouble);   // Outputs 9.0

 

• Narrowing Casting (manually) - converting a larger type to a smaller size type
  double → float → long → int → char → short → byte
  Narrowing casting must be done manually by placing the type in parentheses in front of the value.
  

    double myDouble = 9.78d;
    int myInt = (int) myDouble; // Manual casting: double to int

    System.out.println(myDouble);   // Outputs 9.78
    System.out.println(myInt);      // Outputs 9

---

1) 자동 타입 변환: 큰 타입 = 작은 타입(작은 타입 → 큰 타입)
자동으로 타입이 변환되는 것

byte byteValue = 10;
int intValue = byteValue; //int 타입이 byte 타입보다 허용 범위가 더 크기 때문에 자동 타입 변환된다.

 

2) 강제 타입 변환: 작은 타입 = (작은 타입)큰 타입(큰 타입 → 작은 타입)
강제로 타입을 변환하는 것
ex) short, char의 경우 우위가 없고 강제로 형변환한다. 

int intValue = 10;
byte byteValue = (byte) intValue; //int 타입은 byte 타입보다 더 큰 허용 범위를 가지므로 자동 변환 되지 않는다. 강제 타입 변환한다.

public class OperatorPromotionException2 {
	public static void main(String[] args) {
		byte byteValue1 = 10;
		byte byteValue2 = 20;
		//byte byteValue3 = byteValue1 + byteValue2;
		//첫번째 방법: 자동 타입 변환: 큰 타입 = 작은 타입(작은 타입→ 큰 타입)
		//byteValue1 + byteValue2는 int 타입이다. 
		int byteValue3 = byteValue1 + byteValue2;
		//두번째 방법: 강제 타입 변환: 작은 타입 = (작은 타입)큰 타입
		byte byteValue4 = (byte)(byteValue1 + byteValue2);
		System.out.println(byteValue3);
		System.out.println(byteValue4);
	}
}

---

String 타입 p. 64

작은따옴표(')로 감싼 문자는 char 타입 변수에 저장되어 유니코드로 저장되지만,
큰따옴표(")로 감싼 문자 또는 여러 개의 문자들은 유니코드로 반환되지 않는다.

참조형 타입이다. 기본형 타입 X. String이라는 객체로 저장한다.

---

구분	1byte	2byte	4byte	8byte
정수 타입	byte	short char (우위X, 둘 다 강제로 형변환)	int	long
실수 타입			float	double
논리 타입	boolean

기본 타입을 허용 범위 크기순으로 정리하면 다음과 같다.

byte < short < int < long < float < double

byte (1) < short (2), char (2)  < int (4) < long (8) < float (4, 범위 더 큼) < double (8) 

정수 타입

타입	메모리 사용 크기		저장되는 값의 허용 범위
byte	1 byte	8 bit	-2^7 ~ (2^7-1)	-128 ~ 127
short	2 byte	16 bit	-2^15 ~ (2^15-1)	-32,768 ~ 32,767
char	2 byte	16 bit	0 ~ (2^16 - 1)	0 ~ 65535(유니코드)
int	4 byte	32 bit	-2^31 ~ (2^31 - 1)	-2,147,483,648 ~ 2,147,483,647
long	8 byte	64 bit	-2^63 ~ (2^63 - 1)	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

실수 타입 

타입	메모리 사용 크기		저장되는 값의 허용 범위(양수 기준)	정밀도(소수점 이하 자리)
float	4byte	32bit	(1.4*10^-45) ~ (3.4*10^38)	7자리
double	8byte	64bit	(4.9*10^-324) ~ (1.8*10^308)	15자리

---

Ch. 2  변수와 타입

책의 목차
02-1 변수
02-2 기본 타입
02-3 타입 변환
02-4 변수와 시스템 입출력

2.3 타입 변환(type conversion) p. 72

하나의 타입을 다른 타입으로 바꾸는 것을 타입 변환(type conversion)이라고 한다.
자바에서는 boolean형을 제외한 나머지 기본 타입 간의 타입 변환을 자유롭게 수행할 수 있다.
자바에서 다른 타입끼리의 연산은 우선 피연산자들을 모두 같은 타입으로 만든 후에 수행된다.
메모리에 할당받은 바이트의 크기가 상대적으로 작은 타입에서 큰 타입으로의 타입 변환은 생략할 수 있다.

하지만 메모리에 할당받은 바이트의 크기가 큰 타입에서 작은 타입으로의 타입 변환은 데이터의 손실이 발생한다.
따라서 상대적으로 바이트의 크기가 작은 타입으로 타입 변환을 할 경우 자바 컴파일러는 오류를 발생시킨다.

타입 변환이란 데이터 타입을 다른 데이터 타입으로 변환하는 것을 말한다.
* 데이터 손실이 일어나면 강제 형변환을 한다. 

byte a = 10; //byte 타입 변수 a에 10을 저장
int b = a; //byte 타입 변수 a에 저장된 10을 int 타입 변수 b에 복사해서 저장

---

1) 자동 타입 변환 (Promotion, implicit conversion) (작은 → 큰)

byte byteValue = 10;
int intValue = byteValue; //int 타입이 byte 타입보다 허용 범위가 더 크기 때문에 자동 타입 변환된다.

자동으로 타입 변환이 일어나는 것을 의미한다.
자동 타입 변환은 프로그램 실행 도중에 값의 허용 범위가 작은 타입이 허용 범위가 큰 타입으로 저장될 때 발생한다.

큰 타입 = 작은 타입
괄호는 생략 가능하다. 
기본 타입을 허용 범위 크기순으로 정리하면 다음과 같다.

byte < short < int < long < float < double

예제)

public class PromotionExample {
	public static void main(String[] args) {
		byte byteValue = 10; //int
		//int(4) <- byte(1)
		int intValue = byteValue;
		System.out.println("intValue : "+intValue);
		
		
		char charValue = '가';
		//int(4) <- char(2)
		intValue = charValue;
		System.out.println("가의 유니코드 : "+intValue);
	
		
		intValue = 50;
		//long(8) <- int(4)
		long longValue = intValue;
		System.out.println("longValue : "+longValue);
		
		
		longValue = 100;
		//float(4) <- int(4)
		float floatValue = longValue;
		System.out.println("floatValue : "+floatValue);
		//강제 형변환 문법
		intValue = (int)floatValue;
		
		floatValue = 100.5F;
		//double(8) <- float(4)
		double doubleValue = floatValue;
		System.out.println("doubleValue: "+doubleValue);
	}
}

결과) 
int 정수만 표현
float 정수, 소수점 둘 다 표현. 더 크다. 
float(4) <- int(4)로 강제 형변환된다. 

intValue : 10
가의 유니코드 : 44032
longValue : 50
floatValue : 100.0
doubleValue: 100.5

---

2) 강제 타입 변환 (Casting, explicit conversion) (큰 → 작은)

큰 허용 범위 타입을 작은 허용 범위 타입으로 강제로 나눠서 저장하는 것
작은 타입 = (작은 타입)큰 타입
캐스팅 연산자 괄호 (나누는 단위)를 사용한다. 자바에서는 이 괄호를 타입 캐스트(type cast) 연산자라고 한다.

int intValue = 10;
byte byteValue = (byte) intValue; //int 타입은 byte 타입보다 더 큰 허용 범위를 가지므로 자동 변환 되지 않는다. 강제 타입 변환한다.

int 타입은 byte 타입보다 더 큰 허용 범위를 가진다. 따라서 int 타입은 byte 타입으로 자동 변환 되지 않는다. 하지만 (byte) 캐스팅 연산자를 사용해서 byte 타입으로 강제 변환할 수 있다.

예제)

public class CastingExample {
	public static void main(String[] args) {
		int intValue = 44032;
		// char(2) <- int(4): 강제형 변환 
		char charValue = (char) intValue;
		System.out.println("charValue : "+charValue);
		
		long longValue = 500;
		// int(4) <- long(8): 강제형 변환 
		intValue = (int) longValue;
		System.out.println("intValue : "+intValue);
		
		double doubleValue = 3.14;
		// int(4) <- double(8): 강제형 변환 
		intValue = (int) doubleValue;
		System.out.println("intValue : "+intValue);
	}
}

결과)

charValue : 가
intValue : 500
intValue : 3

---

3) 정수 연산에서의 자동 타입 변환 p. 76

정수 타입 변수가 산술 연산식에서 피연산자로 사용하면
int 타입보다 작은 byte, short 타입의 변수는 int 타입으로 자동 타입 변환되어 연산을 수행한다.
In mathematics, an operand is the object of a mathematical operation, i.e., it is the object or quantity that is operated on.

public class ByteOperationExample {
	public static void main(String[] args) {
		//byte result = (byte)(x+y); 첫번째 방법
		byte x = 10;
		byte y = 20;
		byte result2 = (byte)(x+y);
		System.out.println(result2);
		
		//두번째 방법 
		int result1 = x + y;
		System.out.println(result1);
	}
}

예제) 정수 타입의 연산

public class LongOperationExample {
	public static void main(String[] args) {
		byte value1 = 10;
		int value2 = 100;
		long value3 = 1000L;
		//				byte + int    + long
		//				int  + int    + long
		//				long + long   + long(
		long result = value1 + value2 + value3;
		System.out.println(result);
	}
}

결과)

1110

---

4) 실수 연산에서의 자동 타입 변환 p. 78

실수 타입 변수가 산술 연산식에서 피연산자로 사용될 경우 두 피연산자가 동일한 타입이라면 해당 타입으로 연산되지만,
피연산자 중 하나가 double 타입이라면 다른 피연산자도 double 타입으로 자동 타입 변환되어 연산을 수행한다. 따라서 연산 결과는 double 타입이 된다.

int 타입과 double 타입을 연산해도 동일한 과정을 거친다. 먼저 int 타입의 피연산자가 double 타입으로 자동 변환되고 연산을 수행한다. 

int intValue = 10;
double doubleValue = 5.5;
double result = intValue + doubleValue; //intValue는 double값으로 변환한다. result = 15.5

만약 꼭 int 타입으로 연산을 해야 한다면 double 타입을 int 타입으로 강제 변환하고 덧셈 연산을 하면 된다.

int intValue = 10;
double doubleValue = 5.5;
int result = intValue + (int) doubleValue; //result = 15

예제)

public class OperatorPromotionException {
	public static void main(String[] args) {
		//				실수 + 실수 
		double result1 = 1.2f + 3.4;
		//				정수 + 실수
		//				실수 + 실수
		//				10.0+5.5
		double result2 = 10 + 5.5;
		//강제 형변환 (double -> int)
		int result3 = (int)(10 + 5.5);
		
		System.out.println("result1: "+result1);
		System.out.println("result2: "+result2);
		System.out.println("result3: "+result3);
	}
}

결과)

result1: 4.600000047683716
result2: 15.5
result3: 15

예제2) p.81

public class OperatorPromotionException2 {
	public static void main(String[] args) {
		byte byteValue1 = 10;
		byte byteValue2 = 20;
		//byte byteValue3 = byteValue1 + byteValue2;
		//첫번째 방법: 자동 타입 변환: 큰 타입 = 작은 타입(작은 타입→ 큰 타입)
		//byteValue1 + byteValue2는 int 타입이다. 
		int byteValue3 = byteValue1 + byteValue2;
		//두번째 방법: 강제 타입 변환: 작은 타입 = (작은 타입)큰 타입
		byte byteValue4 = (byte)(byteValue1 + byteValue2);
		System.out.println(byteValue3);
		System.out.println(byteValue4);
	}
}

결과)

30
30

예제3)

		char charValue1 = 'A';
		char charValue2 = '1';
		
		//첫번째 방법: 자동 타입 변환: 큰 타입 = 작은 타입(작은 타입 → 큰 타입)
		//char charValue3 = charValue1 + charValue2;
		int intValue2 = charValue1 + charValue2;
		System.out.println(intValue2);
		//두번째 방법: 강제 타입 변환: 작은 타입 = (작은 타입)큰 타입
		char charValue3 = (char)(charValue1 + charValue2); 
		System.out.println(charValue3);

결과)

114
r

예제 4) int는 소수점을 저장하는 공간이 없다. 소수점은 버려진다.

		int intValue3 = 10;
		int intValue4 = intValue3/4;
		System.out.println(intValue4);
		double intValue5 = intValue3/4;
		System.out.println(intValue5);

결과)

2
2.0

예제 5)

		int x = 1;
		int y = 2;
		double result = (double)x/y;
		System.out.println(result);

결과)

0.5

---

5) + 연산에서의 문자열 자동 타입 변환 p. 82

1. 피연산자가 모두 숫자일 경우: 덧셈 연산 수행한다. 
2. 피연산자 중 하나가 문자열일 경우: 나머지 피연산자도 문자열로 자동 변환되어 문자열 결합 연산을 수행한다.

먼저 수행된 연산이 덧셈 연산이라면 덧셈 결과를 가지고 그다음 + 연산을 수행한다.

String str = 1 + 2 + "3";
String str = 3 + "3";
String str = 33;

앞에서부터 순차적으로 + 연산을 수행하지 않고 우선 연산하고 싶은 부분이 있다면 해당 부분을 괄호 ()로 감싸준다. 괄호는 최우선으로 연산을 수행한다. 

예제) CONCATENATE(연쇄시키다)함수는 여러 개의 범위 또는 여러개의 텍스트 문자열을 하나의 텍스트 문자열로 연결하는 함수입니다.
The concat() method appends (concatenate) a string to the end of another string.

public class StringConcatExample {
	public static void main(String[] args) {
		//숫자 연산
		//			숫자 + 숫자 + 숫자
		int value = 10 + 2 + 8;
		System.out.println("value: " + value);
		
		//문자열 결합 연산자(+)
		//			숫자 + 숫자 + 문자열
		//			10 + 2(12)
		//					12+"8"이고, 뒤가 문자열이므로 +연산자는 두 개의 값을 연결시킨다.
		//			128
		String str1 = 10 + 2 + "8";
		System.out.println("str1: " + str1);
	}
}

결과) 

value: 20
str1: 128

---

6) 문자열을 기본 타입으로 강제 타입 변환 p. 83

String: 기본형 타입이 아니다. 참조형 타입이다.  String이라는 객체로 저장한다. 

ex) "12"와 "3.5"를 정수 및 실수 타입으로 변환해서 숫자 연산을 한다.

변환 타입	사용 예
String ➜ byte	String str = "10"; byte value = Byte.parseByte(str);
String ➜ short	String str = "200"; short value = Short.parseShort(str);
String ➜ int	String str = "300000"; int value = Integer.parseInt(str);
String ➜ long	String str = "40000000000'; long value = Long.parseLong(str);
String ➜ float	String str = "12.345"; float value = Float.parseFloat(str);
String ➜ double	String str = "12.345"; double value = Double.parseDouble(str);
String ➜ boolean	String str = "true"; boolean value = Boolean.parseBoolean(str);

 

기본 타입(byte, short, char, int, long, float, double, boolean)의 값을 문자열로 변경하는 경우에는 간단히 String.valueOf() 메서드를 이용한다.

String str = String.valueOf(기본타입값);

ex) 문자열 "3"을 얻을 수 있다.

String.valueOf(3)

예제)

public class PrimitiveAndStringConversionExample {
	public static void main(String[] args) {
		//String -> int
		int value1 = Integer.parseInt("10");
		//String -> double
		double value2 = Double.parseDouble("3.14");
		//String -> boolean
		boolean value3 = Boolean.parseBoolean("true");
		
		System.out.println("value1: " + value1);
		System.out.println("value2: " + value2);
		System.out.println("value3: " + value3);
		
		//int -> String
		String str1 = String.valueOf(10);
		//double -> String
		String str2 = String.valueOf(3.14);
		//boolean -> String
		String str3 = String.valueOf(true);
		
		System.out.println("str1: " + str1);
		System.out.println("str2: " + str2);
		System.out.println("str3: " + str3);
	}
}

결과)

value1: 10
value2: 3.14
value3: true
str1: 10
str2: 3.14
str3: true

---

charAt이란 string 타입으로 받은 문자열을 char 타입으로 한 글자만 받는 함수이다. 

char var4 = strValue.charAt(0); //0: 인덱스 번호

데이터 손실을 막기 위해 작은 타입 → 큰 타입으로 간다.

---

마무리 p. 85

1) 자동 타입 변환: 큰 타입 = 작은 타입(작은 타입 → 큰 타입)
자동으로 타입이 변환되는 것

byte byteValue = 10;
int intValue = byteValue; //int 타입이 byte 타입보다 허용 범위가 더 크기 때문에 자동 타입 변환된다.

 

2) 강제 타입 변환: 작은 타입 = (작은 타입)큰 타입(큰 타입 → 작은 타입)

int intValue = 10;
byte byteValue = (byte) intValue; //int 타입은 byte 타입보다 더 큰 허용 범위를 가지므로 자동 변환 되지 않는다. 강제 타입 변환한다.

강제로 타입을 변환하는 것
ex) short, char의 경우 우위가 없고 강제로 형변환한다. 

3) 문자열 결합 연산: 문자열과 + 연산을 하면 다른 피연산자도 문자열로 변환되어 문자열 결합이 일어난다.

4) Integer.parseInt(): 문자열을 정수 int 타입으로 변환한다.

5) Double.parseDouble(): 문자열을 실수 double 타입으로 변환한다. 

---

2.4 변수와 시스템 입출력 p. 89

표준 출력 장치는 모니터이고, 표준 입력 장치는 키보드이다. 
변수에 저장된 값을 모니터로 출력하는 방법과 키보드로부터 데이터를 읽고 변수에 저장하는 방법을 알아본다. 

System.out은 시스템의 표준 출력 장치를 말한다. in은 표준 입력 장치이다. 

System.in.read();

1) 모니터로 변숫값 출력하기

System. + out. + println(리터럴 또는 변수);

System: 시스템이 가지고 있는
out: 출력 장치로
println(리터럴 또는 변수): 괄호 안의 내용을 출력하고 행을 바꾼다.

printf("형식문자열",값1,값2,...);

괄호 안의 첫 번째 문자열 형식대로 내용을 출력한다.

%[$argument_index$][flags][width][.precision][conversion]

%: 형식 문자열의 시작
[$argument_index$]: 값의 순번 ex) 1$는 첫 번째 값, 2$는 두 번째 값을 뜻한다. 
[flags]: -, o: 빈자리를 채우는 방법인데 생략되면 왼쪽이 공백으로 채워지고, -가 오면 오른쪽이 공백으로 채워진다. 0은 공백 대신 0으로 채운다. 
[width]: 전체 자릿수
[.precision]: 소수 자릿수
[conversion]: 변환 문자, 제공되는 값의 타입에 따라 d(정수), f(실수), s(문자열)을 입력한다.
형식 문자열에서 %와 conversion(변환 문자)은 필수로 작성하고 그 외의 항목은 모두 생략할 수 있다.

자주 사용되는 형식 문자열
실수: %전체길이.소수점이 나오는 개수

형식화된 문자열		설명	출력 형태
정수	%d	정수	123
	%6d	6자리 정수, 왼쪽 빈 자리 공백	___123
	%-6d	6자리 정수, 오른쪽 빈 자리 공백	123___
	%06d	6자리 정수, 왼쪽 빈 자리 0 채움	000123
실수	%10.2f	소수점 이상 7자리, 소수점 이하 2자리, 왼쪽 빈 자리 공백	___123.45
	%-10.2f	소수점 이상 7자리, 소수점 이하 2자리, 오른쪽 빈 자리 공백	123.45___
	%010.2f	소수점 이상 7자리, 소수점 이하 2자리, 왼쪽 빈 자리 0채움	0000123.45
문자열	%s	문자열	abc
	%6s	6자리 문자열, 왼쪽 빈 자리 공백	___abc
	%-6s	6자리 문자열, 오른쪽 빈 자리 공백	abc___
특수문자	\t	탭(tab)
	\n	줄바꿈
	%%	%	%

예제) p. 91

public class P90PrintExample {
	public static void main(String[] args) {
		int value = 123;
		System.out.println("상품의 가격: "+value+"원");
		//			printf("형식문자열",값)
		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.14 * 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
원상품의 가격:123   
원상품의 가격:000123
원반지름이 10인 원의 넓이:     314.00
     1 | 홍길동        |         도적

---

2) 키보드에서 입력된 내용을 변수에 저장하기 p. 92

키보드에서 키 하나를 입력하면 프로그램에서는 숫자로 된 키코드를 읽을 수 있다.
ex) a = 97번, 1 = 49번

1. keycode: (computing) A code that represents a keypress.

int keyCode = System. + in. + read();

System: 시스템이 가지고 있는
in: 입력 장치에서
read: 입력된 키코드를 읽어라.
keyCode: 읽은 키코드를 변수에 저장한다. 

예제)

public class P93KeyCodeExample {
	public static void main(String[] args) throws Exception {
		int keyCode;
		
		keyCode=System.in.read();
		System.out.println("keyCode: " + keyCode);
		
		keyCode=System.in.read();
		System.out.println("keyCode: " + keyCode);
		
		keyCode=System.in.read();
		System.out.println("keyCode: " + keyCode);
	}
}

결과) 97: [A]키에 대한 키코드
[Enter]키는 다른 키와 다르게 캐리지 리턴(CR: 13)+라인 피트(LF: 10) 키코드 구성 
A carriage return, sometimes known as a cartridge return and often shortened to CR, <CR> or return, is a control character or mechanism used to reset a device's position to the beginning of a line of text.

a
keyCode: 97
keyCode: 13
keyCode: 10

예제) System.in.read()로 읽었기 때문에 int 타입의 키코드를 얻는다. 

public class P94ContinueKeyCodeReadExample {

	public static void main(String[] args) throws Exception {
		int keyCode;
		while(true) {
			//무한대로 키보드로 입력
			keyCode = System.in.read();
			System.out.println("keyCode : "+keyCode);
			//만약에 사용자가 q를 입력하면
			if(keyCode==113) {
			// 반복문을 종료한다.
			break;	
		}
		System.out.println("종료");
	}
}
}

결과)

q
keyCode : 113

---

Scanner 클래스 p. 95

System.in.read()의 단점은 키코드를 하나씩 읽기 때문에 2개 이상의 키가 조합된 한글을 읽을 수 없다.
그리고 키보드로부터 입력된 통 문자열로 읽지 못한다.
이러한 단점을 보완하기 위해 자바는 Scanner 클래스를 제공하고 있다.

Scanner scanner = new Scanner(System.in);

Scanner scanner: Scanner 타입의 변수 scanner을 선언한다.
new Scanner(System.in): 시스템의 입력 장치로부터 읽는 Scanner 생성한다.
     System: 시스템이 가지고 있는
     in: 입력 장치에서
new Scanner: 생성된 Scanner를 변수에 저장한다.

String inputData = scanner.nextLine();

String inputDate: 변수 선언
scanner.nextLine(): [Enter]키가 입력되기 전까지 대기 상태가 되며, [Enter]키가 입력되면 입력된 모든 내용을 문자열로 읽는다.
scanner: 읽은 문자열을 String 변수에 저장한다.

예제) scanner.nextLine()으로 읽었기 때문에 String 타입의 문자열을 얻는다. 

import java.util.Scanner; //Scanner가 java.util 패키지에 있다는 것을 컴파일러에게 알려준다. 

public class P96_ScannerExample {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String inputData;
		
		while(true) {
			inputData=scanner.nextLine();//커서가 깜빡인다.
			System.out.println("입력된 문자열: \""+inputData+"\"");
			//만약에 사용자가 입력한 값이 q이면
			if(inputData.equals("q")) {
				//반복문을 종료한다. 
				break;
			}
		}
		System.out.println("종료");
	}
}

결과)

a
입력된 문자열: "a"
q
입력된 문자열: "q"
종료

자바는 기본 타입(byte, short, int, long, float, double, boolean)의 값이 동일한지 비교할 때에는 ==를 사용하고,
문자열(String)이 동일한지 비교할 때에는 equals() 메서드를 사용한다. p. 97

boolean result = inputData. equals("비교문자열");

inputData: 저장된 문자열
equals("비교문자열"): 비교
result: 같으면 true, 다르면 false

예제) p. 121

String strVar1 = "신용권";
String strVar2 = "신용권";
System.out.println(strVar1.equals(strVar2)); //true
System.out.println(!strVar1.equals(strVar2)); //false

 

---

마무리 p. 98

데이터 손실 최소화

=== console에 결과 출력 ===

1) System.out.println(): 괄호에 주어진 매개값을 모니터로 출력하고 개행(강제 줄 바꿈)을 한다.

2) System.out.print(): 괄호에 주어진 매개값을 모니터로 출력한 하고 개행을 하지 않는다.

3) System.out.printf(): 괄호에 주어진 형식대로 출력한다.

=== 키보드로 값을 입력 ===

4) Sytem.in.read(): 키보드에 입력된 키보드를 읽는다.

5) Scanner: System.in.read()는 키보드를 하나씩 읽기 때문에 2개 이상의 키가 조합된 한글을 읽을 수 없다. 키보드로부터 입력된 내용을 통 문자열로 읽기 위해서 Scanner를 사용할 수 있다.

---

Q1)

public class P98Q1 {
	public static void main(String[] args) {
		String name = "김자바";
		int age = 25;
		String tel1 = "010";
		String tel2 = "123";
		String tel3 = "4567";
		
		System.out.println("이름: " + name);
		System.out.print("나이: " + age+"\n");
		//1$: 첫 번째 값, 2$: 두 번째 값, n$: n번 째 값
		System.out.printf("전화 : %1s-%2s-%3s", tel1,tel2,tel3);
	}
}

결과) 

이름: 김자바
나이: 25
전화 : 010-123-4567

Q2)

public class P99Q2 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("첫번째 수:");
		//String 타입으로 저장한다. 
		String strNum1 = scanner.nextLine();
		
		System.out.println("두번째 수:");
		String strNum2 = scanner.nextLine();
	
		int num1 = Integer.parseInt(strNum1);
		int num2 = Integer.parseInt(strNum2);
		int result = num1 + num2;
		System.out.println("덧셈 결과:"+result);
	}
}

결과)  입력한 숫자 2개의 합이 뜬다. 

첫번째 수:
15
두번째 수:
20
덧셈 결과:35

Q3)

import java.util.Scanner;
public class P99Q3 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("[필수 정보 입력]");
		
		System.out.println("1. 이름: ");
		String name = scanner.nextLine();
		
		System.out.println("2. 주민번호 앞 6자리: ");
		String ssn = scanner.nextLine();
		
		System.out.println("3. 전화번호: ");
		String tel = scanner.nextLine();
		
		System.out.println();
		
		System.out.println("[입력된 내용]");
		System.out.println("1. 이름: " + name);
		System.out.println("2. 주민 번호 앞 6자리: " + ssn);
		System.out.println("3. 전화번호: " + tel);
	}
}

결과) 입력한 결과가 뜬다. 

[필수 정보 입력]
1. 이름: 
안녕하세요
2. 주민번호 앞 6자리: 
912345
3. 전화번호: 
0101234567

[입력된 내용]
1. 이름: 안녕하세요
2. 주민 번호 앞 6자리: 912345
3. 전화번호: 0101234567

---