λ³Έλ¬Έ λ°”λ‘œκ°€κΈ°
β˜•Java

[Java μ΄ν•΄ν•˜κΈ°] 4. μžλ°”μ˜ μ—°μ‚°μž

by Luvbit 2024. 4. 26.


 

 

🩷 Java의 μ—°μ‚°μžλž€?

Javaμ—μ„œμ˜ μ—°μ‚°μž(Operators)λŠ” νŠΉμ •ν•œ 연산을 μˆ˜ν–‰ν•˜λ„λ‘ μ„€κ³„λœ κΈ°ν˜Έμž…λ‹ˆλ‹€.
μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜μ—¬ λ³€μˆ˜μ™€ 값에 λ‹€μ–‘ν•œ μ’…λ₯˜μ˜ 연산을 μ μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

 

 

 

 

 

 

πŸ’› μ—°μ‚°μžμ˜ μ’…λ₯˜ 

 


1οΈβƒ£μ‚°μˆ  μ—°μ‚°μž

μ‚°μˆ  μ—°μ‚°μžλŠ” ν”νžˆλ“€ μ•Œκ³ κ³„μ‹œλŠ” 바와 같이 사칙연산같은 λ”ν•˜κΈ° , λΉΌκΈ° 등이 이에 ν•΄λ‹Ήλ©λ‹ˆλ‹€. μžλ°”μ˜ μ—°μ‚°μžλŠ” 쑰금 더 μ’…λ₯˜κ°€ λ‹€μ–‘ν•œλ°, μ—°μ‚°μžμ˜ μ’…λ₯˜λ₯Ό μƒμ„Έν•˜κ²Œ μ„€λͺ…λ“œλ¦¬κ² μŠ΅λ‹ˆλ‹€.

 

1. λ§μ…ˆ μ—°μ‚°μž ( + )

  • 두 개의 ν”Όμ—°μ‚°μžλ₯Ό λ”ν•©λ‹ˆλ‹€.
  • μˆ˜μΉ˜ν˜• λ°μ΄ν„°λΏλ§Œ μ•„λ‹ˆλΌ, λ¬Έμžμ—΄ 연결에도 μ‚¬μš©λ  수 μžˆμŠ΅λ‹ˆλ‹€.
int a = 1;
int b = 2;
int c = a + b;  // c의 값은 3

String hello = "Hello, ";
String rabbit = "Rabbit!";
String greeting = hello + rabbit;  // greeting의 값은 "Hello, Rabbit!"

 

2. λΊ„μ…ˆ μ—°μ‚°μž  ( - )

  • μ™Όμͺ½ ν”Όμ—°μ‚°μžμ—μ„œ 였λ₯Έμͺ½ ν”Όμ—°μ‚°μžλ₯Ό λΊλ‹ˆλ‹€.
int a = 5;
int b = 3;
int c = a - b;  // c의 값은 2

 

3. κ³±μ…ˆ μ—°μ‚°μž  ( * )

  • 두 개의 ν”Όμ—°μ‚°μžλ₯Ό κ³±ν•©λ‹ˆλ‹€.
int a = 2;
int b = 3;
int c = a * b;  // c의 값은 6

 

4. λ‚˜λˆ—μ…ˆ μ—°μ‚°μž  ( / )

 

  • μ™Όμͺ½ ν”Όμ—°μ‚°μžλ₯Ό 였λ₯Έμͺ½ ν”Όμ—°μ‚°μžλ‘œ λ‚˜λˆ•λ‹ˆλ‹€.
  • μ •μˆ˜ λ‚˜λˆ—μ…ˆμ˜ 경우, κ²°κ³ΌλŠ” μ •μˆ˜λ‘œμ„œ λ‚˜λ¨Έμ§€λ₯Ό 버리고 λͺ«λ§Œ λ°˜ν™˜ν•©λ‹ˆλ‹€
  • .뢀동 μ†Œμˆ˜μ  λ‚˜λˆ—μ…ˆμ˜ 경우, μ •ν™•ν•œ μ†Œμˆ˜ κ²°κ³Όλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 10;
