변수(variable)
하나의 값을 저장할 수 있는 메모리 번지에 붙여진 이름
변수를 통해 프로그램이 메모리 번지에 값을 저장하고 읽을 수 있음
자바의 변수는 다양한 타입의 값을 저장할 수 없고 하나의 값만 저장 가능하다.
즉 정수형 변수는 정수값만 저장, 실수형 변수는 실수값만 저장할 수 있다
변수 선언
어떤 타입의 데이터를 저장할 것인지, 변수 이름은 무엇인지 결정하는 것
변수의 첫 글자는 문자여야하고 중간부터는 문자, 숫자, $, _를 포함할 수 있음
첫 문자를 소문자로 시작하고 캐멀 스타일로 작성하는 것이 관례
어떤 값을 저장하고있는지 알기 쉽게 의미 있는 이름을 붙일 것
캐멀(camel) 스타일
자바 소스 파일명(클래스명)은 대문자로 시작(ex. Week.java, MemberGrade.java, ProductKind.java)
변수명은 소문자로 시작(ex. score, mathScore, sportsCar)
변수 대입
변수 선언은 저장되는 값의 타입과 이름만 결정한 것뿐, 아직 메모리에 할당된 건 아님
변수에 최초로 값이 대입될 떄 메모리에 할당되고, 해당 메모리에 값이 저장됨
변수에 최초로 값을 대입하는 행위를 변수 초기화라고 하고, 이때의 값을 초기값이라고 함
int age; //정수(int)값을 저장할 수 있는 age 변수 선언
double value; //실수(double)값울 저장할 수 있는 value 변수 선언
int score; //변수 선언
score = 90; //대입, 우측 값을 좌측 변수에 대입하는 연산자 =
package ch02.sec01;
public class VariableInitializationExample {
public static void main(String[] args) {
int value; //변수 value 선언
// int result = value + 10; //변수 value 값을 읽고 10으르 더해서 변수 result에 저장
//잘못된 선언!, 초기화되지 않은 변수는 아직 메모리할당X, 메모리값 읽을 수 없음!!
value = 30; //변수 value가 30으로 초기화됨
int result = value + 10; //변수 value값(30)을 읽고 10을 더해서 변수 result에 저장
System.out.println(result); //40
}
}
package ch02.sec01;
public class VariableUseExample {
public static void main(String[] args) {
int hour = 3;
int minute = 5;
System.out.println(hour + "시간 " + minute + "분"); //3시간 5분
int totalMinute = (hour*60) + minute;
System.out.println("총 " + totalMinute + "분"); //총 185분
}
}
package ch02.sec01;
public class VariableExchangeExample {
public static void main(String[] args) {
int x = 3;
int y = 5;
System.out.println("x: " + x + ", y: " + y); //x: 3, y: 5
int temp = x; //변수 x값 3을 변수 temp에 대입
x = y; //변수 y값 5를 변수 x에 대입
y = temp; //변수 temp값 3을 변수 y에 대입
System.out.println("x: " + x + ", y: " + y); //x: 5, y: 3
}
}
타입
변수는 선언될 떄의 타입에 따라 저장할 수 있는 값의 종류와 허용 범위가 달라짐
1byte는 8bit
bit는 0과 1이 저장되는 단위
| 값의 분류 | 기본 타입 |
| 정수 | byte, char, short, int, long |
| 실수 | float, double |
| 논리(true/false) | boolean |
정수 타입
| 타입 | 메모리 크기 | 저장되는 값의 허용 범위 | |
| 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~65546(유니코드) |
| int | 4byte(32bit) | -2^31~(2^31-1) | -2,147,483,648~2,147,483,647 |
| long | 8byte(64bit) | -2^63~(2^63-1) | -9,233,372,036,854,775,808~ 9,233,372,036,854,775,807 |
| 종류 | byte | short | int | long |
| 메모리 사용 크기 (bit 단위) |
8 | 16 | 32 | 64 |
부호비트
byte, short, int, long은 모두 부호 있는(signed) 정수 타입이므로 최상위 bit는 부호 bit로 사용되고, 나머지 bit는 값의 범위를 결정함
양수는 0, 음수는 1
| 최상위 bit 값 | 값의 범위 |
| 0 n-1개의 bit | 0~(2^n-1-1) |
| 1 n-1개의 bit | -2^n-1~-1 |
리터럴(literal)과 진수
프로그래머가 직접 입력한 값을 리터럴이라 부르는데, 변수에 대입할 정수 리터럴은 진수에 따라 작성법이 다름
2진수
0b 또는 0B로 시작하고 0과 1로 작성
int x = 0b1011; //10진수값 11 = 1*2^3 + 0*2^2 + 1*2^1 + 1*2^0
int y = 0B10100; //10진수값 20 = 1*2^4 = 0*2^3 + 1*2^2 + 0*2^1 + 0*2^0
8진수
0으로 시작하고 0~7 숫자로 작성
int x = 013; //10진수값 11 = 1*8^1 + 3&8^0
int y = 0206; //10진수값 134 = 2*8&2 + 0*8^1 + 6&8^0
10진수
소수점이 없는 0~9 숫자로 작성
int x = 12;
int y = 365;
16진수
0x 또는 0X로 시작하고 0~9 숫자나 A, B, C, D, E, F 또는 a, b, c, d, e, f로 작성
int x = 0xB3; //10진수값 179 = 11*16^1 + 3*16^0
int y = 0X2A0f; //10진수값 10767 = 2*16^3 + 10*16^2 + 0*16^1 + 15*16^0
package ch02.sec02;
public class IntegerLiteralExample {
public static void main(String[] args) {
int var1 = 0b1011; //2진수, 11
int var2 = 0206; //8진수, 134
int var3 = 365; //10진수, 365
int var4 = 0xB3; //16진수, 179
System.out.println("var1: " + var1); //var1: 11
System.out.println("var2: " + var2); //var2: 134
System.out.println("var3: " + var3); //var3: 365
System.out.println("var4: " + var4); //var4: 179
}
}
package ch02.sec02;
public class ByteExample {
public static void main(String[] args) {
byte var1 = -128;
byte var2 = -30;
byte var3 = 0;
byte var4 = 30;
byte var5 = 127;
// byte var6 = 128; //컴파일 에러, byte타입 변수 허용범위를 초과함
}
}
package ch02.sec02;
public class LongExample {
public static void main(String[] args) {
long var1 = 10;
long var2 = 20L;
// long var3 = 10000000000; //컴파일러는 기본적으로 int로 인식하기에 에러발생
long var4 = 10000000000L; //int 허용범위 초과값은 l 혹은 L을 붙여 long타입값 인식시킴
System.out.println(var1); //10
System.out.println(var2); //20
System.out.println(var4); //10000000000
}
}
문자 타입
하나의 문자를 작은따옴표(’)로 감싼 것을 문자 리터럴이라고 함
문자 리터럴은 유니코드로 변환돼 저장되는데, 유니코드는 세계 각국의 문자를 0~65535 숫자로 매핑한 국제 표준 규약
자바는 이러한 유니코드를 저장할 수 있도록 char타입 제공
유니코드가 정수이므로 char타입도 정수 타입
char var1 = 'A'; //'A' 문자와 매핑되는 숫자는 65
char var2 = '가'; //'가' 문자와 매핑되는 숫자는 44032
char C = 65; //10진수 65와 매핑되는 문자 'A'
char C = 0x0041; //16진수 0x0041과 매핑되는 문자 'A'
package ch02.sec03;
public class CharExample {
public static void main(String[] args) {
char c1 = 'A'; //문자 저장
char c2 = 65; //유니코드 직접 저장
char c3 = '가'; //문자 저장
char c4 = 44032; //유니코드 직접 저장
System.out.println(c1); //A
System.out.println(c2); //A
System.out.println(c3); //가
System.out.println(c4); //가
// char c = ''; //컴파일 에러, 초기화할땐 공백을 포함해야 에러안남
char c = ' '; //공백 하나를 포함해서 초기화
}
}
실수 타입
double 타입이 float 타입보다 큰 실수를 저장할 수 있고 정밀도 또한 높다
컴파일러는 기본적으로 double타입 인식
float는 뒤에 f 혹은 F로 표시해줘야 함
| 타입 | 메모리크기 | 저장되는 값의 허용 범위 (양수기준) |
유효 소수 이하 자리 |
| float | 4byte(32bit) | 1.410^-45~3.410^38 | 7자리 |
| double | 8byte(64bit) | 4.910^-324~1.810^308 | 15자리 |
자바는 실수 타입의 값을 부동 소수점(floating-point) 방식으로 메모리에 저장함
[float] 부호(1bit) + 지수(8bit) + 가수(32bit) = 32bit(4byte)
[double] 부호(1bit) + 지수(11bit) + 가수(52bit) = 64bit(8byte)
10진수 리터럴
double x = 0.25;
double y = -3.14;
e 또는 E가 포함된 10의 거듭제곱 리터럴
double x = 5e2; //500.0, 5.0 * 10^2
double y = 0.12E-2 0/0012, 0.12*10^-2
package ch02.sec04;
public class FloatDoubleExample {
public static void main(String[] args) {
float var1 = 0.1234567890123456789F;
double var2 = 0.1234567890123456789;
System.out.println(var1); //0.12345679
System.out.println(var2); //0.12345678901234568
//double타입이 float 타입보다 약 2배정도의 유효 자릿수를 가짐
double var3 = 3e6;
float var4 = 3e6F;
double var5 = 2e-3;
System.out.println(var3); //3000000.0
System.out.println(var4); //3000000.0
System.out.println(var5); //0.002
}
}
논리 타입
참과 거짓을 의미하는 논리 리터럴 true, false
논리 리터럴은 boolean 타입 변수에 대입
boolean stop = true;
boolean stop = false;
int x = 10;
boolean result = (x == 20); //x값이 20인가?
boolean result = (x != 20); //x값이 20이 아닌가?
boolean result = (x > 20); //x값이 20보다 큰가?
boolean result = (0 < x && x < 20); //x값이 0보다 크고, 20보다 작은가?
boolean result = (x < 0 || x > 200); //x값이 0보다 적거나, 200보다 큰가?
package ch02.sec05;
public class BooleanExample {
public static void main(String[] args) {
boolean stop = true;
if(stop) {
System.out.println("중지합니다.");
} else {
System.out.println("시작합니다.");
}
int x = 10;
boolean result1 = (x == 20); //x값이 20인가?
boolean result2 = (x != 20); //x값이 20이 아닌가?
System.out.println(result1); //false
System.out.println(result2); //true
}
}
문자열 타입
작은따옴표(’)로 감싼 한 개의 문자는 char 타입이지만, 큰따옴표(”)로 감싼 여러 개의 문자들은 유니코드로 변환되지 않음
char var1 = "A"; //컴파일 에러!
char var2 = "홍길동"; //컴파일 에러!
큰따옴표(”)로 감싼 문자들은 문자열이라 부르고 String 타입을 사용해야 함
String var1 = "A";
String var2 = "홍길동";
이스케이프(escape) 문자 \
이스케이프 문자 역슬래쉬(\)를 사용하면 특정 문자를 포함하거나 출력에 영향을 미침
| 이스케이프 문자 / | |
| \” | “문자 포함 |
| \’ | ‘문자 포함 |
| \\ | \문자 포함 |
| \u16진수 | 16진수 유니코드에 해당하는 문자 포함 |
| \t | 출력 시 탭만큼 띄움 |
| \n | 출력 시 줄바꿈(라인피드) |
| \r | 출력 시 캐리지 리턴 |
package ch02.sec06;
public class StringExample {
public static void main(String[] args) {
String name = "홍길동";
String job = "프로그래머";
System.out.println(name);
System.out.println(job);
String str = "나는 \"자바\"를 배웁니다."; //"문자 포함
System.out.println(str);
str = "번호\t이름\t직업"; //탭만큼 띄움
System.out.println(str);
System.out.print("나는\n"); //줄바꿈
System.out.print("자바를\n");
System.out.print("배웁니다.\n");
}
}
큰따옴표 3개(”””)로 감싸면 이스케이프 하거나 라인피드를 할 필요가 없이 작성된 그대로 문자열로 저장
package ch02.sec06;
public class TextBlockExample {
public static void main(String[] args) {
String str1 = "" +
"{\n" +
"\t\"id\":\"winter\",\n" +
"\t\"name\":\"눈송이\"\n" +
"}";
String str2 = """
{
"id":"winter",
"name":"눈송이"
}
""";
//두 변수 동일한 결과
System.out.println(str1);
System.out.println("==========");
System.out.println(str2);
System.out.println("==========");
// 줄바꿈없이 다음줄에 이어서 작성하려면 맨 끝에 \ 불여줌
String str = """
나는 자바를 \
학습합니다.
나는 자바 고수가 될 겁니다.
""";
System.out.println(str);
}
}
자동 타입 변환(promotion)
값의 허용 범위가 작은 타입이 허용 범위가 큰 타입으로 대입될 때 발생
기본 타입의 허용 범위 순서
byte < short, char < int < long< float < double
byte byteValue = 10;
int intValue = byteValue; //int 타입이 byte 타입보다 허용 범위가 더 크기에 자동 타입 변환됨
정수 타입이 실수 타입으로 대입될 경우 무조건 자동 타입 변환됨
실수 타입은 정수 타입보다 허용 범위가 더 크기 때문
long longValue = 5000000000L;
float floatValue = longValue; //5.0E9f로 저장됨
double doubleValue = longValue; //5.0E9로 저장됨
char 타입의 경우 int 타입으로 자동 변환되면 유니코드 값이 int 타입에 대입됨
char CharValue = 'A';
int intValue = charValue; //65가 저장됨
자동 타입 변환의 예외
char 타입보다 허용 범위가 작은 byte 타입은 char 타입으로 자동 변환될 수 없음
char 타입은 음수를 포함하지 않는데, byte 타입은 음수를 포함하기 때문
byte byteValue = 65;
char charValue = byteValue; //컴파일 에러!
package ch02.sec07;
public class PromotionExample {
public static void main(String[] args) {
byte byteValue = 10;
int intValue = byteValue;
System.out.println("intValue: " + intValue); //10
char charValue = '가';
intValue = charValue;
System.out.println("가의 유니코드: " + intValue); //44032
intValue = 50;
long longValue = intValue;
System.out.println("longValue: " + longValue); //50
longValue = 100;
float floatValue = longValue;
System.out.println("floatValur: " + floatValue); //100.0
floatValue = 100.5F;
double doubleValue = floatValue;
System.out.println("doubleValue: " + doubleValue); //100.5
}
}
강제 타입 변환(casting)
큰 허용 범위 타입을 작은 허용 범위 타입으로 쪼개서 저장하는 것
캐스팅 연산자로 괄호()를 사용하는데, 괄호 안에 들어가는 타입은 쪼개는 단위
강제 타입의 목적은 원래 값이 유지되면서 타입만 바꾸는 것이기에 작은 허용 범위 타입에 저장될 수 있는 값을 가지고 강제 타입 변환을 해야 함
int → byte
int intValue = 10;
byte byteValue = (byte) intValue; //강제 타입 변환 후 10
int intValue = 193928779;
byte byteValue = (byte)intValue; //원래 값이 보존되지 않고 10이됨!
long → int
long longValue - 300;
int intValue - (int)LongValue; //강제 타입 변환 후 300이 그대로 유지됨
int → char
int intValue = 65;
char charValue = (char)intValue;
System.out.println(charValue); //'A'가 출력됨
실수 → 정수
double doubleValue = 3.14;
int intValue = (int)doubleValue; //intValue는 정수부분인 3만 저장됨
package ch02.sec08;
public class CastingExample {
public static void main(String[] args) {
int var1 = 10;
byte var2 = (byte) var1;
System.out.println(var2); //10
long var3 = 300;
int var4 = (int) var3;
System.out.println(var4); //300
int var5 = 65;
char var6 = (char) var5;
System.out.println(var6); //A
double var7 = 3.14;
int var8 = (int) var7;
System.out.println(var8); //3
}
}
연산식에서 자동 타입 변환
정수 타입 변수가 산술 연산식에서 피연산자로 사용되면 int 타입보다 작은 byte, short 타입의 변수는 int 타입으로 자동 타입 변환되어 연산을 수행함
특별한 이유가 없다면 정수 연산에서 변수가 사용될 경우 int 타입으로 변수를 선언하는 것이 실행 성능에 도움이 됨
byte x = 10;
byte y = 20;
//byte result = x + y; //컴파일 에러!!
int result = x + y;
실수의 경우 피연산자가 모두 float 타입이면 결과도 당연히 float 타입이나, 그 중 하나가 double 타입이면 연산 결과도 double이 됨
int intValue = 10;
double doubleValue = 5.5;
double result = intValue + doubleValue; //double값으로 변환, 10.0 + 5.5
int result = intValue + (int)doubleValue; //10 + 5
1/2를 할 때의 연산
자바에서 정수 연산의 경과는 항상 정수가 됨
따라서 밑의 x / y의 연산 결과는 0.5가 아니라 0.0
0.5를 출력하기 위해선 정수 연산이 아니라 실수 연산으로 변경해야 하기에 x나 y를 double 타입으로 변환해야 함
int x = 1;
int y = 2;
double result = x / y;
System.out.println(result); //0.0이 출력됨
//0.5가 출력되는 경우
double result = (double)x / y;
double result = x / (double)y;
double result = (double)x / (double)y;
package ch02.sec08;
public class OperationPromotionExample {
public static void main(String[] args) {
byte result1 = 10 + 20; //컴파일 단계에서 연산
System.out.println(result1); //30
byte v1 = 10;
byte v2 = 20;
int result2 = v1 + v2; //int 타입으로 변환 후 연산
System.out.println(result2); //30
byte v3 = 10;
int v4 = 100;
long v5 = 1000L;
long result3 = v3 + v4 + v5; //long 타입으로 변환 후 연산
System.out.println(result3); //1110
char v6 = 'A';
char v7 = 1;
int result4 = v6 + v7; //int 타입으로 변환 후 연산
System.out.println(result4); //66
System.out.println((char)result4); //B
int v8 = 10;
int result5 = v8 / 4; //정수 연산의 결과는 정수
System.out.println(result5); //2
int v9 = 10;
double result6 = v9 / 4.0; //double 타입으로 변환 후 연산
System.out.println(result6); //2.5
int v10 = 1;
int v11 = 2;
double result7 = (double) v10 / v11; //double 타입으로 변환 후 연산
System.out.println(result7); //0.5
}
}
+연산자
자바에서 +연산자는 피연산자가 모두 숫자일 경우 덧셈 연산을 수행하고, 하나가 문자열일 경우 나머지 피연산자도 문자열로 자동 변환하여 문자열 결합 연산을 수행한다.
int value = 3 + 7;
int value = 10; //덧셈 연산
String str = "3" + 7;
String str = "37"; //문자열 결합 연산
+연산자가 연이어 나오면 순차적으로 연산 수행
먼저 수행된 연산이 덧셈 연산이라면 그 결과를 가지고 다음 연산을 수행
하지만 결합 연산이라면 이후의 연산은 모두 결합 연산이 됨
int value = 1 + 2 + 3;
int value = 3 + 3;
int value = 6; //순차적으로 덧셈 연산
String str = "1" + 2 + 3;
String str = "12" + 3;
String str = "123"; //먼저 수행된 연산이 결합 연산이면 그 이후는 모두 결합연산
만약 순차적으로 +연산을 수행하지 않고 특정 부분을 우선 연산하고 싶다면 괄호()로 감싸면 됨
괄호는 항상 최우선으로 연산을 수행
String str = "1" + (2 + 3);
String str = "1" + 5;
String str = "15";
package ch02.sec09;
public class StringConcatExample {
public static void main(String[] args) {
//숫자 연산
int result1 = 10 + 2 + 8;
System.out.println(result1); //20
//결합 연산
String result2 = 10 + 2 + "8";
System.out.println(result2); //128
String result3 = 10 + "2" + "8";
System.out.println(result3); //1028
String result4 = "10" + 2 + 8; //결합 연산 뒤는 계속 결합 연산
System.out.println(result4); //1028
String result5 = "10" + (2 + 8);
System.out.println(result5); //1010
}
}
문자열을 기본 타입으로 변환
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);
기본 타입의 값을 문자열로 변경하는 경우
String str = String.valueOf(기본타입값);
package ch02.sec10;
public class PrimitiveAndStringConversionExample {
public static void main(String[] args) {
int value1 = Integer.parseInt("10");
double value2 = Double.parseDouble("3.14");
boolean value3 = Boolean.parseBoolean("true");
System.out.println(value1); //10
System.out.println(value2); //3.14
System.out.println(value3);// ture
String str1 = String.valueOf(10);
String str2 = String.valueOf(3.14);
String str3 = String.valueOf(true);
System.out.println(str1); //10
System.out.println(str2); //3.14
System.out.println(str3); //true
}
}
변수 사용 범위
중괄호 {} 블록 내에서 선언된 변수는 해당 중괄호 {} 블록 내에서만 사용이 가능하고 밖에서는 사용할 수 없음
메소드 블록 전체레서 사용하고 싶다면 메소드 블록 첫머리에 선언하는 것이 좋고, 특정 블록 내부에서만 사용된다면 해당 블록 내에서 선언하는 것이 좋음
package ch02.sec11;
public class VariableScoreExample {
public static void main(String[] args) {
int v1 = 15;
if(v1 > 10) {
int v2 = v1 - 10;
}
// int v3 = v1 + v2 + 5; //컴파일 에러! v2 변수를 사용할 수 없음!!
}
}
콘솔로 변숫값 출력
| 메소드 | 의미 |
| println(); | 괄호 안의 내용을 출력하고 행을 바꿔라 |
| print(); | 괄호 안의 내용을 출력하고 행은 바꾸지 말아라 |
| printf(”형식문자열”, 값1, 값2, …) | 형식 문자열에 맞추어 뒤의 값을 출력해라 |
형식문자열-[]는 생략가능
% [argument_index$] [flags] [width] [.precision] conversion
% [값의 순번] [-, 0] [전체 자릿수] [소수 자릿수] 변환문자
System.out.printf("이름: %s", "김자바"); //이름: 김자바
System.out.printf("나이: %d", 25); //나이: 25
System.out.printf("이름: %1$s, 나이: %2$d, "김자바", 25); //이름: 김바자, 나이: 25printf()의 형식 문자열에서 % 와 conversion(변환 문자)는 필수로 작성하고 그 외의 항목은 생략 가능
% 는 형식 문자열의 시작을 뜻하고, conversion에는 제공되는 값의 타입에 따라 d(정수), f(실수), s(문자열)를 입력
형식 문자열에 포함될 값이 두 개 이상일 경우 값의 순번(argument_index$)을 포함시켜야 함
flags는 빈 공간을 채우는 방법인데, 생략되면 왼쪽이 공백으로 채워지고 -가 오면 오른쪽이 공백으로 채워짐
0은 공백 대신 0으로 채움
width는 소수점을 포함한 전체 자릿수
. precision은 소수 이하 자릿수
자주 사용되는 형식 문자열
| 형식화된 문자열 | 설명 | 출력 형태 | |
| 정수 | %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 | 줄바꿈 | ||
| %% | % | % | |
package ch02.sec12;
public class PrintfExample {
public static void main(String[] args) {
int value = 123;
System.out.printf("상품의 가격: %d원\\n", value); //상품의 가격: 123원
System.out.printf("상품의 가격: %6d원\\n", value); //상품의 가격: 123원
System.out.printf("상품의 가격: %-6d원\\n", value); //상품의 가격: 123 원
System.out.printf("상품의 가격: %06d원\\n", value); //상품의 가격: 000123원
double area = 3.14159 * 10 * 10;
System.out.printf("반지름이 %d인 원의 넓이: %10.2f\\n", 10, area); //반지름이 10인 원의 넓이: 314.16
String name = "홍길동";
String job = "도적";
System.out.printf("%6d | %-10s | %10s\\n", 1, name, job); // 1 | 홍길동 | 도적
}
}
키보드 입력 데이터를 변수에 저장
키보드로부터 입력된 데이터를 읽고 변수에 저장하는 가장 쉬운 방법은 Scanner를 사용하는 것
아래와 같이 Scanner 타입 변수를 선언하고, 대입 연산자 =를 사용해 new 연산자로 생성한 Scanner 객체를 변수에 대입함
Scanner scanner = new Scanner(System.in);
//scanner 변수 선언 = Scanner 객체 생성
아래와 같이 scanner.nextLine()을 실행하면 키보드로 입력된 내용을 문자열로 읽고 좌측 String 변수에 저장할 수 있음
scanner.nextLine()은 Enter키가 입력되기 전까지 블로킹(대기) 상태가 되며, Enter키가 입력되면 지금까지 입력된 모든 내용을 문자열로 읽음
String inputData = scanner.nextLine();
//String 변수 선언 = Enter키를 누르면 입력된 문자열을 읽음
package ch02.sec12;
import java.util.Scanner;
public class ScannerExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("x 값 입력: ");
String strX = scanner.nextLine();
int x = Integer.parseInt(strX);
System.out.print("y 값 입력: ");
String strY = scanner.nextLine();
int y = Integer.parseInt(strY);
int result = x + y;
System.out.println("x + y: " + result);
System.out.println();
while(true) { //중괄호 {} 안을 무한히 반복 실행
System.out.print("입력 문자열: ");
String data = scanner.nextLine();
if(data.equals("q")) { //입력 문자열이 q라면 반복을 중지
break;
}
System.out.println("출력 문자열: " + data);
System.out.println();
}
System.out.println("종료");
}
}
자바는 기본 타입(byte, short, int, long, float, double, boolean) 값이 동일한지 비교할 때는 ==를 사용하고, String 타입 값이 동일한지 비교할 때는 equals()를 사용
boolean result = data.equals("문자열");
//data와 변수의 문자열을 비교해서 같으면 true, 다르면 false'공부기록 > 자바' 카테고리의 다른 글
| Chapter 06. 클래스 (0) | 2022.12.18 |
|---|---|
| Chapter 05. 참조 타입 (0) | 2022.11.23 |
| Chapter 04. 조건문과 반복문 (0) | 2022.11.22 |
| Chapter 03. 연산자 (0) | 2022.11.21 |
| Chapter 01. 자바 시작하기 (0) | 2022.11.19 |
댓글