TIL - 02. 변순데? [230713]
Always Expect the Unexpected Because the Only Certainty Is Uncertainty.
오직 확실한 것은 불확실성이므로 항상 예기치못한 변수에 대비해야 한다.
-어니 J. 젤린스키
개발자 공부를 하게 된 것도 변수였을까.
인생은 알다가도 모르겠지만 개발은 그냥 모르겠다.
그러므로 복습을 통해 대비를 해보자.
Data(값) 처리 과정
프로그램 실행 시 사용할 값(Data)이 있다면 그 값은 먼저 메모리에 기록 되어야 함
변수
메모리(RAM)에 값을 기록하기 위한 공간
변수 사용의 장점
- 가독성이 좋아짐
- 재사용성 증가로 인한 코드량 감소
- 유지보수 용이
데이터 저장 단위
저장 공간이 제한적이기 때문에 저장 크기에 대한 기준과 CPU가 데이터를 처리할 때 일정한 기준 필요
비트(bit)
컴퓨터가 나타내는 데이터의 최소 저장 단위로서 2진수 값 하나를 저장할 수 있는 메모리공간을 의미
바이트(byte)
데이터 처리 또는 문자의 최소 단위로서 8개의 비트가 모여 하나의 바이트가 구성됨
변수의 선언
메모리 공간에 데이터를 저장할 수 있는 공간을 할당하는 것
자료형(Type)
변수 저장 가능 범위
변수의 명명 규칙
-
대소문자가 구분되며 길이 제한이 없다.
-
예약어를 사용하면 안 된다.
ex) true, final, String 등 -
숫자로 시작하면 안 된다.
ex) age1은 가능하지만 1age는 불가능 -
특수문자는 ‘_’와 ‘$’만을 허용한다.
- ‘$’는 내부 클래스에서 사용
- ‘_’ 사용 시 컴파일 에러는 없지만 관례상 사용하지 않는 것이 좋음
ex) sh@rp는 불가능하지만 $harp는 가능
- 여러 단어 이름은 단어의 첫 글자를 대문자로 한다.
단, 첫 시작 글자는 소문자로 하는 것이 관례이다.
ex) ageOfVampire, userName
값 대입과 리터럴
값 대입 : 생성한 변수(저장 공간)에 값을 대입하는 것
int age;
age = 10;
age = 20;
* 변수는 한 개의 데이터만 보관, 마지막에 대입한 값만 보관리터럴 : 변수에 대입되는 값 자체
short s = 32767; char c = ‘A’;
int i = 100; String str = “ABC”;
long l = 10000L;
float f = 0.123f;
double d = 3.14;변수의 초기화
변수를 사용하기 전에 처음으로 값을 저장하는 것
지역변수는 반드시 초기화 해야 된다.
선언 후 초기화
int age;
age = 100;
선언과 동시에 초기화
int age = 100;상수란?
수학에서는 변하지 않는 값 의미
컴퓨터(Java)에서는 한 번만 저장(기록)할 수 있는 메모리 의미
상수 선언 방법
final int AGE;
상수 초기화 방법
1) 선언과 동시에 초기화
final int NUM = 100;
2) 선언 후 초기화
final int NUM;
NUM = 100;문자열
컴퓨터에서 “기차“, “출력하세요“등과 같이 단어나 문장을 문자열이라고 표현
“”로 묶여 있으면 문자열로 인식하며 Java에서는 String 객체를 이용하여 저장
String str = “기차”;
String str = new String(“기차”);
String str = “기차” + “칙칙폭폭”;
String str = new String(“기차” + “칙칙폭폭”);
String str = “기차” + 123 + 45 + “출발”;
String str = 123 + 45 + “기차“ + “출발”;
다른 자료형 + “문자열” 문자열
“문자열” + 다른 자료형 문자열원의 둘레, 넓이, 원기둥의 부피, 구의 겉넓이
package edu.kh.variable.ex1;
public class VariableExample1 {
// 생성된 .java 파일과 class 오른쪽에 작성된 이름은 같아야 한다.
public static void main(String[] args) {
System.out.println(2 * 3.141592653589793 * 5);
System.out.println(3.141592653589793 * 5 * 5);
System.out.println(3.141592653589793 * 5 * 5 * 20);
System.out.println(4 * 3.141592653589793 * 5 * 5);
/* 변수(Variable)
* - 메모리(RAM)에 값을 기록하는 공간
* -> 공간에 기록되는 값(Data)이 변할 수 있어서 변수라고 한다.
*
* - 변수는 여러 종류 존재(저장되는 값의 형태, 크기가 다름)
* 0
* 변수 사용의 장점
*
* 1. 가독성 증가(읽기 편해짐)
* 2. 재사용성 증가(한번 만든 변수를 계속 사용)
* 3. 코드 길이 감소
* 4. 유지보수성 증가(코드 수정이 간단해짐)
*
* */
// 변수 사용
double pi = 3.141592653589793; // 원주율
int r = 5; // 반지름(radius)
int h = 20; // 높이(height)
System.out.println("-----------------");
System.out.println(2 * pi * r); // 원의 둘레
System.out.println(pi * r * r); // 원의 넓이
System.out.println(pi * r * r * h); // 원기둥의 부피
System.out.println(4 * pi * r * r); // 구의 겉넓이
}
}출력결과
31.41592653589793
78.53981633974483
1570.7963267948967
314.1592653589793
31.41592653589793
78.53981633974483
1570.7963267948967
314.1592653589793자료형
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, 유니코드)
*
*/
// 변수 선언 : 메모리에 값을 저장할 공간을 할당하는 것
// 변수 값 대입(집어넣기) : 변수에 값을 집어 넣는 것
// * 카멜(낙타) 표기법
// 연결되는 두 단어 중 후속단어의 첫 문자를 대문자로 표기
boolean booleanData;
// 메모리에 논리 값(t/f)을 저장할 공간을 1byte 할당하고
// 할당된 공간을 booleanData라고 부르겠다.
booleanData = true; // booleanData 변수에 true 값을 집어 넣기
System.out.println("booleanData : " + booleanData);
byte byteNumber = 127; // 128 넣는 순간 에러
// 메모리에 정수 값을 저장할 공간을 1byte 할당하고
// 할당된 공간을 byteNumber라고 부르겠다.
// 선언된 byteNumber변수에 처음으로 127을 집어넣음.
// --> 초기화 : 처음 변수에 값을 대입
System.out.println("byteNumber : " +byteNumber);
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);
System.out.println("ch2 : " + ch2);
// 변수 명명 규칙
// 1. 대소문자 구분, 길이제한 X
int abcdefg123456789;
int abcdefG123456789;
// 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번);
// -------------------------------------------------------
int number = 10;
System.out.println("number : " + number); // 10
number = 20;
System.out.println("number : " + number); // 20
final double PI_VALUE = 3.14;
//PI_VLUE = 2.32222; // 에러 ! 재대입 불가 !
/* 상수(항상 같은 수) :
* - 변수 한 종류
* - 한번 값이 대입되면 다른값을 재대입 할 수 없음!
* - 자료형 앞에 final 키워드를 작성
*
* - 상수 명명 규칙 : 모두 대문자, 여러단어 작성 시 _ 사용
*
* - 상수를 사용하는 경우
* 1) 변하면 안되는 고정된 값을 저장할 때
* 2) 특정한 값에 의미를 부여하는 경우
*
*/
final int LEFT_MOVE = -1;
final int RIGHT_MOVE = 1;
System.out.println(1+1.3);
}
}
출력결과
booleanData : true
byteNumber : 127
ch : A
ch2 : B
3.14
number : 10
number : 20
2.3형변환
값(Data)의 자료형을 바꾸는 것 (boolean 제외)
컴퓨터의 값 처리 원칙
같은 종류 자료형만 대입 가능
같은 종류 자료형만 계산 가능
계산의 결과도 같은 종류의 값이 나와야 함
-> 이러한 원칙이 지켜지지 않은 경우에 형변환이 필요함
형변환 예시
123456789 → 123456789.0
(int) (double)
‘A’ → 65
(char) (int)
3.14f → 3
(float) (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));
// 원래 에러가 발생해야 되지만 "자동 형변환" 덕분에 발생하지 않음.
int i1 = 3;
double d1 = i1;
System.out.println("i1 : " + i1); // 3
System.out.println("d1 : " + d1); // 3.0
// double은 실수만 저장할 수 있는 자료형
// 정수가 대입되는 연산이 수행되면
// 정수 -> 실수로 자동 형변환
System.out.println(d1 + num2); //double + double
// 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);
// char -> int 형변환
/* char 자료형은 문자형이지만 실제 저장하는 값은
* 0부터 6만5천번 사이에 있는 숫자
*/
char ch3 = 'V';
int i3 = ch3;
System.out.println(i3);
char ch4 = '각';
int i4 = ch4;
System.out.println(i4);
// 오버플로우 현상은 컴퓨터가 미리 예측할수가 없다!!!
// -> 개발자가 미리 예측해야함.
int i6 = 2147483647; // int의 최대값
int result6 = i6 + 1;
System.out.println(result6); //-2147483648
}
}
출력결과
자동 형변환 결과 : 13.5
i1 : 3
d1 : 3.0
6.5
result2 : 12100000000
86
44033
-2147483648데이터 오버플로우
변수와 메모리 구조
출력메소드
System.out.print( )
() 안의 변수, 문자, 숫자, 논리 값을 모니터에 출력해주는 메소드
System.out.println( )
print문과 동일하게 출력은 해주지만 출력 후 자동으로 출력창에 줄바꿈을 해주는 메소드
System.out.printf(“%형식”, 변수 등)
정해져 있는 형식에 맞춰서 그 형식에 맞는 값(변수)을 줄바꿈 하지 않고 출력
정렬방법
- %5d : 5칸을 확보하고 오른쪽 정렬
- %-5d : 5칸을 확보하고 왼쪽 정렬
- %.2f : 소수점 아래 2자리까지만 표시
강제 형변환
값의 범위가 큰 자료형을 값의 범위가 작은 자료형으로 변환
강제 형변환 시 데이터 손실이 발생할 수 있음 → 데이터의 변형, 손실을 감수하고 강제 변환
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: connot convert from double to int
System.out.println("temp:" + temp);
System.out.println("num:" + num);
// 실수 -> 정수형 변환 시 소수점 버림 처리(데이터 손실)
// int -> byte 강제 형변환
int iNum = 290;
// byte bNum = iNum; // Type mismatch: cannot convert from int to byte
byte bNum = (byte) iNum;
System.out.println(iNum);
System.out.println(bNum);
// 같은 정수형 끼리의 변환 시에도
// 값의 범위 차이 때문에 데이터 손실이 발생
// char -> int 강제 형변환
char ch = 'A'; // 65
int iNum2 = ch; // 자동 형변환
System.out.println(iNum2) ; // 65
// 강제형변환 이용
System.out.println( (int)ch );
// int -> char 강제형변환
int iNum3 = 44033;
System.out.println( iNum3 + "번째 문자 : " + (char)iNum3);출력결과
temp:3.14
num:3
290
34
65
65
44033번째 문자 : 각강제 형변환 연습문제
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( (float)iNum1 ); // 10.0
System.out.println( ( (float)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 차이점
System.out.println( iNum1 / fNum ); // 3.3333333
System.out.println( (double)iNum1 / fNum ); // 3.3333333333333335
// 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( ch + iNum1 ); // 75
System.out.println("'" + (char)(ch + iNum1) + "'"); // 'K'
// ch 와 iNum1 더하기 ==> int로 자동형변환
// 그 값을 char 형태로 강제형변환
// 양옆에 + 로 문자열 연결해주기
}
}출력결과
2
2
10.0
10.0
2.5
2.5
3
3
3.3333333
3.3333333333333335
'A'
65
75
'K'
패턴
package edu.kh.variable.ex1;
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 enter
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); // 소수점 둘째자리까지만 나타내고 싶다
System.out.printf("%.0f\n", 10 / 4.0); // 소수점 아래를 표현하지 않겠다
// 문자, 문자열, 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출력
// 한공간씩 표현X, 한번에 공간차지
// 유니코드 이스케이프
System.out.println("\u0041");
// 유니코드(16진수)
// 65를 16진수로 표현
// 65 나누기 16하면 몫 4고, 나머지 1
}
}출력결과
테스트1
테스트2
테스트3
테스트4
10 + 5 = 15
10 + 5 = 15
10 + 10 * 5 / 2 = 35
10 + 10 * 5 / 2 = 35
3
3
3
2.500000
2.50
3
false / 조 / 안녕하세요
\
\o/
a b c d
A```
---
초보자