int b = 3;
int c = a / b;  // c의 값은 3 (μ •μˆ˜ λ‚˜λˆ—μ…ˆ)

double x = 10.0;
double y = 3.0;
double z = x / y;  // z의 값은 3.33... (뢀동 μ†Œμˆ˜μ  λ‚˜λˆ—μ…ˆ)

 

5. λ‚˜λ¨Έμ§€ μ—°μ‚°μž  ( % ) 

  • μ™Όμͺ½ ν”Όμ—°μ‚°μžλ₯Ό 였λ₯Έμͺ½ ν”Όμ—°μ‚°μžλ‘œ λ‚˜λˆ„κ³  λ‚œ λ‚˜λ¨Έμ§€λ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
  • 이 μ—°μ‚°μžλŠ” λ‚˜λˆ—μ…ˆμ˜ λ‚˜λ¨Έμ§€λ₯Ό ꡬ할 λ•Œ μœ μš©ν•˜λ©°, μˆ«μžκ°€ μ–΄λ–€ κ°’μœΌλ‘œ λ‚˜λˆ„μ–΄ λ–¨μ–΄μ§€λŠ”μ§€ 확인할 λ•Œ 자주 μ‚¬μš©λ©λ‹ˆλ‹€.
int a = 10;
int b = 3;
int c = a % b;  // c의 값은 1

int d = 4;
int e = 2;
int f = d % e;  // f의 값은 0

 


2️⃣비ꡐ μ—°μ‚°μž

비ꡐ μ—°μ‚°μžλŠ” λ‘ κ°’을 λΉ„κ΅ν•˜κ³  κ·Έ κ²°κ³Όλ‘œ λ…Όλ¦¬μ μΈ κ°’인 true λ˜λŠ” falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

 

