열심히 끝까지
Java1 day02 본문
[2일차 수업내용] 연산자(Operator)
연산자(Operator) : 연산을 수행하는 기호 ( +, -, *, / .....)
피연산자 : 연산자와 연산을 수행하려면 반드시 필요한 연산의 대상 => 연산자의 작업 대상
==> ** 기억해 둘 것 : 연산자는 피연산자로 연산을 수행하면 항상 결과값을 반환한다.
식(표현식, Expression) : 연산자와 피연산자를 조합하여 계산하고자 하는 바를 표현하는 것을 식(표현식)이라고 한다.
연산자 종류
| 종류 | 연산자 | 설명 |
| 산술연산자 | +, -, *, /, %, <<, >> | 사칙연산과 나머지 연산 |
| 비교연산자 | >, <, >=, <=, ==, != | 크고 작음과 같고 다름을 비교 |
| 논리연산자 | &&, ||, ~, &, ^ | 그리고(AND)와 또는(OR)으로 조건 연결 |
| 대입연산자 | = | 우변의 값을 좌변에 저장 |
| 기타연산자 | (type), ? :, instanceof | 형변환연산자, 삼항연산자, instanceof연산자 |
연산자의 우선순위와 결합규칙
- 식에 사용된 연산자가 둘 이상일 경우, 연산자의 우선순위에 의해서 연산순서가 결정
- 단항연산자가 이항연산자보다 우선순위가 높음
- 우선순위가 확실하지 않다면, 먼저 계산되어야 하는 부분을 괄호로 묶어주기(괄호 안의 계산식의 우선순위 제일 높음)
- 연산자의 결합규칙은 왼쪽에서 오른쪽, 대입연산자의 결합규칙은 오른쪽에서 왼쪽
<정리>
산술 > 비교 > 논리 > 대입 순서로 진행, 대입은 제일 마지막에 실행
단항(1) > 이항(2) > 삼항(3) 순서로 진행
대입연산자는 연산의 진행방향이 오른쪽에서 왼쪽
산술변환
- 이항연산자는 두 피연산자의 타입이 일치해야 연산이 가능
==> 피연산자의 타입이 서로 다르면 타입 중 더 큰 타입으로 일치시키기
- 두 피연산자의 타입 중 더 큰 타입으로 일치시키는 이유 : 작은 타입으로 형변환하면 원래 값 손실 가능성이 있기 때문
- 작은 타입에서 큰 타입으로 형변환하는 경우, 자동적으로 형변환 연산자 생략 가능
* 두 피연산자의 타입을 일치시킨다(보다 더 큰 타입으로 일치) *
long + int -> long + long
float + int -> float + int
double + float -> double + double
* 피연산자의 타입이 int보다 작은 타입이면 int로 변환 *
byte + short -> int + int
char + short -> int + int
package example01;
public class OperatorEx04 {
public static void main(String[] args) {
// 산술변환
// byte 범위 : -128 ~ 127
byte b1 = 127;
byte b2 = 1;
char ch = 'A'; //내부적으로 'A'는 정수 65로 저장
float f1 = 15.5F;
double d1 = 10.5;
byte b3 = -128;
byte b4 = 1;
byte bb3 = (byte)(b1 + b2); // byte + byte ==> int + int ==> int 강제형변환 b1, b2 전체를 묶어서 변환
int i1 = b1+ b2; // byte + byte ==> int + int ==> int
int i2 = ch + b2; // char + byte ==> int + int ==> int
float f2 = b2 + f1; // byte + float ==> float + float ==> float
double d2 = f1 + d1; // float + double ==> double + double ==> double
byte bb4 = (byte)(b3 - b4); // byte + byte ==> int + int ==> int
System.out.println(bb3); // 128 ==> overflow : 최대값 + 1 ==> 최소값 ==> -128이 맞는 것
System.out.println(i1); // 128
System.out.println(i2); // 66
System.out.println(f2); // 142.5
System.out.println(d2); // 26.0
System.out.println(bb4); // -129 ==> underflow : 최소값 - 1 ==> 최대값 ==> 127이 맞는 것
}
}
-단향연산자(증감연산자) : ++, --
: 피연산자에 저장된 값을 1 증가 또는 1 감소
: 단향연산자는 피연산자의 왼쪽에 위치하지만 증감연산자는 양쪽 모두 가능
int num = 10;
num++; ++num; num--; --num;
: 피연산자의 왼쪽에 위치하면 전위형( prefix ), 피연산자의 오른쪽에 위치하면 후위형 ( postfix )
: 전위형, 후위형 모두 피연산자의 값을 1 증가 혹은 감소시키지만,
증감연산자가 수식이나 메소드 호출에 포함된 경우, 전위형일 때와 후위형일 때의 결과가 다름
* 메소드 : 이름 뒤에 소괄호()
ex ) System.out.println()
public static void main(String[] args)
package example01;
public class OperatorEx02 {
public static void main(String[] args){
// 증감연산자
int x = 10;
int y = 10;
++X;
x++;
//단독으로 증가하는 경우 전위, 후위 상관없음
System.out.println("++x와 x++를 한 값 : " + x); // x값 : 12
Sysyem.out.println("==================================================");
x=10;
System.out.println("초기 x값 : " + x ); // x값 : 10
System.out.println("x++ : " + (x++)); // x++ 진행하고 나온 값 : 10
// 후위형 : 출력하고 증가
System.out.println("최종 x값 : " + x ); // x값 : 11
Sysyem.out.println("==================================================");
System.out.println("초기 y값 : " + y ); // y값 : 10
System.out.println("++y : " + (++y)); // ++y 진행하고 나온 값 : 11
// 전위형 : 증가하고 출력
System.out.println("최종 y값 : " + y ); // y값 : 11
Sysyem.out.println("==================================================");
x = 10;
int result = x++;
//대입하고 증가
System.out.println("result : " + result); // result 값 : 10
System.out.println("x : " + x); // x 값 : 11
Sysyem.out.println("==================================================");
x = 10;
int result2 = ++x;
//증가하고 대입
System.out.println("result2 : " + result2); // result 값 : 11
}
}
-산술연산자 : +(덧셈), -(뺄셈), *(곱셈), /(나눗셈), %(나머지)
package example01;
public class OperatorEx01 {
public static void main(String[] args) {
//산술연산
int v1 = 5;
int v2 = 2;
int result = 0;
result = v1 + v2;
System.out.println("더하기 결과 : " + result); // 7
System.out.println("더하기 결과 : " + v1 + v2); // 앞부터 차례로 문자열로 받아 계산해서 52
System.out.println("더하기 결과 : " + (v1 + v2)); //7
result = v1 - v2;
System.out.println("빼기 결과 : " + result); //3
System.out.println("빼기 결과 : " + (v1 - v2)); //3
result = v1 * v2;
System.out.println("곱하기 결과 : " + result); //10
System.out.println("곱하기 결과 : " + (v1 * v2)); //10
result = v1 / v2;
System.out.println("나누기 결과 : " + result); //2
System.out.println("나누기 결과 : " + (v1 / v2)); //2
result = v1 % v2;
System.out.println("나머지 결과 : " + result); //1
System.out.println("나머지 결과 : " + (v1 % v2)); //1
}
}
-비교연산자
: 두 피연산자를 비교하는데 사용되는 연산자
: 조건문과 반복문의 조건식에 사용, 연산결과는 오직 true, false
: 비교연산자는 이항연산자이므로 비교하는 피연산자의 타입이 서로 다를 경우
자료형의 범위가 큰 쪽으로 자동형변환되어 피연산자의 타입을 일치시킨 후 비교
| 대소비교연산자 : >, <, >=, <= | |
| 비교연산자 | 연산결과 |
| > | 좌변값이 크면 true, 아니면 false |
| < | 좌변값이 작으면 true, 아니면 false |
| >= | 좌변값이 크거나 같으면 true, 아니면 false |
| <= | 좌변값이 작거나 같으면 true, 아니면 false |
| 등가비교연산자 : ==, != - 두 피연산자의 값이 같은지 또는 다른지를 비교하는 연산자 - - 기본형은 물론 참조형에서도 사용 - - 기본형의 경우 변수에 저장되어 있는 값이 같은지 알 수 있고 참조형의 경우 객체의 주소값을 저장하기 때문에 두개의 피연산자가 같은 객체를 가리키고 있는지를 확인 가능 - |
|
| 비교연산자 | 연산결과 |
| == | 두 값이 같으면 true, 아니면 false |
| != | 두 값이 다르면 true, 아니면 false |
-논리연산자 : &&(AND결합), ||(OR결합), !(NOT)
:둘 이상의 조건을 '그리고(AND)나 또는(OR)'으로 연결하여 하나의 식으로 표현할 수 있게 함
: &&(AND결합) - 피연산자 모두 true여야 true
||(OR결합) - 피연산자 중 어느 한쪽만 true면 true
!(NOT) - true -> false, false -> true
: 쓰는 방법 - A > B && A > C / A > B || A > C
: 효율적인 연산을 위해 OR 연산의 경우 연산 결과가 참일 확률이 높은 피연산자를 왼쪽에 놓는 것이 좋음
: AND연산의 경우 연산 결과가 거짓일 확률이 높은 피연산자를 왼쪽에 놓는 것이 좋음
| 논리연산자 OR, AND 예시 | |||
| x | y | x||y | x&&y |
| true | true | true | true |
| true | false | true | false |
| false | true | true | false |
| false | false | false | false |
| 논리연산자 NOT 예시 | |||
| x | !x | ||
| true | false | ||
| false | true | ||
ex ) int num = 5; int num1 = 10;
num > num1 ==> false
!(num > num1) ==> true
package example01;
public class OperatorEx05 {
public static void main(String[] args) {
// 비교연산자, 논리연산자
boolean result = false;
int i = 10;
char ch = 'b'; // 98
result = ( i > 5 );
System.out.println("result : " + result); // true
System.out.println("( i > 5 ) : " + (i > 5)); // true
System.out.println("==================================================");
result = ( i >= 9 ) && ( i < -8); // false
System.out.println("result : " + result);
result = ( i >= 9 ) || ( i < -8); // true
System.out.println("result : " + result);
System.out.println("==================================================");
/*
* 1. 해당 문자가 영어 소문자인지 확인하는 조건문
* 2. 해당 문자가 알파벳인지 확인하는 조건문
*
* A : 65
* Z : 90
* a : 97
* z : 122
*/
// ch == 'b' 98
// 1. 해당 문자가 영어 소문자인지 확인하는 조건문
result = (ch >= 97 ) && (ch <= 122);
System.out.println("소문자 여부: " + result);
// 2. 해당 문자가 알파벳인지 확인하는 조건문
result = (ch >= 65 && ch <= 90 ) || (ch >= 97 && ch <= 122);
// result = (ch >= A && ch <= Z ) || (ch >= a && ch <= z);
System.out.println("알파벳 여부 : " + result);
}
}
package example01;
public class OperatorEx03 {
public static void main(String[] args) {
// !(NOT) true -> false, false -> true
boolean flag = false;
System.out.println("flag : " + flag); // false
flag = !flag;
System.out.println("flag : " + flag); //true
flag = !flag;
System.out.println("flag : " + flag); //false
System.out.println("flag : " + !flag); //true
System.out.println("flag : " + flag); //false
if(flag ) {
//조건식이 참이어야 실행되는 문장
System.out.println("if문내부");
}
}
}
-비트연산자
: &, |, ^, <<, >>
: 어떤 변수의 값을 0과 1의 조합, 즉 비트로 변환한 뒤에 비트 단위로 연산을 수행
: bit > byte > KB > MB > GB > TB
: 1 byte = 8 bit
| 2진수 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
ex ) 10 ==> 00001010(2)
11 ==> 00001011(2)
비트연산자 종류
| &(AND) | a & b | a와 b를 AND처리( 둘 다 1이어야 1 ) |
| |(OR) | a | b | a와 b를 OR처리 ( 둘 중 하나만 1이면 1 ) |
| ^(XOR) | a ^ b | a와 b를 XOR처리 ( 두 비트가 달라야 1 ) |
| <<(SHIFT) | a << 2 | a를 비트로 변환하여 왼쪽으로 2비트 이동 |
| >>(SHIFT) | a >> 2 | a를 비트로 변환하여 오른쪽으로 2비트 이동 |
ex ) 10 ==> 00001010(2)
10 << 2 ==> 00101000(2) ==> 40
10 >> 2 ==> 00000010(2) ==> 2
-그 외의 연산자
: 조건연산자(삼항연산자)
: 조건식, 식1, 식2 모두 세 개의 피연산자를 필요로하는 삼항연산자, 조건연산자는 하나 뿐
: 조건식 ? 식1 : 식2
==> 조건식이 true라면 식1, false라면 식2
ex ) int score = 90;
char grade = score >= 90 ? 'A' : 'B' ==> 'A'
int score = 80;
char grade = score >= 90 ? 'A' : 'B' ==> 'B'
: 대입연산자
: 변수와 같은 저장공간에 값 또는 수식의 연산결과를 저장하는데 사용
: 대입연산자의 왼쪽 피연산자는 lvalue(left value), 오론쪽 피연산자는 rvalue(right value)
: rvalue는 변수뿐만 아니라 식이나 상수 모두 가능,
lvalue는 반드시 변수처럼 변경할 수 있는 것이어야 함
* 복합대입연산자
+= 더한 값을 저장
-= 뺀 값을 저장
*= 곱한 값을 저장
/= 나눈 값을 저장
%= 나눈 나머지 값을 저장
ex ) int sum = 13;
sum += 2; // sum = sum + 2; ==> 15
sum -= 2; // sum = sum - 2; ==> 11
sum *= 2; // sum = sum * 2; ==> 26
sum /= 2; // sum = sum / 2; ==> 6
sum %= 2; // sum = sum % 2; ==> 1
'Java1(주말)' 카테고리의 다른 글
| Java1 day03 (0) | 2022.04.16 |
|---|---|
| Java1 day02 보충 2 (0) | 2022.04.16 |
| Java1 day02 보충 1 (0) | 2022.04.12 |
| Java1 day01 추가 보충 (0) | 2022.04.10 |
| Java1 day01 (0) | 2022.04.09 |