Java์์ Boolean ๋ฐ์ดํฐ ํ์
์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ฐธ(true
) ๋๋ ๊ฑฐ์ง(false
)์ ๋ ๊ฐ์ง ๊ฐ๋ง์ ์ ์ฅํ ์ ์๋ ๋ฐ์ดํฐ ํ์
์
๋๋ค. Boolean ํ์
์ ์กฐ๊ฑด๋ฌธ๊ณผ ๋
ผ๋ฆฌ ์ฐ์ฐ์ ๋ค๋ฃฐ ๋ ํ์์ ์ด๋ฉฐ, ํ๋ก๊ทธ๋จ์ ํ๋ฆ ์ ์ด์ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ Java์์ Boolean ํ์
์ ์ ์ธํ๊ณ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ, ๊ทธ๋ฆฌ๊ณ ๋ค์ํ ํ์ฉ ์์ ๋ฅผ ์๊ฐํ๊ฒ ์ต๋๋ค.
Boolean ๋ฐ์ดํฐ ํ์ ์ด๋?
boolean
๋ฐ์ดํฐ ํ์
์ true
๋๋ false
๊ฐ๋ง์ ๊ฐ์ง ์ ์์ต๋๋ค. Boolean ๋ณ์๋ ์ฃผ๋ก ์กฐ๊ฑด๋ฌธ์ด๋ ๋ฐ๋ณต๋ฌธ์์ ์กฐ๊ฑด์ ๊ฒ์ฌํ ๋ ์ฌ์ฉ๋๋ฉฐ, ํ๋ก๊ทธ๋จ์ ๋
ผ๋ฆฌ์ ํ๋ฆ์ ์ ์ดํ๋ ๋ฐ ๋งค์ฐ ์ ์ฉํฉ๋๋ค.
Boolean ๋ณ์ ์ ์ธ ์์
public class BooleanExample {
public static void main(String[] args) {
boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println("Java๋ ์ฌ๋ฏธ์๋ค: " + isJavaFun);
System.out.println("๋ฌผ๊ณ ๊ธฐ๋ ๋ง์๋ค: " + isFishTasty);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
Java๋ ์ฌ๋ฏธ์๋ค: true
๋ฌผ๊ณ ๊ธฐ๋ ๋ง์๋ค: false
์ ์ฝ๋์์๋ isJavaFun
๋ณ์์ true
, isFishTasty
๋ณ์์ false
๊ฐ์ ํ ๋นํ์ฌ, ๊ฐ๊ฐ์ ๋
ผ๋ฆฌ ์ํ๋ฅผ ์ ์ฅํ๊ณ ์ถ๋ ฅํ๊ณ ์์ต๋๋ค.
Boolean ๋ฐ์ดํฐ ํ์ ์ ํ์ฉ
1. ์กฐ๊ฑด๋ฌธ์์ Boolean ํ์ฉ
Boolean ํ์
์ ์ฃผ๋ก if
, else
์ ๊ฐ์ ์กฐ๊ฑด๋ฌธ์์ ์ฌ์ฉ๋์ด ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ค๋ฅธ ์ฝ๋๋ฅผ ์คํํ ์ ์๋๋ก ๋์ต๋๋ค.
์์ ์ฝ๋
public class ConditionalExample {
public static void main(String[] args) {
boolean isRaining = true;
if (isRaining) {
System.out.println("์ฐ์ฐ์ ๊ฐ์ ธ๊ฐ์ธ์.");
} else {
System.out.println("๋ง์ ๋ ์จ์
๋๋ค!");
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์ฐ์ฐ์ ๊ฐ์ ธ๊ฐ์ธ์.
์ ์ฝ๋์์๋ isRaining
๋ณ์๊ฐ true
์ผ ๋ "์ฐ์ฐ์ ๊ฐ์ ธ๊ฐ์ธ์."๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค. false
์ผ ๊ฒฝ์ฐ์๋ "๋ง์ ๋ ์จ์
๋๋ค!"๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค.
2. ๋ฐ๋ณต๋ฌธ์์ Boolean ํ์ฉ
boolean
๋ณ์๋ while
๊ณผ ๊ฐ์ ๋ฐ๋ณต๋ฌธ์์๋ ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํน์ ์กฐ๊ฑด์ด true
์ธ ๋์ ๋ฐ๋ณต ์คํํ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
์์ ์ฝ๋
public class WhileLoopExample {
public static void main(String[] args) {
boolean keepGoing = true;
int counter = 0;
while (keepGoing) {
System.out.println("์นด์ดํฐ: " + counter);
counter++;
if (counter >= 5) {
keepGoing = false;
}
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์นด์ดํฐ: 0
์นด์ดํฐ: 1
์นด์ดํฐ: 2
์นด์ดํฐ: 3
์นด์ดํฐ: 4
์ ์ฝ๋์์๋ keepGoing
์ด true
์ธ ๋์ counter
๊ฐ์ ์ถ๋ ฅํ๋ฉฐ, counter
๊ฐ 5 ์ด์์ด ๋๋ฉด keepGoing
์ false
๋ก ์ค์ ํด ๋ฐ๋ณต์ ์ข
๋ฃํฉ๋๋ค.
3. ๋ ผ๋ฆฌ ์ฐ์ฐ์์ Boolean
Java์์๋ Boolean ํ์
๊ณผ ํจ๊ป ๋
ผ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ณต์กํ ์กฐ๊ฑด์ ๊ตฌ์ฑํ ์ ์์ต๋๋ค. ๋ํ์ ์ธ ๋
ผ๋ฆฌ ์ฐ์ฐ์๋ก๋ &&
(AND), ||
(OR), !
(NOT)๊ฐ ์์ต๋๋ค.
์์ ์ฝ๋
public class LogicalOperatorsExample {
public static void main(String[] args) {
boolean isWeekend = true;
boolean isSunny = false;
if (isWeekend && isSunny) {
System.out.println("๋ ์จ๊ฐ ์ข์ผ๋ ์ํ์ ๊ฐ์!");
} else if (isWeekend || isSunny) {
System.out.println("์ํ์ ๊ฐ์ง ๊ณ ๋ฏผํด ๋ณด์.");
} else {
System.out.println("์ค๋์ ์ํ์ ๊ฐ์ง ์๊ฒ ์ต๋๋ค.");
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์ํ์ ๊ฐ์ง ๊ณ ๋ฏผํด ๋ณด์.
์ ์ฝ๋์์๋ isWeekend
์ isSunny
์ ์กฐํฉ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ถ๋ ฅ์ด ํ์๋ฉ๋๋ค. isWeekend && isSunny
๋ ๋ ๋ค true
์ผ ๋๋ง ์ฐธ์ด ๋๋ฉฐ, isWeekend || isSunny
๋ ๋ ์ค ํ๋๋ผ๋ true
์ผ ๊ฒฝ์ฐ ์ฐธ์ด ๋ฉ๋๋ค.
Boolean ๋ํผ ํด๋์ค
Java์ Boolean
์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์
์ธ์๋ ๋ํผ ํด๋์ค Boolean
์ ์ ๊ณตํฉ๋๋ค. ๊ธฐ๋ณธ ํ์
๊ณผ ๋ฌ๋ฆฌ Boolean
๊ฐ์ฒด๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฒด๋ก ๋ค๋ฃฐ ๋ ์ ์ฉํฉ๋๋ค.
Boolean ๊ฐ์ฒด ์์ฑ ์์
public class BooleanWrapperExample {
public static void main(String[] args) {
Boolean isActive = Boolean.valueOf(true);
Boolean isClosed = Boolean.parseBoolean("false");
System.out.println("isActive: " + isActive);
System.out.println("isClosed: " + isClosed);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
isActive: true
isClosed: false
Boolean.valueOf
๋ฉ์๋๋ฅผ ์ฌ์ฉํด true
๋๋ false
๊ฐ์ ๊ฐ๋ Boolean
๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์์ผ๋ฉฐ, Boolean.parseBoolean
๋ฉ์๋๋ฅผ ํตํด ๋ฌธ์์ด ๊ฐ์ Boolean์ผ๋ก ๋ณํํ ์๋ ์์ต๋๋ค.
Boolean๊ณผ ์ผํญ ์ฐ์ฐ์
Boolean ํ์
์ ์ผํญ ์ฐ์ฐ์(condition ? value1 : value2
)์ ํจ๊ป ์์ฃผ ์ฌ์ฉ๋๋ฉฐ, ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ์ ์ ํํ ๋ ์ ์ฉํฉ๋๋ค.
์ผํญ ์ฐ์ฐ์ ์์
public class TernaryExample {
public static void main(String[] args) {
boolean isMember = true;
String accessLevel = isMember ? "์ ๊ทผ ํ์ฉ" : "์ ๊ทผ ๋ถ๊ฐ";
System.out.println("์ฌ์ฉ์ ์ ๊ทผ ์์ค: " + accessLevel);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์ฌ์ฉ์ ์ ๊ทผ ์์ค: ์ ๊ทผ ํ์ฉ
์ ์ฝ๋์์๋ isMember
๊ฐ true
์ผ ๊ฒฝ์ฐ "์ ๊ทผ ํ์ฉ"์ด ํ ๋น๋๊ณ , false
์ผ ๊ฒฝ์ฐ "์ ๊ทผ ๋ถ๊ฐ"๊ฐ ํ ๋น๋ฉ๋๋ค.
๊ฒฐ๋ก
Java์ boolean
๋ฐ์ดํฐ ํ์
์ ํ๋ก๊ทธ๋จ์์ ์กฐ๊ฑด์ ๋ค๋ฃจ๊ณ ๋
ผ๋ฆฌ์ ํ๋ฆ์ ์ ์ดํ๋ ๋ฐ ํ์์ ์ธ ์์์
๋๋ค. Boolean ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ, ๋
ผ๋ฆฌ ์ฐ์ฐ์์ ํจ๊ป ํ์ฉํ๋ฉด ์ฝ๋์ ์ ์ฐ์ฑ๊ณผ ํจ์จ์ฑ์ด ํฌ๊ฒ ํฅ์๋ฉ๋๋ค. ์ด๋ฒ ๊ธ์์ ๋ค๋ฃฌ ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ๊ณผ ๋ค์ํ ์์ ๋ฅผ ํตํด Java์ Boolean ํ์
์ ์ดํดํ๊ณ , ์ค์ ์ฝ๋์์ ํจ์จ์ ์ผ๋ก ํ์ฉํด ๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