1. 동등 μ—°μ‚°μž ( '==' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 10;
int b = 20;
boolean result = (a == b)  // true

 

  •  

2. λΆ€λ“± μ—°μ‚°μž ( '!=' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 10;
int b = 20;
boolean result = (a != b);  // true

 

3. 크닀 μ—°μ‚°μž ( '>' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 15;
int b = 10;
boolean result = (a > b);  // true

 

4. μž‘λ‹€ μ—°μ‚°μž ( '<' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 10;
int b = 15;
boolean result = (a < b);  // true

 

5. ν¬κ±°λ‚˜ μž‘λ‹€ μ—°μ‚°μž ( '>=' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 15;
int b = 15;
boolean result = (a >= b);  // true

 

6. μž‘κ±°λ‚˜ κ°™λ‹€ μ—°μ‚°μž ( '<=' )

  • 두 ν”Όμ—°μ‚°μžμ˜ 값이 같은지 λΉ„κ΅ν•©λ‹ˆλ‹€.
  • κ°™μœΌλ©΄ true, λ‹€λ₯΄λ©΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 10;
int b = 15;
boolean result = (a <= b);  // true

 


3️⃣논리 μ—°μ‚°μž

논리 μ—°μ‚°μžλŠ” 주둜 논리적인 쑰건을 ν‰κ°€ν•˜λŠ” 데 μ‚¬μš©λ©λ‹ˆλ‹€.

 

 

 1. AND μ—°μ‚°μž  ( '&&' )

  • 두 μ‘°κ±΄ λͺ¨λ‘ true일 λ•Œλ§Œ κ²°κ³Όκ°€ trueκ°€ λ©λ‹ˆλ‹€. 
  • 첫 번째 쑰건이 false이면, 두 번째 쑰건은 κ²€μ¦ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.
boolean a = true;
boolean b = false;
boolean c = true;
boolean result = a && b;  // false
boolean result2 = a && c; // true

 

 2. OR μ—°μ‚°μž ( ' || ' )

  • 두 쑰건 쀑 ν•˜λ‚˜λΌλ„ 'true'이면 κ²°κ³Όκ°€ 'true'κ°€ λ©λ‹ˆλ‹€.
  • 첫 번째 쑰건이 true이면, 두 번째 쑰건은 κ²€μ¦ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.
boolean a = true;
boolean b = false;
boolean result = a || b;  // true
boolean result2 = b || b; // false

 

 3. NOT μ—°μ‚°μž ( ' ! ' )

  • 단일 쑰건의 논리 값을 λ°˜μ „μ‹œν‚΅λ‹ˆλ‹€.
  • 'true'λŠ” 'false'둜, 'false'λŠ” 'true'둜 λ³€ν™˜λ©λ‹ˆλ‹€.
boolean a = true;
boolean result = !a;  // false

 

4️⃣할당 μ—°μ‚°μž

ν• λ‹Ή μ—°μ‚°μžλŠ” λ³€μˆ˜μ— κ°’을 ν• λ‹Ήν•˜λŠ” λ° μ‚¬μš©λ˜λŠ” μ—°μ‚°μžμž…λ‹ˆλ‹€

 

 

 1. κΈ°λ³Έ ν• λ‹Ή μ—°μ‚°μž ( ' = ' )

  • κ°€μž₯ κΈ°λ³Έμ μΈ ν• λ‹Ή μ—°μ‚°μžλ‘œ, μ˜€λ₯Έμͺ½ ν”Όμ—°μ‚°μžμ˜ κ°’을 μ™Όμͺ½ ν”Όμ—°μ‚°μž(λ³€μˆ˜)에 μ €μž₯ν•©λ‹ˆλ‹€.
int a = 10;  // a λ³€μˆ˜μ— 10을 ν• λ‹Ή

 

 2. λ§μ…ˆ ν• λ‹Ή μ—°μ‚°μž ( ' += ' )

  • μ™Όμͺ½ λ³€μˆ˜μ— μ˜€λ₯Έμͺ½ κ°’을 λ”ν•˜κ³  κ²°κ³Όλ₯Ό μ™Όμͺ½ λ³€μˆ˜μ— μ €μž₯ν•©λ‹ˆλ‹€.
int a = 5;
a += 3;  // a = a + 3κ³Ό 동일, aλŠ” 이제 8

 

 

 3. λΊ„μ…ˆ ν• λ‹Ή μ—°μ‚°μž ( ' -= ' )

  • μ™Όμͺ½ λ³€μˆ˜μ—μ„œ μ˜€λ₯Έμͺ½ κ°’을 λΉΌκ³  κ²°κ³Όλ₯Ό μ™Όμͺ½ λ³€μˆ˜μ— μ €μž₯ν•©λ‹ˆλ‹€.
int a = 5;
a -= 2;  // a = a - 2와 동일, aλŠ” 이제 3

 

 4. κ³±μ…ˆ ν• λ‹Ή μ—°μ‚°μž ( ' *= ' )

  • μ™Όμͺ½ λ³€μˆ˜μ— μ˜€λ₯Έμͺ½ κ°’을 κ³±ν•˜κ³  κ²°κ³Όλ₯Ό μ™Όμͺ½ λ³€μˆ˜μ— μ €μž₯ν•©λ‹ˆλ‹€.
int a = 5;
a *= 2;  // a = a * 2와 동일, aλŠ” 이제 10

 

 5. λ‚˜λˆ—μ…ˆ ν• λ‹Ή μ—°μ‚°μž ( ' /= ' )

  • μ™Όμͺ½ λ³€μˆ˜λ₯Ό μ˜€λ₯Έμͺ½ κ°’μœΌλ‘œ λ‚˜λˆ„κ³  κ²°κ³Όλ₯Ό μ™Όμͺ½ λ³€μˆ˜μ— μ €μž₯ν•©λ‹ˆλ‹€.
int a = 10;
a /= 2;  // a = a / 2와 동일, aλŠ” 이제 5

 


 

 

5οΈβƒ£λΉ„νŠΈ μ—°μ‚°μž

Javaμ—μ„œ λΉ„νŠΈ μ—°μ‚°μžλŠ” μ •μˆ˜ νƒ€μž…μ˜ λ°μ΄ν„°μ— λŒ€ν•΄ λΉ„νŠΈ λ‹¨μœ„λ‘œ μ—°μ‚°μ„ μˆ˜ν–‰ν•˜λŠ” μ—°μ‚°μž

 

AND
μ—°μ‚°μž (&)
두 ν”Όμ—°μ‚°μžμ˜ λΉ„νŠΈλ₯Ό λΉ„κ΅ν•˜μ—¬ λ‘˜ λ‹€ 1이면 결과의 ν•΄λ‹Ή λΉ„νŠΈλ₯Ό 1둜, ν•˜λ‚˜λΌλ„ 0이면 0으둜 μ„€μ •ν•©λ‹ˆλ‹€. 5 & 3 (μ΄μ§„μˆ˜λ‘œ 0101 & 0011)의 κ²°κ³ΌλŠ” 0001μ΄λ―€λ‘œ, κ²°κ³ΌλŠ” 1μž…λ‹ˆλ‹€.
OR
μ—°μ‚°μž
( | )
두 ν”Όμ—°μ‚°μžμ˜ λΉ„νŠΈλ₯Ό λΉ„κ΅ν•˜μ—¬ ν•˜λ‚˜λΌλ„ 1이면 κ²°κ³Όμ˜ ν•΄λ‹Ή λΉ„νŠΈλ₯Ό 1둜, λ‘˜ λ‹€ 0이면 0으둜 μ„€μ •ν•©λ‹ˆλ‹€. 5 | 3 (μ΄μ§„μˆ˜λ‘œ 0101 | 0011)의 κ²°κ³ΌλŠ” 0111μ΄λ―€λ‘œ, κ²°κ³ΌλŠ” 7μž…λ‹ˆλ‹€.
XOR
μ—°μ‚°μž (^)
두 ν”Όμ—°μ‚°μžμ˜ λΉ„νŠΈλ₯Ό λΉ„κ΅ν•˜μ—¬ λΉ„νŠΈκ°€ μ„œλ‘œ λ‹€λ₯΄λ©΄ 결과의 ν•΄λ‹Ή λΉ„νŠΈλ₯Ό 1둜, κ°™μœΌλ©΄ 0으둜 μ„€μ •ν•©λ‹ˆλ‹€. 이 연산은 두 κ°’μ˜ 차이λ₯Ό κ²€μΆœν•˜λŠ” 데 μœ μš©ν•©λ‹ˆλ‹€. 5 ^ 3 (μ΄μ§„μˆ˜λ‘œ 0101 ^ 0011)의 κ²°κ³ΌλŠ” 0110μ΄λ―€λ‘œ, κ²°κ³ΌλŠ” 6μž…λ‹ˆλ‹€.
NOT
μ—°μ‚°μž (~)
단일 ν”Όμ—°μ‚°μžμ˜ λͺ¨λ“  λΉ„νŠΈλ₯Ό λ°˜μ „μ‹œν‚΅λ‹ˆλ‹€. 1은 0으둜, 0은 1둜 λ°”λ€λ‹ˆλ‹€. 이 μ—°μ‚°μžλŠ” 보수λ₯Ό ꡬ할 λ•Œ μ‚¬μš©λ©λ‹ˆλ‹€. ~5 (μ΄μ§„μˆ˜λ‘œ ~0101)의 κ²°κ³ΌλŠ” 1010 (2의 보수 ν‘œν˜„μ—μ„œλŠ” -6)μž…λ‹ˆλ‹€. μ‹€μ œ κ²°κ³ΌλŠ” λͺ¨λ“  λΉ„νŠΈκ°€ λ°˜μ „λ˜κ³ , μΆ”κ°€ λΉ„νŠΈλ“€λ„ λ°˜μ „λ˜μ–΄ 음수 값이 λ©λ‹ˆλ‹€.
Left
Shift (<<)
ν”Όμ—°μ‚°μžμ˜ λͺ¨λ“  λΉ„νŠΈλ₯Ό μ§€μ •λœ 수만큼 μ™Όμͺ½μœΌλ‘œ μ΄λ™μ‹œν‚΅λ‹ˆλ‹€. μƒˆλ‘œ μƒκΈ°λŠ” λΉ„νŠΈλŠ” 0으둜 μ±„μ›Œμ§‘λ‹ˆλ‹€. 이 연산은 주둜 값을 λΉ λ₯΄κ²Œ κ³±ν•˜κΈ° μœ„ν•΄ μ‚¬μš©λ©λ‹ˆλ‹€. 5 << 1은 0101을 μ™Όμͺ½μœΌλ‘œ ν•œ λΉ„νŠΈ μ΄λ™μ‹œν‚΅λ‹ˆλ‹€. κ²°κ³ΌλŠ” 1010, 즉 10μž…λ‹ˆλ‹€.
Right
Shift (>>)
ν”Όμ—°μ‚°μžμ˜ λͺ¨λ“  λΉ„νŠΈλ₯Ό μ§€μ •λœ 수만큼 였λ₯Έμͺ½μœΌλ‘œ μ΄λ™μ‹œν‚΅λ‹ˆλ‹€. μƒˆλ‘œ μƒκΈ°λŠ” λΉ„νŠΈλŠ” ν”Όμ—°μ‚°μžμ˜ μ΅œμƒμœ„ λΉ„νŠΈ(λΆ€ν˜Έ λΉ„νŠΈ)와 같은 κ°’μœΌλ‘œ μ±„μ›Œμ§‘λ‹ˆλ‹€ (μ΄λŠ” λΆ€ν˜Έ μžˆλŠ” 였λ₯Έμͺ½ μ‹œν”„νŠΈλ‘œ, λΆ€ν˜Έλ₯Ό μœ μ§€ν•©λ‹ˆλ‹€). -10 >> 2λŠ” -10 (μ΄μ§„μˆ˜λ‘œ 11110110μ—μ„œ 2개의 였λ₯Έμͺ½ μ‹œν”„νŠΈ)을 κ³„μ‚°ν•©λ‹ˆλ‹€. κ²°κ³ΌλŠ” -3μž…λ‹ˆλ‹€.
Unsigned Right Shift (>>>) ν”Όμ—°μ‚°μžμ˜ λͺ¨λ“  λΉ„νŠΈλ₯Ό μ§€μ •λœ 수만큼 였λ₯Έμͺ½μœΌλ‘œ μ΄λ™μ‹œν‚€λ©°, μ΅œμƒμœ„ λΉ„νŠΈλŠ” 0으둜 μ±„μ›Œμ§‘λ‹ˆλ‹€. 이 연산은 λΆ€ν˜Έλ₯Ό κ³ λ €ν•˜μ§€ μ•ŠλŠ” 였λ₯Έμͺ½ μ‹œν”„νŠΈμž…λ‹ˆλ‹€. -10 >>> 2λŠ” -10을 였λ₯Έμͺ½μœΌλ‘œ 두 λΉ„νŠΈ μ΄λ™μ‹œν‚€κ³ , μƒμœ„ λΉ„νŠΈλŠ” 0으둜 μ±„μ›Œμ§‘λ‹ˆλ‹€. κ²°κ³ΌλŠ” 큰 μ–‘μˆ˜ 값이 λ©λ‹ˆλ‹€.

 

ex ) λΉ„νŠΈ μ—°μ‚°μž μ˜ˆμ‹œ

int a = 12; // 12의 이진 ν‘œν˜„: 1100
int b = 9;  //  9의 이진 ν‘œν˜„: 1001
int result = a & b; // κ²°κ³Ό: 1000, μ΄μ§„μˆ˜λ‘œ 8

System.out.println(result); // 좜λ ₯: 8

 

 


6️⃣증감 μ—°μ‚°

 1. μ „μœ„ 증감 μ—°μ‚°μž  (Pre-Increment/Pre-Decrement)

 μ „μœ„ 증감 μ—°μ‚°μžλŠ” λ³€μˆ˜μ˜ 값을 λ¨Όμ € μ¦κ°€μ‹œν‚€κ±°λ‚˜ κ°μ†Œμ‹œν‚¨ ν›„, κ·Έ κ²°κ³Όλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€. μ—°μ‚°μžλŠ” λ³€μˆ˜ μ•ž 

 μ—  μœ„μΉ˜ν•©λ‹ˆλ‹€.

  • ++λ³€μˆ˜ (Pre-Increment): λ³€μˆ˜μ˜ 값을 1 μ¦κ°€μ‹œν‚¨ ν›„, μ¦κ°€λœ 값을 λ°˜ν™˜ν•©λ‹ˆλ‹€.
  • -λ³€μˆ˜ (Pre-Decrement): λ³€μˆ˜μ˜ 값을 1 κ°μ†Œμ‹œν‚¨ ν›„, κ°μ†Œλœ 값을 λ°˜ν™˜ν•©λ‹ˆλ‹€.
int a = 5;
int result = ++a;  // a의 값을 λ¨Όμ € 1 μ¦κ°€μ‹œν‚€κ³ , κ·Έ ν›„ result에 a의 값을 ν• λ‹Ήν•©λ‹ˆλ‹€.
// a와 result λͺ¨λ‘ 6이 λ©λ‹ˆλ‹€.

 

 

2. ν›„μœ„ 증감 μ—°μ‚°μž  (Post-Increment/Post-Decrement)

ν›„μœ„ 증감 μ—°μ‚°μžλŠ” λ³€μˆ˜μ˜ ν˜„μž¬ 값을 λ°˜ν™˜ν•œ ν›„, λ³€μˆ˜μ˜ 값을 1 μ¦κ°€μ‹œν‚€κ±°λ‚˜ κ°μ†Œμ‹œν‚΅λ‹ˆλ‹€. μ—°μ‚°μžλŠ” λ³€μˆ˜ 뒀에 μœ„μΉ˜ν•©λ‹ˆλ‹€.

  • λ³€μˆ˜++ (Post-Increment): λ³€μˆ˜μ˜ ν˜„μž¬ 값을 λ°˜ν™˜ν•œ ν›„, κ·Έ 값을 1 μ¦κ°€μ‹œν‚΅λ‹ˆλ‹€.
  • λ³€μˆ˜-- (Post-Decrement): λ³€μˆ˜μ˜ ν˜„μž¬ 값을 λ°˜ν™˜ν•œ ν›„, κ·Έ 값을 1 κ°μ†Œμ‹œν‚΅λ‹ˆλ‹€.
int a = 5;
int result = a++;  // a의 ν˜„μž¬ 값을 result에 ν• λ‹Ήν•˜κ³ , κ·Έ ν›„ a의 값을 1 μ¦κ°€μ‹œν‚΅λ‹ˆλ‹€.
// resultλŠ” 5, aλŠ” 6이 λ©λ‹ˆλ‹€.

 

 

7️⃣그 μ™Έ

1. μ‚Όν•­  μ—°μ‚°μž  

Javaμ—μ„œ μ‚Όν•­ μ—°μ‚°μžλŠ” μ‘°κ±΄ μ—°μ‚°μžλΌκ³ λ„ λΆˆλ¦¬λ©°, κ°„λ‹¨ν•œ μ‘°κ±΄λ¬Έμ„ κ°„κ²°ν•˜κ²Œ ν‘œν˜„ν•  μˆ˜ μžˆκ²Œ ν•΄μ€λ‹ˆλ‹€.

 

쑰건 ? ν‘œν˜„μ‹1 : ν‘œν˜„μ‹2

 

쑰건을 ν‰κ°€ν•©λ‹ˆλ‹€. μ‘°κ±΄μ΄ true일 κ²½μš°, ν‘œν˜„식1을 μ‹€ν–‰ν•˜κ³  κ·Έ κ²°κ³Όλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€. 

쑰건이 false일 κ²½μš°, ν‘œν˜„식2λ₯Ό μ‹€ν–‰ν•˜κ³  κ·Έ κ²°κ³Όλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

 

 

ex ) μ΅œλŒ€κ°’ μ°ΎκΈ°

int a = 5;
int b = 10;
int max = a > b ? a : b;
System.out.println("Max: " + max); // 좜λ ₯: Max: 10

 

 

 

 

 

 

 


μ—°μ‚°μžλŠ” ν”„λ‘œκ·Έλž˜λ° μ–Έμ–΄μ—μ„œ 데이터λ₯Ό μ‘°μž‘ν•˜κ³ 
ν”„λ‘œκ·Έλž¨μ˜ 흐름을 μ œμ–΄ν•˜λŠ” 데 ν•„μˆ˜μ μΈ μš”μ†Œμž…λ‹ˆλ‹€!