01_변수
* 변수(Variable)
메모리(RAM)에 값(Data)을 기록하기 위한 공간
변수에 기록된 값은 지속적으로 사용 가능
* 데이터 저장 단위
저장 공간이 제한적이기 때문에 저장 크기에 대한 기준과 CPU가 데이터를 처리할 때 일정한 기준 필요
- 비트(bit) : 컴퓨터가 나타내는 데이터의 최소 저장 단위로서 2진수(0,1) 값 하나를 저장할 수 있는 메모리공간을 의미
- 바이트(byte) : 데이터 처리 또는 문자의 최소 단위로서 8개의 비트가 모여 하나의 바이트가 구성됨 ex) 1byte = 256, char = 2byte ( 한글이 있기 때문 )
* 변수의 선언
메모리 공간에 데이터를 저장할 수 있는 공간을 할당하는 것
- 자료형 변수명 ;
- 선언 예시
_[ 기본자료형 ]
// 논리형 변수 선언
boolean isTrue;
// 문자형 변수 선언
char ch;
// 정수형 변수 선언
byte bNum;
short sNum;
int iNum;
long lNum;
// 실수형 변수 선언
float fNum;
double dNum;
_[ 참조형 ]
// 문자열 변수 선언
String str;
ex)
double pi = 3.1415926; // 선언과 동시에 초기화
double pi; // 선언
cf)
String : 메모리 크기 X ( 미리 크기 정해둘 수 없음 )
char : 한 글자만 들어감 'A', 'b', '남', '여', '!'
boolean : 1 > 5 (false), 2 == 2 (true)
int( Integer ) : -4, -3, -2, -1, 0, 1, 2, 3, 4 ...
실수( 소수점이 있는 수 ) : 1.2549, 3.141592 ...
ㄴ float : 소수점 뒤 8자리
ㄴ double : 소수점 뒤 16자리
package edu.kh.variable.ex1;
public class VariableExample2 {
public static void main(String[] args) {
/* 자바 기본 자료형 8가지(암기)
*
* 논리형 : boolean(1byte)
* 정수형 : byte(1byte), short(2byte), int(4byte), long(8byte)
* 실수형 : float(4byte), double(8byte)
* 문자형 : char(2byte, 유니코드)
*
*/
// 변수 선언 : 메모리에 값을 저장할 공간을 할당 하는 것.
// 변수 값 대입(집어넣기) : 변수에 값을 집어 넣는 것.
/*
* int iNum; // 선언
* iNum = 2; // 초기화
* int iNum = 2; // 선언과 동시에 초기화
*/
// * 카멜(낙타) 표기법
// 연결되는 두 단어 중 후속단어의 첫 문자를 대문자로 표기
boolean booleanData;
// 메모리에 논리 값(t/f)을 저장할 공간을 1byte 할당하고
// 할당된 공간을 booleanData라고 부르겠다.
booleanData = true; // booleanData 변수에 true 값을 집어 넣기
System.out.println("booleanData : " + booleanData); // booleanData : true
byte byteNumber = 127; // 128을 넣는순간 에러
// 메모리에 정수 값을 저장할 공간을 1byte 할당하고
// 할당된 공간을 byteNumber라고 부르겠다.
// 선언된 byteNumber변수에 처음으로 127을 집어넣음.
// --> 초기화 : 처음 변수에 값을 대입
System.out.println("byteNumber : " + byteNumber); // byteNumber : 127
short shortNumber = 32767; // 변수 선언 및 초기화
// 정수 자료형 기본형! (short, byte는 옛날 코드 잔재)
int intNumber = 2147483647; // 변수 선언 및 초기화
// 자료형 변수명 = 리터럴;
// 프로그래밍에서는 대입되는 이 데이터(값 자체)를 리터럴 이라는 단어로도 표현합니다!
// ** 리터럴 : 변수에 대입되거나 작성 되어지는 값 자체
// + 자료형에 따라 리터럴 표기법이 다름.
long longNumber = 10000000000L; // L 또는 소문자 l
// The literal 10000000000 of type int is out of range
// -> 100억 이라는 값은 int의 범위를 벗어났다! 21억 몇까지만 가능..
// 뒤에 L을 붙여줌으로써 long 자료형인 것을 나타냄.
float floatNumber = 1.2345f; // F 또는 소문자 f
// 1.2345까지만 쓰면 에러남. 자료형 맨 앞글자인 f 붙여줌.
double doubleNumber = 3.141592;
// double이 실수형 중에서 기본형
// (리터럴 표기법이 없는 실수는 double로 인식)
// d를 뒤에 쓸 수는 있다 -> 3.141592d;
// 실수형은 float, double 두 개 밖에 없기 때문에
// 자바는 double을 그냥 리터럴 표기법 안붙이고 쓰는애로 정함.
// 문자형 리터럴 표기법 : ''(홑따옴표)
// -> 문자 하나
char ch = 'A';
char ch2 = 66;
/* char 자료형에 숫자가 대입될 수 있는 이유?
* - 컴퓨터에는 문자표가 존재하고 있는데
* 숫자에 따라 지정된 문자 모양이 매핑되어 있고
* 'B' 문자 그대로가 대입되면 변수에 숫자 66으로 변환되어 저장
* -> 반대로 생각하면 변수에 애초에 66이라는 숫자를 저장하는 것이 가능!
*
*
*/
System.out.println("ch : " + ch); // ch : A
System.out.println("ch2 : " + ch2); // ch2 : B
}
}* 변수의 명명 규칙
package edu.kh.variable.ex1;
public class VariableExample2 {
public static void main(String[] args) {
// 변수 명명 규칙
// 1. 대소문자 구분, 길이제한 X
int abcdefg123456789;
int abcdefG123456789; // G 다름
// 2. 예약어 사용 X
//double double;
// 3. 숫자 시작 X
//char 1abc;
char a2bc;
// 4. 특수문자 $, _만 사용 가능(하지만 쓰지 않는다)
int $intNumber; // 문제는 없지만 개발자가 직접 이렇게 작성하진 않음
int int_Number; // 자바는 카멜표기법 사용
// _ 작성 표기법 DB에서 사용
// MEMBER_NAME
// 5. 카멜 표기법
// 변수명 작성 시 여러 단어를 이어서 작성하는 경우
// 띄어쓰지 않고 후속 단어 첫 글자를 대문자로 작성.
char helloWorldAppleBananaTomato;
// 6. 변수명은 언어를 가리지 않음. (하지만 쓰지 않음)
int 정수1번;
double 실수2번 = 3.14;
System.out.println(실수2번);
}
}* 상수란?
수학에서는 변하지 않는 값 의미
컴퓨터(Java)에서는 한 번만 저장(기록)할 수 있는 메모리 의미
* 상수 선언 방법
final int AGE;
* 상수 초기화 방법
1) 선언과 동시에 초기화
final int NUM = 100;
2) 선언 후 초기화
final int NUM;
NUM = 100;
* 초기화 이후 다른 데이터(값)을 대입할 수 없다.
package edu.kh.variable.ex1;
public class VariableExample2 {
public static void main(String[] args) {
int number = 10;
System.out.println("number : " + number); // number : 10
number = 20; // 변수이므로 재대입 가능
System.out.println("number : " + number); // number : 20
final double PI_VALUE = 3.14;
//PI_VALUE = 2.32222; // 에러 ! 재대입 불가!
/* 상수(항상 같은 수) :
* - 변수 한 종류
* - 한번 값이 대입되면 다른 값을 재대입할 수 없음!
* - 자료형 앞에 final 키워드를 작성
*
* - 상수 명명 규칙 : 모두 대문자, 여러단어 작성 시 _ 사용
*
* - 상수를 사용하는 경우
* 1) 변하면 안되는 고정된 값을 저장할 때
* 2) 특정한 값에 의미를 부여하는 경우
*
*/
final int LEFT_MOVE = -1;
final int RIGHT_MOVE = 1;
}
}* 형변환(casting)
값(Data)의 자료형을 바꾸는 것 (boolean 제외)
* 컴퓨터의 값 처리 원칙
같은 종류 자료형만 대입 가능
같은 종류 자료형만 계산 가능
계산의 결과도 같은 종류의 값이 나와야 함
-> 이러한 원칙이 지켜지지 않는 경우 형변환이 필요함
* 형변환 예시
123456789(int) -> 123456789.0(double)
'A'(char) -> 65(int)
3.14f(float) -> 3(int)
-> 형변환 하고자 하는 값과 자료형의 표현 범위 차이에 따라 형변환 방법이 나뉨(자동 형변환, 강제 형변환)
* 자동 형변환
값의 범위가 큰 자료형과 값의 범위가 작은 자료형의 연산 시
컴파일러가 자동으로 값의 범위가 작은 자료형을 값의 범위가 큰 자료형으로 변환
ex)
int a = 12;
double d = 3.3;
double result = a + d;
a + d -> 12 + 3.3 -> 12.0 + 3.3 -> 15.3
* 단, byte와 short 자료형 값의 계산 결과는 무조건 int로 처리한다.
package edu.kh.variable.ex1;
public class VariableExample3 {
public static void main(String[] args) {
/* 형변환 (Casting): 값의 자료형을 변환하는 것 (단, boolean 제외)
*
* ** 형변환은 왜 필요할까?
* 컴퓨터는 기본적으로 같은 자료형끼리만 연산이 가능함.
* 다른 자료형과 연산 시 오류 발생.
* --> 이런 상황을 해결하기 위해서 필요한 기술이 형변환.
*
* 자동 / 강제 형변환이 존재.
*
*/
int num1 = 10;
double num2 = 3.5;
System.out.println("자동 형변환 결과 : " + (num1 + num2)); // 자동 형변환 결과 : 13.5
// 원래 에러가 발생해야 되지만 "자동 형변환" 덕분에 발생하지 않음.
int i1 = 3;
double d1 = i1;
System.out.println("i1 : " + i1); // i1 : 3
System.out.println("d1 : " + d1); // d1 : 3.0
// double은 실수만 저장할 수 있는 자료형
// 정수가 대입되는 연산이 수행되면
// 정수 -> 실수로 자동 형변환
System.out.println(d1 + num2); // double + double, 6.5
// int -> long 형변환
int i2 = 2_100_000_000; // 21억
long l2 = 10_000_000_000L; // 100억
long result2 = i2 + l2;
//int + long -> long + long = long
System.out.println("result2 : " + result2); // result2 : 12100000000
// char -> int 형변환
/* char 자료형은 문자형이지만 실제 저장하는 값은
* 0부터 6만 5천번 사이에 있는 숫자
*/
char ch3 = 'V';
int i3 = ch3;
System.out.println(i3); // 86
char ch4 = '각';
int i4 = ch4;
System.out.println(i4); // 44033
}
}* 데이터 오버플로우
package edu.kh.variable.ex1;
public class VariableExample3 {
public static void main(String[] args) {
// 오버플로우 현상은 컴퓨터가 미리 예측할 수가 없다!!!
// -> 개발자가 미리 예측해야함.
int i6 = 2147483647; // int의 최대값
int result6 = i6 + 1;
System.out.println(result6); // -2147483648
}
}* 형변환(casting)
* 강제 형변환
값의 범위가 큰 자료형을 값의 범위가 작은 자료형으로 변환
강제 형변환 시 데이터 손실이 발생할 수 있음 -> 데이터의 변형, 손실을 감수하고 강제 변환
double temp;
int name = (int) temp;
* 데이터 손실
package edu.kh.variable.ex1;
public class VariableExample4 {
public static void main(String[] args) {
//main method(메서드) : 자바 어플리케이션(프로그램)을 실행하기 위해 반드시 필요한 메서드
/* 강제 형변환
* - 기존 자료형을 원하는 자료형으로 강제 변환 시키는 것
*
* 1) 값의 범위가 큰 자료형을 작은 자료형으로 변환할 때 사용
* 2) 출력되는 데이터의 표기법을 변환시키고 싶을 때
*
* * 강제 형변환 방법
* - 자료형을 변환 시키고 싶은 값 또는 변수 앞에 (자료형) 을 작성
*
* ex) double temp = 3.14;
* int num = (int) temp;
*
*/
double temp = 3.14;
int num = (int) temp; // Type mismatch: cannot convert from double to int
System.out.println("temp : " + temp); // temp : 3.14
System.out.println("num : " + num); // num : 3
// 실수 -> 정수형 변환 시 소수점 버림 처리(데이터 손실)
// int -> byte 강제 형변환
int iNum = 290;
//byte bNum = iNum; // Type mismatch: cannot convert from int to byte
byte bNum = (byte) iNum;
System.out.println(iNum); // 290
System.out.println(bNum); // 34
// 같은 정수형 끼리의 변환 시에도
// 값의 범위 차이 때문에 데이터 손실이 발생
// char -> int 강제 형변환
char ch = 'A'; // 65
int iNum2 = ch; // 자동 형변환 이용
System.out.println(iNum2); // 65
// 강제형변환 이용
System.out.println( (int) ch ); // 65
// int -> char 강제 형변환
int iNum3 = 44033;
System.out.println( iNum3 + "번째 문자 : " + (char)iNum3 ); // 44033번째 문자 : 각
}
}실습문제
Q.
Package Name : edu.kh.variable.practice
Class Name : CastingPractice1
선언 및 초기화된 5개의 변수를 가지고 알맞은 사칙연산(+, -, *, /)과 형변환을 이용하여 주석에 작성된 값과 같은 결과가 나타나도록 코드를 완성하세요.
A.
package edu.kh.variable.practice;
public class CastingPractice1 {
public static void main(String[] args) {
int iNum1 = 10;
int iNum2 = 4;
float fNum = 3.0f;
double dNum = 2.5;
char ch = 'A';
System.out.println( iNum1 / iNum2 ); // 2
// '/' 나누기한 몫
// '%' 나머지
System.out.println( (int) dNum ); // 2
System.out.println( iNum2 * dNum ); // 10.0
// 4.0 * 2.5 = 10.0
System.out.println( (double) iNum1 ); // 10.0
System.out.println( (double) iNum1 / iNum2); // 2.5
System.out.println( dNum ); // 2.5
System.out.println( (int) fNum ); // 3
System.out.println( iNum1 / (int) fNum ); // 3
// float / double 차이점
// 10 3.0f
System.out.println( iNum1 / fNum ); // 3.3333333
System.out.println( (double) iNum1 / fNum ); // 3.3333333333333335, System.out.println( iNum1 / (double) fNum );
// float : 소수점 아래 8번째 자리까지 연산 후 반올림
// double : 소수점 아래 16번째 자리까지 연산 후 반올림
// ** double은 뒤에가 5로 끝나는 이유?
// -> 컴퓨터는 숫자를 2진수로 표현한다.
// -> 3.33333.. 이런 실수도 11.01011011011.. 이런식으로
// 2진수로 실수를 표현하면 무한히 반복되는 경우가 많다.
// 따라서 일정한 크기만큼 계산하고 적당한 위치에서 잘라내어 반올림하는데
// 2진수 -> 10진수로 변환했을 때
// float 7~8자리까지 자르고, double은 15~16자리까지 자름
// 자르는 위치가 다르니까 숫자도 다르게 나올 수 있다.
// -> 2진수로 소수점 이하를 정확하게 표현하지 못하는 경우가 많아서
// 근사치가 출력되게 된다. 2진수 -> 10진수 변환이 잘못된 경우
System.out.println( "'" + ch + "'" ); // 'A'
System.out.println( (int) ch ); // 65
System.out.println( (int) ch + iNum1 ); // 75, System.out.println( ch + iNum1 );
System.out.println( "'" + (char)((int)ch + iNum1) + "'" ); // 'K', System.out.println( "'" + (char)(ch + iNum1) + "'" );* 변수와 메모리 구조
* 출력메소드
* System.out.print()
() 안의 변수, 문자, 숫자, 논리 값을 모니터에 출력해주는 메소드
* System.out.println()
print문과 동일하게 출력은 해주지만 출력 후 자동으로 출력창에 줄바꿈을 해주는 메소드
* System.out.printf("%형식", 변수 등)
정해져 있는 형식에 맞춰서 그 형식에 맞는 값(변수)을 줄바꿈 하지 않고 출력
* escape 문자
package edu.kh.variable.ex2;
public class PrintExample {
// main작성 ctrl + space + 엔터
public static void main(String[] args) {
// System.out.print() : 단순 출력(출력 후 줄바꿈 X)
// System.out.println() : 한 줄 출력(출력 후 줄바꿈 수행)
// 줄바꿈이라는 차이점은 있지만 괄호안의 내용이 그대로 나온다는 것은 똑같음
System.out.println("테스트1");
System.out.println("테스트2");
System.out.print("테스트3");
System.out.println(); // 내용없는 println 단순 줄바꿈
// 프린트구문 자동완성: syso ctrl + space
System.out.print("테스트4");
// System.out.printf() : 출력될 문자열 형식을 패턴으로 지정하는 출력구문
System.out.println(); // 위에 print 구문 썼으니 줄바꿈 해줌
int iNum1 = 10;
int iNum2 = 5;
// 10 + 5 = 15
System.out.println( iNum1 + " + " + iNum2 + " = " + (iNum1 + iNum2) );
// 중간 오타..
/* printf
*
* %d : 정수형, %o : 8진수, %x : 16진수
* %c : 문자, %s : 문자열
* %f : 실수(소수점 아래 6자리), %e : 지수형태표현, %g : 대입값그대로
* %A : 16진수 실수
* %b : 논리형
*
*/
// System.out.printf("패턴", 패턴에 들어갈 값);
// 10 + 5 = 15
System.out.printf("%d +%d = %d\n", iNum1, iNum2, iNum1+iNum2);
// 줄바꿈하려면 \n 붙혀줘야 한다.
// 10 + 10 * 5 / 2 = 35
System.out.println(iNum1 + " + " + iNum1 + " * " + iNum2 + " / 2 = " + (iNum1 + iNum1 * iNum2 / 2));
System.out.printf("%d + %d * %d / 2 = %d\n", iNum1, iNum1, iNum2, (iNum1 + iNum1 * iNum2 / 2));
// 패턴 연습
int iNum3 = 3;
System.out.printf("%d\n", iNum3);
System.out.printf("%5d\n", iNum3); // 5칸 공간 확보 후 오른쪽 정렬
System.out.printf("%-5d\n", iNum3); // 5칸 공간 확보 후 왼쪽 정렬
// 소수점 자리 제어 (반올림처리)
System.out.printf("%f\n", 10 / 4.0); // 2.500000
System.out.printf("%.2f\n", 10 / 4.0); // 소수점 둘째자리까지만 나타내고 싶다, 2.50
System.out.printf("%.0f\n", 10 / 4.0); // 소수점 아래를 표현하지 않겠다, 3
// 문자, 문자열, boolean
boolean isTrue = false;
char ch = '조';
String str = "안녕하세요"; // String은 참조형(기본자료형을 뺀 나머지)
// false / 조 / 안녕하세요
System.out.printf("%b / %c / %s\n", isTrue, ch, str); // 순서 맞춰야 함, 맞추지 않을 경우 실행 시 에러
// escape(이스케이프 == 탈출) 문자 : 일반 문자가 아닌 특수문자 표현
// \
System.out.println("\\"); // 백슬래시(역슬래시) 출력 방법
// \o/
System.out.println("\\o/");
System.out.println("a\tb\tc\td"); // tab출력 // a b c d
// 한공간씩 표현X, 한번에 공간차지
// 유니코드 이스케이프
System.out.println("\u0041"); // A
// 유니코드(16진수)
// 65를 16진수로 표현
// 65 나누기 16하면 몫 4고, 나머지 1
}
}