์๋ฐ ํ๋ก๊ทธ๋๋ฐ์์ ์ฝ๋๋ฅผ ์์ฑํ ๋ ์ฐ์ฐ์์ ์ฐ์ ์์๋ฅผ ์ดํดํ๋ ๊ฒ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ฐ์ฐ์ ์ฐ์ ์์๋ฅผ ์ ๋๋ก ํ์ ํ์ง ์์ผ๋ฉด ์ฝ๋๋ฅผ ์ดํดํ๊ณ ์์ฑํ๋ ๋ฐ ์ด๋ ค์์ ๊ฒช์ ์ ์์ต๋๋ค. ์ด๋ฒ ํฌ์คํ ์์๋ ์๋ฐ์์ ์ฌ์ฉ๋๋ ์ฐ์ฐ์๋ค์ ์ฐ์ ์์์ ๋ํด ์์ธํ ์์๋ณด๊ฒ ์ต๋๋ค.
โฃ ๋ชฉ์ฐจ
1. ์ฐ์ฐ์ ์ฐ์ ์์๐
์ฐ์ฐ์ ์ฐ์ ์์๋ ์ฐ์ฐ์ด ์ํ๋๋ ์์๋ฅผ ๊ฒฐ์ ํ๋ ๊ท์น์
๋๋ค. ์ฐ์ฐ์ ์ฐ์ ์์๋ฅผ ์ดํดํ๋ฉด ์ฝ๋๋ฅผ ๋์ฑ ๋ช
ํํ๊ฒ ์ดํดํ ์ ์์ผ๋ฉฐ, ์๋ํ ๋๋ก ๋์ํ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๊ณฑ์
์ด ๋ง์
๋ณด๋ค ๋จผ์ ๊ณ์ฐ๋๋ค๋ ๊ฒ์ ์๊ณ ์์ผ๋ฉด ๋ ๋ณต์กํ ํํ์๋ ์ดํดํ๊ธฐ ์ฌ์์ง๋๋ค.
์๋ฐ์์์ ์ฐ์ฐ์ ์ฐ์ ์์๋ ๋ค์๊ณผ ๊ฐ์ ์์๋ก ์ ์๋ฉ๋๋ค.
- ๊ดํธ ()
- ๋จํญ ์ฐ์ฐ์ ++, --, +, -
- ์ฐ์ ์ฐ์ฐ์ *, /, %
- ์ฐ์ ์ฐ์ฐ์ +, -
- ์ํํธ ์ฐ์ฐ์ <<, >>, >>>
- ๋นํธ ์ฐ์ฐ์ &, |, ^
- ๋ ผ๋ฆฌ ์ฐ์ฐ์ &&, ||
- ์กฐ๊ฑด(์ผํญ) ์ฐ์ฐ์?:
- ๋์ ์ฐ์ฐ์ =, +=, -=, *=
์ด ์์๋๋ก ์ฐ์ ์์๊ฐ ๊ฒฐ์ ๋๋ฉฐ, ์ฐ์ ์์๊ฐ ๋์ ์ฐ์ฐ์์ผ์๋ก ์ฐ์ ์ ์ผ๋ก ์ํ๋ฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์ฐ์ ์์๊ฐ ๊ฐ์ ์ฐ์ฐ์๋ค๋ผ๋ฆฌ๋ ์ด๋ค ์์๋ก ์ฒ๋ฆฌ๋ ๊น์?
์ฐ์ ์์๊ฐ ๊ฐ์ ์ฐ์ฐ์๋ค๋ผ๋ฆฌ๋ ์ผ๋ฐ์ ์ผ๋ก ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฐ์ฐ์ด ์ํ๋ฉ๋๋ค. ์ด๋ฅผ ์ข์์ ์ฐ๋ก ๊ฒฐํฉ(associativity)ํ๋ค๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ง์
๊ณผ ๋บ์
์ฐ์ฐ์๋ ์ฐ์ ์์๊ฐ ๊ฐ์ผ๋ฉฐ ์ข์์ ์ฐ๋ก ๊ฒฐํฉ๋ฉ๋๋ค. ๋ฐ๋ผ์
2 + 3 - 1
์ด๋ผ๋ ์์ ๋จผ์ 2 + 3์ด ๊ณ์ฐ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ -1์ด ๊ณ์ฐ๋์ด ์ ์ฒด ์์ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค.
๋์
์ฐ์ฐ์๋ ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ์คํ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด
a = b = c = 10;
c์ ๋จผ์ 10์ด ๋์
๋๊ณ , ๊ทธ๋ค์ b์ ๋์
๋๋ฉฐ, ๋ง์ง๋ง์ผ๋ก a์ ๋์
๋ฉ๋๋ค. ์ดํ์๋ a, b, c, ๋ชจ๋ ๊ฐ์ด 10์ด ๋ฉ๋๋ค. ์ด์ฒ๋ผ ์ฐ์ฐ์๋ ์ฐ์ ์์์ ์ฐ์ฐ๋ฐฉํฅ์ด ์ ํด์ ธ ์๊ธฐ ๋๋ฌธ์ ๋ณต์กํ ์ฐ์ฐ์์์๋ ์ฃผ์๊ฐ ํ์ํฉ๋๋ค.
public class OperatorPrecedenceMoreExamples {
public static void main(String[] args) {
// ๊ณฑ์
์ฐ์ฐ์์ ๋๋์
์ฐ์ฐ์์ ์ฐ์ ์์
int result1 = 10 + 5 * 2 / 3; // ๊ณฑ์
๊ณผ ๋๋์
์ด ๋จผ์ ๊ณ์ฐ๋ฉ๋๋ค.
System.out.println("result1: " + result1); // ์ถ๋ ฅ: 10 + (5 * 2 / 3) = 13
// ๋ณตํฉ ๋์
์ฐ์ฐ์์ ์ฐ์ ์ฐ์ฐ์์ ์ฐ์ ์์
int x = 5;
x *= 3 + 2; // ๋ง์
์ด ๋จผ์ ๊ณ์ฐ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ ๊ณฑ์
์ด ์ํ๋ฉ๋๋ค.
System.out.println("x: " + x); // ์ถ๋ ฅ: 25
// ๋
ผ๋ฆฌ ์ฐ์ฐ์์ ๊ด๊ณ ์ฐ์ฐ์์ ์ฐ์ ์์
boolean condition1 = true;
boolean condition2 = false;
boolean result2 = condition1 || condition2 && condition1; // && ์ฐ์ฐ์๊ฐ || ์ฐ์ฐ์๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ต๋๋ค.
System.out.println("result2: " + result2); // ์ถ๋ ฅ: true
// ์กฐ๊ฑด(์ผํญ) ์ฐ์ฐ์์ ๋์
์ฐ์ฐ์์ ์ฐ์ ์์
int num = 10;
int result3 = (num % 2 == 0) ? num * 2 : num / 2; // ์กฐ๊ฑด ์ฐ์ฐ์๊ฐ ์ฐ์ ์์๊ฐ ๋ฎ์์ ๋์
์ฐ์ฐ์๋ณด๋ค ๋์ค์ ์ํ๋ฉ๋๋ค.
System.out.println("result3: " + result3); // ์ถ๋ ฅ: 20
}
}
2.๊ดํธ์ ํ์ฉ๐ซ
๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ฐ์์ ์ฐ์ ์์๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ๊ดํธ ์์ ์๋ ์์ด ๊ฐ์ฅ ๋จผ์ ๊ณ์ฐ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด,
int result = (2 + 3) * 4;
์ ์ฝ๋์์๋ ๋ง์
์ด ๋จผ์ ๊ณ์ฐ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ 4๊ฐ ๊ณฑํด์ง๋๋ค.
public class ParenthesesExample {
public static void main(String[] args) {
int x = 5;
int y = 3;
int z = 2;
// ๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ฐ์์ ์ฐ์ ์์๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
int result1 = x * (y + z); // ๊ดํธ ์์ ๋ง์
์ด ๋จผ์ ์ํ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ x๊ฐ ๊ณฑํด์ง๋๋ค.
System.out.println("result1: " + result1); // ์ถ๋ ฅ: 5 * (3 + 2) = 25
int result2 = (x + y) * z; // ๊ดํธ ์์ ๋ง์
์ด ๋จผ์ ์ํ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ z๊ฐ ๊ณฑํด์ง๋๋ค.
System.out.println("result2: " + result2); // ์ถ๋ ฅ: (5 + 3) * 2 = 16
}
}
์์ ์์ ์์๋ ๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ฐ์์ ์ฐ์ ์์๋ฅผ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค. result1์ ๊ฒฝ์ฐ ์๋ ๊ณฑ์
์ฐ์ฐ์๋ณด๋ค ๋ง์
์ฐ์ฐ์๊ฐ ๋จผ์ ์ํ๋๋๋ก ๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ ์์๋ฅผ ๋ณ๊ฒฝํ์ต๋๋ค. ์ด์ ๋ฐ๋ผ ๋ง์
์ด ๋จผ์ ์ํ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ ๊ณฑ์
์ด ์ด๋ฃจ์ด์ ธ์ 25๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค. ๋ฐ๋ฉด์ result2์ ๊ฒฝ์ฐ์๋ ๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋ง์
์ฐ์ฐ์๊ฐ ๋จผ์ ์ํ๋๋๋ก ํ์ต๋๋ค. ๋ฐ๋ผ์ ๊ดํธ ์์ ๋ง์
์ด ๋จผ์ ์ํ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ ๊ณฑ์
์ด ์ด๋ฃจ์ด์ ธ์ 16์ด ์ถ๋ ฅ๋ฉ๋๋ค.
3. ๋ณตํฉ ์ฐ์ฐ์์ ์ฐ์ ์์๐คธ
๋ณตํฉ ์ฐ์ฐ์๋ ์ฌ๋ฌ ์ฐ์ฐ์ ํ ๋ฒ์ ์ํํ๋ ์ฐ์ฐ์์
๋๋ค. ์ด๋ค์ ์ฐ์ ์์๋ ๋ค๋ฅธ ์ฐ์ฐ์์ ์ ์ฌํฉ๋๋ค. ์๋ฅผ ๋ค์ด,
int x = 5;
x += 3 * 2;
์ ์ฝ๋์์๋ ๊ณฑ์
์ด ๋จผ์ ๊ณ์ฐ๋๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ 5๊ฐ ๋ํด์ง ํ์ x์ ๋์
๋ฉ๋๋ค.
public class CompoundAssignmentExample {
public static void main(String[] args) {
int x = 5;
x += 3 * 2; // x = x + (3 * 2)
System.out.println("x: " + x); // ์ถ๋ ฅ: 11
int y = 10;
// ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ค๋ฅธ ๋ณตํฉ ์ฐ์ฐ์๋ค๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
y -= 4; // y = y - 4
System.out.println("y: " + y); // ์ถ๋ ฅ: 6
int z = 3;
z *= 5 + 2; // z = z * (5 + 2)
System.out.println("z: " + z); // ์ถ๋ ฅ: 21
}
}
4.ํต์ฌ ๋ด์ฉ๐