2025. 4. 30. 13:33ㆍJAVA/JAVA 기초 문법
🖥️ Operators(연산자)란?
연산자는 특정 작업을 수행하는 특수 기호로, 하나, 둘 또는 셋의 피연산자에 대해 작업을 수행한 다음 결과를 반환한다.
자바 프로그래밍 언어의 연산자를 탐색하는 동안 연산자의 우선순위가 높은 것부터 미리 알고 있으면 도움이 될 수 있다.
다음 표에 나열된 연산자는 우선순위 순서대로 나열되어 있다.
표의 맨 위에 나타나는 연산자일수록 우선순위가 높다. 우선순위가 높은 연산자가 상대적으로 우선순위가 낮은 연산자보다 먼저 평가된다.
동일한 라인에 있는 연산자는 우선순위가 동일하다. 동일한 우선순위의 연산자가 동일한 표현식에 나타날 때 어떤 것이 먼저 평가될지를 결정하는 규칙이 필요하다. 할당 연산자를 제외한 모든 이항 연산자는 왼쪽에서 오른쪽으로 평가된다. 할당 연산자는 오른쪽에서 왼쪽으로 평가된다.
💻 Operator Precedence
| Operators | Precedence |
| postfix | expr++ expr-- |
| unary | ++expr --expr +expr -expr ~ ! |
| multiplicative | * / % |
| additive | + - |
| shift | << >> >>> |
| relational | < > <= >= instanceof |
| equality | == != |
| bitwise AND | & |
| bitwise exclusive XOR | ^ |
| bitwise inclusive OR | | |
| logical AND | && |
| logical OR | || |
| ternary | ? : |
| assignment | = += -= *= /= %= &= ^= |= <<= >>= >>>= |
⌨️ Unary(단항 연산자)
단항 연산자(Unary Operator)는 하나의 피연산자에 대해 작용하는 연산자이다. 이 연산자는 단일 피연산자에 대해 수행하는 작업을 정의하며, 피연산자 하나를 가지고 단일 연산을 수행한다.
| Unary목록 | expr++ expr-- ++expr --expr +expr -expr ~ ! |
🖱️ Postfix(후위 증감 연산자)
자바에서 postfix 라는 용어는 보통 후위 연산자(Postfix Operator)를 의미한다. 후위 연산자는 변수의 값에 대한 연산이 먼저 수행된 후에 그 값을 증가시키거나 감소시키는 연산자를 말한다.
🖲️ 후위 증가(Post-Increment) 연산자 (x ++)
- 이 연산자는 변수를 먼저 사용한 후에 그 값을 1 증가시킨다.
- 예를 들어, int x = 5; int y = x ++; 이코드에서 y의 값은 5가 되고, x의 값은 6이 됩니다.
🖲️ 후위 감소(Post-Decrement) 연산자 (x - -)
- 이 연산자는 변수를 먼저 사용한 후에 그 값을 1 감소시킨다.
- 예를 들어, int x = 5; int y = x --; 이 코드에서 y의 값은 5가 되고, x의 값은 4가 됩니다
public class PostfixExample {
// Syntactic sugar 연산자 : ++, --
// ++ (후위 증가(1씩) 연산자)
// -- (후위 감소(1씩) 연산자)
public static void main(String[] args) {
// Post-Increment
int a = 10;
int b = a++; // b는 10이 되고, a는 11이 됩니다.
// int b = a; // a의 값을 먼저 b에 대입한다. : 원래 값으로 평가한다
// a = a + 1; // 그런 후[Postfix]에, a의 값을 1 증가함. 그래서 후위 증가라고 함.
// Post-Decrement
int c = 10;
int d = c--; // d는 10이 되고, c는 9가 됩니다.
// int d = c;
// c = c - 1;
System.out.println("a: " + a + ", b: " + b);
System.out.println("c: " + c + ", d: " + d);
}
}이 예제에서, a++와 c--는 각각 a와 c의 값을 먼저 할당한 후에 1씩 증가하거나 감소시킨다.
따라서 출력 결과는 다음과 같다.
a : 11 b: 10
c : 9 d: 10
‼️ 후위 연산자는 변수의 현재 값을 사용하고 난 후에 변경하기 때문에, 다른 연산자나 명령문과 함께 사용될 때 그 동작을 잘 이해하고 있어야 한다.
🖱️ Prefix(전위 증감 연산자)
Prefix 연산자는 연산자가 피연산자 앞에 위치하는 연산자입니다.
즉, 연산을 먼저 수행한 뒤 그 결과 값을 사용합니다.
🖲️ 전위 증가(Pre-Increment) 연산자
- 이 연산자는 먼저 값을 1 증가시키고, 그 증가된 값을 사용한다.
- 예를 들어, int x = 5; int y = ++x ; 이코드에서 y의 값은 6가 되고,x의 값은 6이 됩니다.
🖲️ 전위 감소(Pre-Decrement) 연산자
- 이 연산자는 먼저 값을 -1 감소시키고, 그 감소된 값을 사용한다.
- 예를 들어, int x = 5; int y = --x ; 이 코드에서 y의 값은 4가 되고, x의 값은 4가 됩니다
public class UnaryExample {
public static void main(String[] args) {
int a = 5, b = 10;
// 전위 증감 연산자[prefix]
int preA = ++a; // 값을 증가시키고, 그 결과를 리턴함..(=) 연산자에게
// a = a + 1; // 전위 증감 : a의 값을 먼저 1 증가 시킨 후
// int preA = a; // preA 변수에 대입한다.
int preB = --b; // 값을 감소시키고, 그 결과를 리턴함..(=) 연산자에게
// b = b - 1; // 전위 감소 : b의 값을 먼저 1 감소 시킨 후
// int preB = b; // preB 변수에 대입한다
System.out.println("unary: ++a = " + preA + ", --b = " + preB);
}이 예제에서 ++a와 --b는 각각 a와 c의 값을 먼저 1씩 증가하거나 감소시킨 후 값을 대입한다.
출력 값은 다음과 같다.
unary: ++a = 6, --b = 9
🖱️ Unary Plus/Minus
- + 는 아무 일도 안 일어나느 것처럼 보이지만, 명시적으로 정수를 표현할 때 사용
- - 는 음수로 만들 때 사용
int a = 5, b = 10;
int positive = +a; // a는 5
int negative = -b; // b는 -10
🖱️ Logical Complement( !, 논리 부정 연산자)
- True를 False로, False를 True로 바꿈
boolean x = true;
boolean logicalNot = !x; // false
🖱️ Bitwise Complement( ~, 비트 반전 연산자)
- 모든 비트를 반전시킴 (1을 0으로, 0을 1로)
- 결과는 2의 보수 형식으로 계산됨
int a = 5; // 0000101 (2진수)
int b = ~a; // 1111010 -> 6 (10진수)⌨️ Binary(이항 연산자)
이항 연산자(Binary Operator)는 두 개의 피연산자를 필요로 하는 연산자입니다. 이 피연산자들은 연산의 좌항과 우항에 위치하며, 이항 연산자가 이들을 조작하여 새로운 값을 생성합니다.
🖱️ Arithmetic(산술 연산자)
산술 연산자(Arithmetic Operator)는 두 개의 숫자 값을 이용하여 수학적 계산을 수행하는 연산자다.
🖲️ + 덧셈(Addition) 연산자
- + : 두 수를 더함
🖲️ - 뺄셈(Subtraction) 연산자
- - : 두 수를 뺌
🖲️ * 곱셈(Multiplication) 연산자
- * : 두 수를 곱함
🖲️ / 나눗셈(Division) 연산자
- / : 첫 번째 수를 두번째 수로 나눔
🖲️ % 나머지(Modulus) 연산자
- % : 두 수를 나눈 나머지를 구함
public class ArithmeticExample {
public int a = 5, b = 10, c = 0;
// Addition
int add = a + b; // 15
// Subtraction
int sub = b - a; // 5
// Multiplication
int mul = a * b; // 50
// Division
int div = b / a; // 2
// Modulus
int mod = b % a; // 나머지 값 0
}
🖱️ Comparison(비교 연산자)
비교 연산자는 두 개의 값을 비교하여 결과를 참(true) 또는 거짓(false)으로 반환하는 연산자다.
조건문(if, while 등)에서 자주 사용되며, 논리적 판단의 기준이 됩니다.
🖲️ == 같음(Equal to) 연산자
- 두 값이 같으면 true, 다르면 false
🖲️ != 다름(Not equal to) 연산자
- 두 값이 다르면 true, 같으면 false
🖲️ > 큼(Great than) 연산자
- 왼쪽 값이 오른쪽보다 크면 true
🖲️ < 작음(Less than) 연산자
- 왼쪽 값이 오른쪽보다 작으면 true
🖲️ >= 크거나 같음(Greater than or equal to)
- 왼쪽이 크거나 같으면 true
🖲️ <= 작거나 같음(Less than to equal to)
- 왼쪽이 작거나 같으면 true
class ComparisonDemo {
public static void main(String[] args){
int a = 1;
int b = 2;
if(a == b)
System.out.println("a == b"); // a와 b의 값은 다르므로 false
if(a != b)
System.out.println("a != b"); // a와 b의 값은 다르므로 true
if(a > b)
System.out.println("a > b"); // a는 b보다 작아서 false
if(a < b)
System.out.println("a < b"); // b는 a보다 커서 true
if(a <= b)
System.out.println("a <= b"); // b는 a보다 커서 true
}
}출력시
a != b
a < b
a <= b
🖱️ Conditional(논리 연산자)
논리 연산자는 두 개의 조건(또는 boolean 값)을 논리적으로 연결해서 결과를 참(true) 또는 거짓(false)으로 반환하는 연산자다.
🖲️ && AND 연산
- 모든 조건이 참일 때만 전체 결과가 참
| A | B | A && B |
| True | True | True |
| True | False | False |
| False | False | False |
🖲️ || OR 연산
- 하나라도 참이면 전체 결과가 참
| A | B | A || B |
| True | True | True |
| True | False | True |
| False | False | False |
public static void main(String[] args){
int a = 1;
int b = 2;
if((a == 1) && (b == 2))
System.out.println("a is 1 AND b is 2"); // 둘다 true여서 true
if((a == 1) || (b == 1))
System.out.println("a is 1 OR b is 1"); // a==1이 true고 b==1은 false 지만 한개가 true이므로
// true
}출력시
a is 1 AND b is 2
a is 1 OR b is 1
🖱️ Bitwise(비트 연산자)
비트 연산자는 숫자를 2진수(비트 단위)로 벼노한하여, 각 비트에 대해 연산을 수행하는 연산자 입니다.
즉, 숫자의 내부 표현(0과 1)을 직접 다루는 연산입니다.
🖲️ & 비트 AND(Bitwise And) 연산자
- 두 비트가 모두 1이면 1
- ex) 0011 & 1001 -> 0001
🖲️ | 비트 OR(Bitwise OR) 연산자
- 하나의 비트가 1이면 1
- ex) 0011 | 1001 -> 1011
🖲️ ^ 비트 XOR(Bitwise XOR) 연산자
- 두 비트가 다르면 1
- ex) 0011 ^ 1001 -> 1010
🖲️ << 왼쪽 시프트(Left Shift) 연산자
- 비트를 왼쪽 n칸 이동 (2의 n제곱 곱셈 효과)
- ex) 0011 << 1 -> 0110
🖲️ >> 오른쪽 시프트(Right Shift) 연산자
- 부호 유지하며 비트를 오른쪽 n칸 이동 (음수는 1유지)
- ex) 0011 >> 1 -> 0001
🖲️ >>> 부호 없는 오른쪽 시프트(Unsigned Right Shift) 연산자
- 부호 상관없이 오른쪽으로 0을 채워 이동
- ex) 0011 >>> 1 -> 0001
public static void main(String[] args){
int a = 5, b = 10;
// bitwise AND
int andBit = a & b;
System.out.println("bitwise AND: & = " + andBit);
// bitwise XOR
int xorBit = a ^ b;
System.out.println("bitwise XOR: ^ = " + xorBit);
// bitwise OR
int orBit = a | b;
System.out.println("bitwise OR: | = " + orBit);
// bitwise shift
int leftbit = a << 1;
System.out.println("bitwise LeftShift: << = " + leftbit);
int rightbit = a >> 1;
System.out.println("bitwise RightShift: >> = " + rightbit);
int negativeRightbit = -a >> 1;
System.out.println("bitwise negativeRightShift: >> = " + negativeRightbit);
int unsignedRightbit = b >>> 1;
System.out.println("bitwise UnsignedRightShift: >>> = "+ unsignedRightbit);
int negativeUnsignedRightbit = -b >>> 1;
System.out.println("bitwise negativeUnsignedRightShift: >>> = "+ negativeUnsignedRightbit);
}
}출력시
bitwise AND: & = 0
bitwise XOR: ^ = 15
bitwise OR: | = 15
bitwise LeftShift: << = 10
bitwise RightShift: >> = 2
bitwise negativeRightShift: >> = -3
bitwise UnsignedRightShift: >>> = 2
bitwise negativeUnsignedRightShift: >>> = 2147483645
🖱️ Assignment(대입 연산자)
대입 연산자는 변수에 값을 저장하거나 계산 결과를 할당할 때 사용하는 연산자다.
🖲️ = 기본 대입 연산자
- 오른쪽 값을 왼쪽 변수에 저장
🖲️ += 연산자
- 더한 후 대입 한다.
🖲️ -= 연산자
- 뺀 후 대입 한다
🖲️ *= 연산자
- 곱한 후 대입
🖲️ /= 연산자
- 나눈 후 대입
🖲️ %= 연산자
- 나머지 후 대입
🖲️ &= 연산자
- 비트 AND 후 대입
🖲️ |= 연산자
- 비트 OR 후 대입
🖲️ ^= 연산자
- 비트 XOR 후 대입
🖲️ <<= 연산자
- 왼쪽 시프트 후 대입
🖲️ >>= 연산자
- 오른쪽 시프트 후 대입
🖲️ >>>= 연산자
- 부호없는 오른쪽 시프트 후 대입
int a = 5, b = 10, c = 0;
// assignment
c = a; // c에 a의 값을 대입합니다. (c = 5)
c += b; // c = c + b; → c = 5 + 10 = 15
c -= a; // c = c - a; → c = 15 - 5 = 10
c *= 2; // c = c * 2; → c = 10 * 2 = 20
c /= 2; // c = c / 2; → c = 20 / 2 = 10
c %= 3; // c = c % 3; → c = 10 % 3 = 1
c &= 7; // c = c & 7; → c = 1 & 7 = 1 (비트 AND: 0001 & 0111 = 0001)
c ^= 2; // c = c ^ 2; → c = 1 ^ 2 = 3 (비트 XOR: 0001 ^ 0010 = 0011)
c |= 1; // c = c | 1; → c = 3 | 1 = 3 (비트 OR: 0011 | 0001 = 0011)
c <<= 1; // c = c << 1; → c = 3 << 1 = 6 (비트를 왼쪽으로 1칸 이동: 0011 → 0110)
c >>= 1; // c = c >> 1; → c = 6 >> 1 = 3 (부호 유지하면서 오른쪽으로 1칸 이동: 0110 → 0011)
c >>>= 1; // c = c >>> 1; → c = 3 >>> 1 = 1 (부호 비트 무시, 0으로 채우며 오른쪽으로 1칸 이동: 0011 → 0001)
⌨️ Ternary(삼항 연산자)
삼항 연산자는 세 개의 피연산자를 사용하는 조건 기반 연산자로, 조건이 참인지 거짓인지에 따라 다른 값을 반환한다.
즉, 짧은 if-else 문을 한 줄로 표현할 수 있게 해주는 문법이다.
삼항 연산자는 단 한개의 연산자( ? : )만 가지고 있다.
(조건식) ? true 때 반환값 : false 때 반환값;조건식은 boolean 타입으로 평가 된다. 반환값은 같은 타입이여야 한다.
❗ 타입 관련 주의
int x = true ? 1 : 2.0; // ❌ 오류: int와 double은 호환되지 않음
double y = true ? 1 : 2.0; // ✅ OK (1이 자동으로 double로 변환됨)
❓ int에는 double 대입이 안되고, double에는 int가 자동으로 들어갈 수 있을까?
‼️자바의 형변환 규칙(Type Conversion)‼️
1. 자동 형변환
- 작은 타입 → 큰 타입으로 변환은 자동으로 이루어진다
- 손실이 없기 때문에 안전함.
| 반환 예시 | 설명 |
| int → double | ✅ 가능 (자동) |
| int x = 3; double y = x; | ✅ 가능 |
2. 강제 형변환
- 큰 타입 → 작은 타입 변환은 명시적 캐스팅(형변환)이 필요하다.
- 데이터 손실 가능성이 있어서 자동으로는 불가하다.
| 반환 예시 | 설명 |
| double → int | ❌ 자동 불가 |
| double d = 3.14; int i = (int)d; | ✅ 명시적 변환 필요 |
public class TernaryExample {
public static void main(String[] args) {
int a = 5, b = 10, c = 0;
// ternary ? :
// (a > b) : ()안에서 사용되는 expression은 true 또는 false 값을 만듦.
// (...) : ()안에 ... expression의 값이,
// 1. true 이면(?),
// -> ? X : Y ----> ':' 기준으로 왼쪽에 있는 X가 선택된다
// 2. false 이면(?),
// -> ? X : Y ----> ':' 기준으로 오른쪽에 있는 Y가 선택된다.
int ternary = (a > b) ? a : b;
// 쓸수 있는 코드지만 이렇게 쓰지 않는다
int ternary2 = (true) ? a : b;
System.out.println("ternary: (a > b) ? a : b = " + ternary );
// (a > b) 조건식이 false므로 b 값 출력
}
}출력시
ternary: (a > b) ? a : b = 10'JAVA > JAVA 기초 문법' 카테고리의 다른 글
| Explicit(명시적)과 Implicit(암시적) (0) | 2025.05.14 |
|---|---|
| Control Flow Statements (1) | 2025.05.14 |
| Array(배열) (0) | 2025.04.23 |
| 자바에서 This (0) | 2025.04.15 |
| Constructor (생성자) (0) | 2025.04.14 |