🔗 복습하기
- 변수란, 하나의 값을 저장할 수 있는 메모리 공간임.
- 변수 선언은
변수타입+변수이름형식으로 선언함.
- 변수 선언은
- 식별자란, 프로그램 코드 안에서 정의된 element(원소)를 구분하기 위한 이름.
- 리터럴이란, 변수선언 시에 초기값 또는 변수 사용 시에 새로 할당된 값.
정수 리터럴,실수 리터럴,문자 리터럴,문자열 리터럴,논리문자 리터럴
- 이스케이프 문자란,
\가 포함된 문자 리터럴(literal). - 데이터는 메모리의 최소 기억단위인
bit8개가 모여byte1개를 형성함 - char은
문자형 리터럴로''안에 문자를 관리하기 위한 타입임.
👩🏻💻 변수 생명 주기(life cycle)
1️⃣변수의 생명주기(life cycle)
🔍변수의 생명주기(life cycle)이란?
-
수가 생성, 사용, 소멸 과정.
-
변수의 생명(존재) 유지하는 것은 메모리에 있을 경우에만 사용 가능
변수가 메모리에 존재해야만, 변수의 메모리 값을 읽고 수정할 수 있음
-
자바에서 변수의 생명주기는 {} 안에서만 살아 있음
예시, parentNum 변수는 main 메소드에서만 살아있음
childNum변수는 if문 안에서만 살아 있음
-
✍️ 변수 생명 주기 (실습)
⌨️ coding ⤵️
package p05.local_variable_scope;
public class LocalVariableScopeEx {
public static void main(String[] args) {
int parentNum =20;
if (parentNum > 10) {
int childNum = parentNum - 10;
System.out.println("parentNum =" + parentNum);
System.out.println("childNum =" + childNum);
}
System.out.println("parentNum =" + parentNum);
// System.out.println("childNum =" + childNum);//에러
//childNum변수는 if문 안에서만 살아 있음, if문 밖에서 사용불가
}
// parentNum = 30; //에러
// parentNum 변수는 main 메소드에서만 살아있음
}🖥 print ⤵️
👩🏻💻 데이터 타입(data type)
1️⃣기본(primitive) 타입
기본(primitive) 타입은
정수, 실수, 문자, 논리 리터럴(literal)을 직접 저장하는 타입이다.
컴퓨터는 모든 숫자를 2진수로 관리함
➡️ 10진수로 된 실수값을 2진수로 변환할 때 *무리수로 나오는 문제가 생김.
*무리수 : 두 정수의 비의 형태로 나타낼 수 없는 실수를 말한다. 즉, 분수로 나타낼 수 없는 소수를 의미함.
👩🏻💻 데이터 타입(data type)의 종류
1️⃣실수 타입 float과 double
-
실수값 *리터럴(literal)의 기본 타입은
double(8)임.- 실수 리터럴(literal)
float(4)에 넣을 경우 리터럴(literal) 끝에F를 붙여서 실행 가능.
➡️ 이후에 나올👩🏻💻 타입 변환에3️⃣ 강제적 타입 변환의 내용
- 실수 리터럴(literal)
-
float길이 제약이 있어서double보다 결과 정확도가 떨어짐.
*리터럴(literal) : 소스 코드 내에서 직접 입력된 변수의 초기값
<3️⃣ 강제적 타입 변환 예시>
3.14 값을 4byte인 float을 8byte로 생성해 달라는 명령어 F
float var2 = 3.14F;
float var2 = 3.14f;
✍️ 실수 타입 float과 double (실습)
⌨️ coding ⤵️
package p02.datapython_basic;
public class FloatDoubleEx {
public static void main(String[] args) {
double var1 = 3.14; //double은 8바이트
// float var2 = 3.14; //float은 4바이트, 3.14는 8바이트--> 오류 발생
float var2 = 3.14f; // 실행됨
double var3 = 3.14;
double var4 = 0.123456789012345679;
float var5 = 0.123456789012345679f;
//float 길이 제약이 있어서 결과 정확도가 double보다 떨어짐
double var6 =3e6; // 3*10**6, (E : Exponential)
float var7 = 3e6F;
double var8= 2e-3; // 3*10**-3
System.out.println("var1 = " + var1);
System.out.println("var2 = " + var2);
System.out.println("var3 = " + var3);
System.out.println("var4 = " + var4);
System.out.println("var5 = " + var5);
System.out.println("var6 = " + var6);
System.out.println("var7 = " + var7);
System.out.println("var8 = " + var8);
}
}🖥 print ⤵️
2️⃣정수 타입 int
정수 타입 int(4) 리터럴
-
8진수10진수16진수사용 가능함. -
통신 프로그램에서 주로 사용함.
👨🏻🏫 : "실무에서는 잘 사용하지 않습니다."
✍️ 정수 타입 int 리터럴 예제(실습)
⌨️ coding ⤵️
package p02.datapython_basic;
public class IntEx {
public static void main(String[] args) {
int var1 = 10; //10진수
int var2 = 012; //8 진수 : 리터럴 첫번째에 0을 넣으면 8진수
int var3 = 0xA; // 16진수
System.out.println("var1 = " + var1);
System.out.println("var2 = " + var2);
System.out.println("var3 = " + var3);
}
}🖥 print ⤵️
3️⃣정수 타입 Long
- 정수 타입 리터럴(literal)의 기본은 4byte임.
- 하지만
Long(8)type은 8byte임.
- 하지만
Long(8)type 리터럴(literal)로 만들고 싶을 때,
리터럴(literal) 끝에L을 붙이면 8byte로 메모리로 사용 가능.
➡️ 이후에 나올👩🏻💻 타입 변환에2️⃣ 자동적 타입 변환의 내용
✍️ 정수 타입 Long 예제(실습)
⌨️ coding ⤵️
package p02.datapython_basic;
public class LongEx {
public static void main(String[] args) {
long var1 = 10; // 10은 4바이트에 만듦
long var2 = 10L; // 10L은 8바이트에 만듦
// long var3 = 100000000000000; //숫자가 너무 길어서 오류
long var3 = 100000000000000L; // L을 붙이면 긴 숫자 사용 가능
System.out.println("var1 = " + var1);
System.out.println("var2 = " + var2);
System.out.println("var3 = " + var3);
}
}
🖥 print ⤵️
3️⃣논리 타입 Boolean
✍️ 논리 타입 Boolean(실습)
⌨️ coding ⤵️
//🖥 print ⤵️
[출력이미지]
📌 상수의 데이터 타입(내용추가)
다음에 나올 내용인 👩🏻💻 타입변환(형변환)을 잘 이해하려면 상수의 데이터 타입을 집고 넘어가야 한다.
🔍상수란?
변수의 반대말로, 변하지 않는 수를 의미함.
<변수와 상수 예시>
int a = 10;여기서 변수는 a이고 상수는 10이다.
10은 언제나 10이다.
10이 혼자서 a가 되는 경우는 없다.
a는 혼자 있으면 a이지만, 위 식이 성립되면 a는 10이 된다.
1️⃣상수의 데이터 타입
다음 코드에서 에러가 발생하는 이유가 무엇일까?
int a = 10
int a = 10.0; // --> 에러 발생수학에서 10.0은 그냥 10이지만, 컴퓨터에서 10.0과 10은 전혀 다른 값이다.
컴퓨터에서 소수점이 붙는 순간 실수로 구분된다.
➡️ 그렇다면 실수 10.0을 받는 변수의 데이터 타입을 바꿔주면 에러가 수정될까?
int a = 10
float a = 10.0; // --> 여전히 에러 발생실수10.0을 받는 변수타입을 정수형인 int타입에서 실수형인 float으로 수정했지만,
여전히 에러는 수정되지 않았다. 왜일까?
상수에도 데이터 타입이 있기 때문이다.
상수는 기본적으로 정수는 int데이터 타입을 갖고, 실수는 double타입을 갖는다.
int a = 10
double a = 10.0; // --> 에러 수정됨.💡 이후에 나올 👩🏻💻 타입변환에 3️⃣ 강제(명시적) 타입 변환: Casting에서
double타입을 갖는 상수(즉, 소숫점을 갖는 수)를 강제로 정수 타입으로 변환하는 방법을 배운다.
그 방법은 좋지 않다. 실수 타입을 정수 타입으로 만들면 데이터가 유실되기 때문이다. 다시말해 출력시 소숫점 이후의 값이 유실된다.
결론적으로, 꼭 필요한 경우가 아니라면 변수와 상수의 타입이 달라서 오류가 났을 때 변수타입을 수정하는 것이 좋다.
👩🏻💻 타입변환
1️⃣타입변환
🔍타입변환이란?
- 데이터 타입을 다른 타입으로 변환하는 것.
- Promotion : 자동적(묵시적) 타입 변환
- Casting : 강제적(명시적) 타입 변환
2️⃣자동적(묵시적) 타입 변환: Promotion
- 작은 데이터 타입(작은 데이터 값)에서 큰 데이터 타입으로 자동 변환됨.
- 작은 곳에서 큰 곳으로.작은 집에서 큰 집으로 이사감. ➡️ 문제 없음.
-
정수형 산술연산(
bytecharshortintlong)에서 자동타입변환(promotion)-
int(4)보다 작은byte(1)char(2)short(2)를 사용하여 산술연산을 수행하면 무조건int(4)타입 자동형변환(promotion)
-
정수형
long(8)타입 이나 실수형float(4)double(8)등의 타입과 다른 타입과 산술 연산을 수행하면 큰 데이터 타입으로 자동변환
-
<변환 과정 예시>
int var1 = 10;
리터럴 10을 int(4)로 메모리를 생성했을 때,
➡️ int(4) 타입인 var1에 넣기 위해 long(8) 타입인 8byte로 확장함.
➡️ var1에 넣음.
ex) int(4) -> long(8), int(4) -> float(4)
✍️ 자동적 형변환(Promotion) 예제 (실습)
출처: https://taisou.tistory.com/754 [Release Center:티스토리]
⌨️ coding ⤵️
package p03.datatypes_promtion;
public class PromotionEx {
public static void main(String[] args) {
byte byteValue = 10; // 정수인 상수는 기본적으로 int 타입을 갖음
int intValue = byteValue; // 그래서 int 타입에 들어가도
System.out.println("intValue = " +intValue);
char charValue = '가';
intValue = charValue;
System.out.println("intValue = " +intValue);
long longValue = 500;
System.out.println("longValue = " +longValue);
float floatValue = longValue;
System.out.println("floatValu = " +floatValue);
double doubleValue =longValue ;
System.out.println("doubleValue = " +doubleValue);
}
}
🖥 print ⤵️
✍️ 자동적 형변환(Promotion) 순서 정리 (실습)
⌨️ coding ⤵️
package p03.datatypes_promtion;
public class TypeConvertsionInExpressionEx {
public static void main(String[] args) {
byte b1 = 42;
byte b2 = 10;
byte sum;
char c1 = 20;
char c2 = 30;
char csum;
long l1 = 15;
long lresult;
// sum = b1 + b2;
/*
* <sum = b1 + b2; 수행 에러 기계어로 표현 순서 정리>
* 1. byte 타입인 b1을 int 타입으로 promotion(즉, 1바이트 -> 4바이트로 메모리 확장)
* 2. byte 타입인 b2를 int 타입으로 promotion
* 3. b1+ b2 수행
* 4. int 타입인 결과값을 byte 타입이 sum 넣으면
--> 에러 발생
*/
sum =(byte) (b1 + b2); //(byte)를 넣어 int로 강제형변환
// 아니면
int isum; //강제형변환을 쓰지 않는 방법
isum = b1 +b2;
// csum1 = c1 +c2; --> 에러, int타입으로 강제형변환 해야함
//----------------------------------------------------------------
lresult = b1 + c1 + l1;
/*
* <result = b1 + c1 + l1; 변환 순서 정리>
* 1. b1 + c1 연산하면 int 타입으로 변환 메모리 4바이로 저장
* 2. 위 결과 값(4바이트)과 l1의 덧셈 연산하기 위해서
* 2-1. b1 + c1의 결과 값(4바이트)을 8바이트인 long타입으로 변환
* 2-2. l1과 덧셈 연산 수행
* 3. 최종값을 long타입인 lresult에 넣음
*/
//----------------------------------------------------------------
result = l1 + 0.5;
/*
* < long 타입인 l1과 double 타입인 0.5를 덧셈 기계어 >
* 1. l1을 double 타입으로 변환
* 2. 0.5를 더하여 연산결과 double 타입으로 만듦
*/
//다른 방법
double dresult;
dresult = l1 + 0.5;
}
}
3️⃣강제(명시적) 타입 변환: Casting
-
큰 데이터 타입에서 작은 데이터 타입으로 변환시 강제적 형변환(casting)이 필요함.
- 코딩할 때, 강제적 형변환(casting)을 실행한다는 의사 표현을 해줘야 함.
< casting 형변환 예시 >
long l = (long) d;
double타입을long타입에 넣기(강제적 형변환)
➡️ 리터럴 앞에(long)을 넣어 어떤 타입에 담겼는지 표시
강제형변환의 문제점
-
큰 테이터 타입이 작은 데이터 타입으로 변환하는것: Castion
- 기존 데이터값이 보존 되지 않음.
👨🏻🏫 : "강제적 형변환(casting)을 할 때, 데이터 유실을 고려해서 시행해야 합니다. 유실된 데이터는 돌아오지 않아요..!!!"
💡 강제적 형변환(casting) 사용하는 TIP
casting이 가능한지 MIN_VALUE, MAX_VALUE를 check하여 확인할 것.
✍️ 강제적 형변환(Casting) 기계어로 표현 순서(실습)
⌨️ coding ⤵️
package p03.datatypes_promtion;
public class TypeConvertsionInExpressionEx {
public static void main(String[] args) {
byte b1 = 42;
byte b2 = 10;
byte sum;
char c1 = 20;
char c2 = 30;
char csum;
sum = b1 + b2; // --> 에러
/*
* <sum = b1 + b2; 수행 에러 기계어로 표현 순서 정리>
* 1. byte 타입인 b1을 int 타입으로 promotion(즉, 1바이트 -> 4바이트로 메모리 확장)
* 2. byte 타입인 b2를 int 타입으로 promotion
* 3. b1+ b2 수행
* 4. int 타입인 결과값을 byte 타입이 sum 넣으면
--> 에러 발생
(큰 타입에서 작은 타입으로 변환시 장제적 변환 필요)
*/
sum =(byte) (b1 + b2); //(byte)를 넣어 int로 강제형변환
// 아니면
int isum; //강제형변환을 쓰지 않는 방법
isum = b1 +b2;
// csum1 = c1 +c2; --> 에러, int타입으로 강제형변환 해야함
}
}
✍️ 강제적 형변환(Casting)하는 방법 (실습)
⌨️ coding ⤵️
package p04.datatypes_casting;
public class CastingEx {
public static void main(String[] args) {
char ch = 'A'; // 아스키코드
int inumber = 88; // 10진수
double d = 100.04;
long l = (long) d;
// double 타입을 long 타입에 넣기(강제적 형변환)
// --> 리터럴 앞에 (long)을 넣어 어떤 타입에 담겼다는 표시 넣기
System.out.println("l = " + l);
int i = (int) l;
//int 타입으로 강제 형변환(casting) 하면 소숫점 이하 숫자는 삭제됨.
System.out.println("i = " + i);
System.out.println("ch = " + ch);
//-------------------------------------------------------
ch = (char) inumber;
// int 타입인 number을 char 타입으로 강제 형변환(casting)
// --> 아스키코드 10진수 88은 문자 X
System.out.println("ch = " + ch);
}
}
🖥 print ⤵️(수정)
✍️ 강제적 형변환(Castiong)의 문제;데이터 유실(실습)
⌨️ coding ⤵️
package p04.datatypes_casting;
public class CastiongEx2 {
public static void main(String[] args) {
byte byteValue = 0 ;
int intValue = 257;
double doubleValue = 323.142;
byteValue =(byte) intValue;
// 강제형변환의 문제 : 데이터 유실
// -> 4바이트 -> 1바이트만 남기고 전부 삭제
// -> 나머지 3바이트 유실 , 복구 불가
System.out.println("byteValue = " + byteValue);
intValue = (int) doubleValue;
System.out.println("intValue = " + intValue);
//
}
}🖥 print ⤵️
4️⃣강제적 형변환(Casting) 가능 여부 확인하기.
💡 강제적 형변환(casting) 사용하는 TIP
casting이 가능한지 MIN_VALUE, MAX_VALUE를 check하여 확인할 것.
- casting 실행시 데이터 유실이 있을 수 있기 때문에 확인이 필요함.
✍️ 강제적 형변환(casting)시 변환 가능 여부 출력하기.(실습)
⌨️ coding ⤵️
package p04.datatypes_casting;
public class ByteTypeMinMaxCheckEx {
public static void main(String[] args) {
int num = 128;
System.out.println("바이트 최소값 : " + Byte.MIN_VALUE);
System.out.println("바이트 최대값 : " + Byte.MAX_VALUE);
if ((num < Byte.MIN_VALUE) || (num > Byte.MAX_VALUE)) {
System.out.println("바이트 타입으로 변환할 수 없습니다.");
} else {
byte bNum = (byte) num;
System.out.println("bNum = "+ bNum);
}
// < if문 해석 >
// --> num을 byte 타입으로 변환 가능한가?
// 가능 하면, byte 타입으로 변환해서 출력하기.
// 아니면 "바이트 타입으로 변환할 수 없습니다." 출력하기.
}
}
🖥 print ⤵️
👩🏻💻 연산자(Operator)
1️⃣연산(Operate)
🔍연산(Operate)이란?
- 연산이란, 데이터를 처리하여 결과를 산출하는 것.
🔍연산자(Operator)란?
- 연산에 사용되는 표시나 기호
🔍피연산자란?
- 연산 대상이 되는 데이터
리터럴,변수
ex)
🔍연산식(Expressions)이란?
- 연산자와 피연산자를 이용하여 연산의 과정을 기술한 것.
=오른쪽에 있는 식.
ex) result = a + b;
👩🏻💻 연산자 우선순위(Operator Precedence)
연산자 우선순위(Operator Precedence)
assignment operator인 =을 기준으로,
1. =을 기준 오른쪽에 있는 수식은 왼쪽부터 오른쪽으로 계산함.
2. 왼쪽부터 오른쪽으로 계산할 때, 연산 순위가 높은 연산자를 먼저 연산함.
➡️ * / %가 + -보다 우선 연산.
3. ()가 모든 연산자 보다 우선순위 가장 높음.
💡 연산순위가 제일 높은 () 적극 활용하기!!
👩🏻💻 연산자(Operator) 종류
1️⃣연산자(Operator) 종류
+ - / % * : 산술연산자(arithmetic Operator)
+= -= *= /= %= : 할당 연산자(Assignment Operator)
== != > >= < <= : 비교연산자(Relational Operator)
&&(and) ||(or) !(not)... : 논리연산자(Logical Operato)
외 비트 논리 연산자, 비트 이동 연산자
단항 연산자(Unary Operator)
이항 연산자(Binary Operator)
A ? B : C : 3항 연산자(Ternary Operator)
2️⃣할당 연산자 (Assignment Operator)
-
+=-=*=/=%= -
C 언어에서 주로 상용됨.
<할당 연산자 사용 예시>
아래 두 식이 같은 의미를 값을 출력함.n1 = n1 + 10;
n1 += 10;
✍️ 할당 연산자(Assignment Operator)사용하기.(실습)
⌨️ coding ⤵️
public class AssignmentOperatorEx {
public static void main(String[] args) {
int n1 = 10;
System.out.println("n1 = " + n1);
// n1 = n1 + 10;
n1 += 10; //c언어 스타일
System.out.println("n1 = " + n1);
// n1 = n1 - 10;
n1 -= 10;
System.out.println("n1 = " + n1);
// n1 = n1 * 2;
n1 *= 2;
System.out.println("n1 = " + n1);
// n1 = n1 / 3;
n1 /= 3;
System.out.println("n1 = " + n1);
}
}🖥 print ⤵️(수정)
3️⃣비교연산자 (Relational Operator)
==
(예 , a == b : a와 b의 값이 같으면 true, 틀리면 false.)!=
(예 , a != b : a와 b의 값이 같으면 false, 틀리면 true.)>
(예 , a > b : a가 b보다 값이 크면true , 작으면 false)>=
(예 , a >= b : a가 b보다 값이 크 같으면 true , 작으면 false)<
(예 , a < b : a가 b보다 값이 크면false , 작으면 true)<=
(예 , a <= b : a가 b보다 값이 크거나 같으면false , 작으면 true)
✍️ Relational Operator(비교연산자)(실습)
⌨️ coding ⤵️
package p01.basic;
public class RelationalOperatorEx {
public static void main(String[] args) {
int a1 = 5;
int a2 = 10;
int a3 = 5;
boolean bresult;
System.out.println("a1 == a2" + (a1 == a2));
System.out.println("a1 == a3" + (a1 == a3));
bresult = (a1 == a2);
System.out.println("bresult = " + bresult);
bresult = (a1 == a3);
System.out.println("bresult = " + bresult);
System.out.println("a1 != a2 : " + (a1 != a2));
System.out.println("a1 != a3 : " + (a1 != a3));
System.out.println("a1 > a2 : " + (a1 > a2));
System.out.println("a1 < a3 : " + (a1 < a3));
System.out.println("a1 >= a2 : " + (a1 >= a2));
System.out.println("a1 <= a3 : " + (a1 <= a3));
}
}
🖥 print ⤵️
4️⃣논리연산자(Logical Operato)
&& and
|| or
! not
...
✍️ 논리연산자(Logical Operato)(실습)
⌨️ coding ⤵️
package p01.basic;
public class LogicalOperatorEx {
public static void main(String[] args) {
int a1 = 10;
int a2 = 20;
int a3 = 20;
int a4 = 0;
boolean bresult;
bresult = (a1 < a2) && (a2 == a3);
System.out.println("bResult = " + bresult);
bresult = (a1 < a2) || (a2 == a3);
System.out.println("bResult = " + bresult);
bresult = (a1 > a2) && (a2 == a3);
System.out.println("bResult = " + bresult);
bresult = (a1 > a2) || (a2 == a3);
System.out.println("bResult = " + bresult);
bresult = !(a1 > a1);
System.out.println("bresult = " + bresult);
}
}
🖥 print ⤵️
5️⃣단항 연산자(Unary Operator)와 이항 연산자(Binary Operator)
🔍단항 연산자(Unary Operator)란?
피연산자(operator)가 한 개인 연산자를 의미함.
🔍이항 연산자(Binary Operator)란?
피연산자(operator)가 2개인 연산자를 의미함.
✍️ 단항 연산자(Unary Operator)와 이항 연산자(Binary Operator)(실습)
⌨️ coding ⤵️
package p01.basic;
/*
* Unary Operator(단항연산자)
* + - : 피연산자 앞에 붙여 사용할 경우
* Binary Operator(이항 연산자)
* 피연산자(operator)가 2개인 경우 (산술연산자 : + - * /)
*
*/
public class UnaryOperatorEx {
public static void main(String[] args) {
int n1 = 20;
int result;
result = +n1 ;
System.out.println("result = " + result);
result = -n1 ;
System.out.println("result = " + result);
}
}
🖥 print ⤵️
1️⃣3항 연산자(Ternary Operator)
3항 연산자(Ternary Operator)는 피연산자 갯수가 3개 라는 의미를 갖음.
A ? B : C 형식의 식이 있다면,
연산자는 ?, : 2개, 피연산자는 A, B, C 3개 있는 경우
➡️ A가 true 이면 B를 실행하고, A가 false면 C 실행해라
✍️ 3항 연산자(Ternary Operator)(실습)
⌨️ coding ⤵️
package p01.basic;
public class TernaryOperatorEx {
public static void main(String[] args) {
int n1 = 15;
int n2 = 10;
int max;
// A가 ( n1 > n2 )
// B가 n1
// C가 n2
// A가 true이면 B를 실행하고, A가 false면 C실행해라.ㄴ
max = ( n1 > n2 ) ? n1 : n2;
System.out.println("max = " + max);
//3항 연산자를 if문으로 바꾸면,
if ( n1 > n2 ) {
max = n1;
} else {
max =n2;
}
System.out.println("max = " + max);
//----------------------------------------------------------
int result;
result = (n1 > n2)? (n1 + n2) : (n1 - n2);
System.out.println("result = " + result);
}
}
🖥 print ⤵️
