์๋
ํ์ธ์! ์ง๋ ์์
์์ ์ฐ๋ฆฌ๋ ํด๋์ค์ ์์ฑ์์ ๋ํด ์๊ฒ ๋์๊ณ ์ฐ๋ฆฌ ์์ ์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ์ต๋๋ค. ์ค๋ ์ฐ๋ฆฌ๋ ์์
์ ํ์์ ์ธ ๋ถ๋ถ์ธ Java ๋ฉ์๋์ ๋ํด ๋ ์ ์๊ฒ ๋ ๊ฒ์
๋๋ค. Java์ ๋ฉ์๋๋ ํ๋ก๊ทธ๋จ์์ ํน์ ์์
์ ์ํํ ์ ์๋๋ก ํ๋ ๋ช
๋ น ์งํฉ์
๋๋ค. ์ฆ, ๋ฉ์๋๋ ํจ์์
๋๋ค. ํด๋์ค๊ฐ ํ ์ ์๋ ๊ฒ. ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์๋ ๋ฉ์๋๋ฅผ ์ข
์ข
"ํจ์"๋ผ๊ณ ๋ถ๋ฅด์ง๋ง Java์์๋ "๋ฉ์๋"๋ผ๋ ๋จ์ด๊ฐ ๋ ์ผ๋ฐ์ ์
๋๋ค. :) ๊ธฐ์ตํ์๊ฒ ์ง๋ง, ์ง๋ ์์
์์ Cat ํด๋์ค ์ ๋ํ ๊ฐ๋จํ ๋ฉ์๋๋ฅผ ๋ง๋ค์ด์ ๊ณ ์์ด๊ฐ ์ผ์นํ๊ณ ์ ํํ ์ ์๋๋ก ํ์ต๋๋ค.
๋ฐ๋ผ์ ๊ฐ์ฒด๋ ์ฐธ์กฐ์ ์ํด ๋ฉ์๋์ ์ ๋ฌ๋๋ ๊ฒ์ผ๋ก ๋ํ๋ฌ์ต๋๋ค. ๊ฐ์ฒด์ ๋ณต์ฌ๋ณธ์ ์๋์ผ๋ก ์์ฑ๋์ง ์์ต๋๋ค. ๊ณ ์์ด ๊ฐ์ฒด๋ฅผ ๋ฉ์๋์ ์ ๋ฌํ๊ณ ์๋ช
์ ๋ณ๊ฒฝํ๋ฉด ์๋ช
๋ ๋ณ๊ฒฝ๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ์ฐธ์กฐ ๋ณ์๋ ๊ฐ์ ํ ๋นํ๊ฑฐ๋ ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋ณต์ฌ๋ฉ๋๋ค! ํ๋ฆฌ๋ฏธํฐ๋ธ ์ ๋ฌ์ ๋ํด ๋งํ ๋ด์ฉ์ ์ฌ๊ธฐ์์ ๋ฐ๋ณตํด ๋ณด๊ฒ ์ต๋๋ค. " changeInt() ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ int๋ณ์ x (=15) , ๋ฉ์๋๋ x ๋ณ์ ์์ฒด๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ์ด ์๋๋ผ ๋ณต์ฌ๋ณธ์ ๊ฐ์ ธ์ต๋๋ค. ๋ฐ๋ผ์ ์ฌ๋ณธ์ ๋ํ ๋ณ๊ฒฝ ์ฌํญ์ ์๋ณธ x ์ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค.Java์์ ์ธ์๊ฐ ์ ๋ฌ๋๋ ๋ฐฉ์์ ๋ํด ํ ๋ฒ ์ด์ ๋
ผ์ํ๊ฒ ๋ ๊ฒ์
๋๋ค(์๋ จ๋ ๊ฐ๋ฐ์ ์ฌ์ด์์๋). ๊ทธ๋ฌ๋ ์ด์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์ ํํ ์๊ณ ์์ต๋๋ค. ๊ณ์ ํ์ธ์! :) ๋ฐฐ์ด ๋ด์ฉ์ ๋ณด๊ฐํ๋ ค๋ฉด Java ๊ณผ์ ์์ ๋น๋์ค ๊ฐ์๋ฅผ ์์ฒญํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
public class Cat {
String name;
int age;
public void sayMeow() {
System.out.println("Meow!");
}
public void jump() {
System.out.println("Pounce!");
}
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
smudge.sayMeow();
smudge.jump();
}
}
sayMeow() ๋ฐ jump()๋ ์ฐ๋ฆฌ ํด๋์ค์ ๋ฉ์๋์
๋๋ค. ์ด๋ฌํ ๋ฉ์๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์ฝ์ ์ถ๋ ฅ์ด ์์ฑ๋ฉ๋๋ค.
Meow!
Pounce!
์ฐ๋ฆฌ์ ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋จ์ํ ์ฝ์์ ํ
์คํธ๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ๊ทธ๋ฌ๋ Java์์ ๋ฉ์๋๋ ์ค์ํ ์์
์ด ์์ต๋๋ค. ๊ฐ์ฒด์ ๋ฐ์ดํฐ์ ๋ํ ์์
์ ์ํํฉ๋๋ค. ๊ฐ์ฒด์ ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ๊ณ ๋ณํํ๊ณ ํ์ํ๊ณ ๋ค๋ฅธ ์์
์ ์ํํฉ๋๋ค. ์ฐ๋ฆฌ์ ํ์ฌ ๋ฉ์๋๋ Cat ๊ฐ์ฒด์ ๋ฐ์ดํฐ ๋ก ์๋ฌด ์์
๋ ์ํํ์ง ์์ต๋๋ค . ์ข ๋ ์์์ ์ธ ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
public class Truck {
int length;
int width;
int height;
int weight;
public int getVolume() {
int volume = length * width * height;
return volume;
}
}
์๋ฅผ ๋ค์ด ์ฌ๊ธฐ์ Truck ์ ๋ํ๋ด๋ ํด๋์ค๊ฐ ์์ต๋๋ค . ์ธ๋ฏธ ํธ๋ญ์๋ ๊ธธ์ด, ๋๋น, ๋์ด ๋ฐ ๋ฌด๊ฒ๊ฐ ์์ต๋๋ค(๋์ค์ ํ์ํจ). getVolume() ๋ฉ์๋ ์์ ๊ฐ์ฒด์ ๋ฐ์ดํฐ๋ฅผ ๋ถํผ๋ฅผ ๋ํ๋ด๋ ์ซ์(๊ธธ์ด, ๋๋น ๋ฐ ๋์ด๋ฅผ ๊ณฑํจ)๋ก ๋ณํํ์ฌ ๊ณ์ฐ์ ์ํํฉ๋๋ค. ์ด ์ซ์๋ ๋ฉ์๋์ ๊ฒฐ๊ณผ์
๋๋ค. ๋ฉ์๋์ ์ ์ธ์ public int getVolume ์ผ๋ก ์์ฑ๋ฉ๋๋ค . ์ฆ, ์ด ๋ฉ์๋๋ int ๋ฅผ ๋ฐํํด์ผ ํฉ๋๋ค . ๋ฉ์๋์ ๋ฐํ ๊ฐ์ ๊ณ์ฐํ์ผ๋ฉฐ ์ด์ ๋ฉ์๋๋ฅผ ํธ์ถํ ํ๋ก๊ทธ๋จ์ ๋ฐํํด์ผ ํฉ๋๋ค. Java์์ ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ค๋ฉด return ํค์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๋ฐํ ๋ณผ๋ฅจ;
์๋ฐ ๋ฉ์๋ ๋งค๊ฐ๋ณ์
๋ฉ์๋๋ฅผ ํธ์ถํ ๋ "์ธ์"๋ผ๋ ๊ฐ์ ๋ฉ์๋์ ์ ๋ฌํ ์ ์์ต๋๋ค. ๋ฉ์๋์ ์ ์ธ์๋ ๋ฉ์๋๊ฐ ํ์ฉํ ์ ์๋ ๋ณ์์ ์ ํ๊ณผ ์์๋ฅผ ์๋ ค์ฃผ๋ ๋ณ์ ๋ชฉ๋ก์ด ํฌํจ๋ฉ๋๋ค. ์ด ๋ชฉ๋ก์ "๋ฉ์๋ ๋งค๊ฐ๋ณ์"๋ผ๊ณ ํฉ๋๋ค. Truck ํด๋์ค ์ getVolume() ๋ฉ์๋๋ ํ์ฌ ๋งค๊ฐ๋ณ์๋ฅผ ์ ์ํ์ง ์์ผ๋ฏ๋ก ํธ๋ญ ์์ ๋ฅผ ํ์ฅํด ๋ณด๊ฒ ์ต๋๋ค. BridgeOfficer ๋ผ๋ ์ ํด๋์ค๋ฅผ ๋ง๋ญ๋๋ค . ์ด๊ฒ์ ๊ต๋์์ ๊ทผ๋ฌดํ๋ ๊ฒฝ์ฐฐ๊ด์ผ๋ก, ํต๊ณผํ๋ ๋ชจ๋ ํธ๋ญ์ด ํ์ฉ ์ค๋์ ์ด๊ณผํ๋์ง ํ์ธํฉ๋๋ค.public class BridgeOfficer {
int maxWeight;
public BridgeOfficer(int normalWeight) {
this.maxWeight = normalWeight;
}
public boolean checkTruck(Truck truck) {
if (truck.weight > maxWeight) {
return false;
} else {
return true;
}
}
}
checkTruck ๋ฉ์๋๋ Truck ๊ฐ์ฒด ๋ผ๋ ํ๋์ ์ธ์๋ฅผ ๋ฐ์๋ค์ด๊ณ ๊ฒฝ์ฐฐ๊ด ์ด ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ๋๋ก ํ์ฉํ ์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํฉ๋๋ค. ๋ฉ์๋ ๋ด๋ถ์ ๋
ผ๋ฆฌ๋ ๊ฐ๋จํฉ๋๋ค. ํธ๋ญ์ ๋ฌด๊ฒ๊ฐ ํ์ฉ๋ ์ต๋๊ฐ์ ์ด๊ณผํ๋ฉด ๋ฉ์๋๋ false ๋ฅผ ๋ฐํํฉ๋๋ค . ๋ค๋ฅธ ๊ธธ์ ์ฐพ์์ผ ํฉ๋๋ค :( ๊ฐ์ค์น๊ฐ ์ต๋๊ฐ ์ดํ์ด๋ฉด ํต๊ณผํ ์ ์์ผ๋ฉฐ ๋ฉ์๋๋ true๋ฅผ ๋ฐํํฉ๋๋ค.. "return" ๋๋ "the method returns a value"๋ผ๋ ๋ฌธ๊ตฌ๋ฅผ ์์ง ์์ ํ ์ดํดํ์ง ๋ชปํ๋ค๋ฉด ํ๋ก๊ทธ๋๋ฐ์ ์ ์ ์ค๋จํ๊ณ ์ค์ํ์ ๊ฐ๋จํ ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ณ ๋ คํ์ญ์์ค. :) ๋น์ ์ด ์ํ๊ณ ๋ฉฐ์น ๋์ ์ผ์ ํ์ง ์๊ณ ์ง์ ์๋ค๊ณ ๊ฐ์ ํด ๋ด
์๋ค. ๋ณ๊ฐ๋ ์ง๋ถํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์์ฌ์ ์ง๋จ์๋ฅผ ๊ฐ์ง๊ณ ํ๊ณ ๋ถ์์ ๊ฐ๋๋ค. ์ด ์ํฉ์ ๋ฐฉ๋ฒ๊ณผ ๋น๊ตํ๋ฉด ํ๊ณ์ฌ๋ paySickLeave ()๋ฐฉ๋ฒ. ์ด ๋ฐฉ๋ฒ์ ๋ํ ์ธ์๋ก ์์ฌ์ ์ง๋จ์๋ฅผ ์ ๋ฌํฉ๋๋ค(์ด ๋ฐฉ๋ฒ์ด ์์ผ๋ฉด ๋ฐฉ๋ฒ์ด ์๋ํ์ง ์์ผ๋ฉฐ ๊ธ์ฌ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค!). ๊ทธ๋ฐ ๋ค์ ๊ทํ์ ๋ฉ๋ชจ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฉ๋ฒ ๋ด์์ ํ์ํ ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง๊ณ (ํ๊ณ์ฌ๋ ์ด๋ฅผ ์ฌ์ฉํ์ฌ ํ์ฌ๊ฐ ๊ทํ์๊ฒ ์ง๋ถํด์ผ ํ๋ ๊ธ์ก์ ๊ณ์ฐํฉ๋๋ค) ๊ทํ์ ์์
๊ฒฐ๊ณผ(๊ธ์ก)๊ฐ ๊ทํ์๊ฒ ๋ฐํ๋ฉ๋๋ค. ์ฐ๋ฆฌ ํ๋ก๊ทธ๋จ์ ๋น์ทํ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค. ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๊ณ ๊ถ๊ทน์ ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ต๋๋ค. BridgeOfficer ํ๋ก๊ทธ๋จ์ main() ๋ฉ์๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค .
public static void main(String[] args) {
Truck first = new Truck();
first.weight = 10000;
Truck second = new Truck();
second.weight = 20000;
BridgeOfficer officer = new BridgeOfficer(15000);
System.out.println("Truck 1! Can I go, officer?");
boolean canFirstTruckGo = officer.checkTruck(first);
System.out.println(canFirstTruckGo);
System.out.println();
System.out.println("Truck 2! And can I?");
boolean canSecondTruckGo = officer.checkTruck(second);
System.out.println(canSecondTruckGo);
}
์ฐ๋ฆฌ๋ 10,000๊ณผ 20,000์ ์ ์ฌ๋์ ๊ฐ์ง ๋ ๋์ ํธ๋ญ์ ๋ง๋ญ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฅ๊ต๊ฐ ์ผํ๋ ๋ค๋ฆฌ์ ์ต๋ ๋ฌด๊ฒ๋ 15,000์
๋๋ค. ํ๋ก๊ทธ๋จ์ officer.checkTruck(first) ๋ฉ์๋๋ฅผ ํธ์ถํฉ๋๋ค. ๋ฉ์๋๋ ๋ชจ๋ ๊ฒ์ ๊ณ์ฐํ ๋ค์ true ๋ฅผ ๋ฐํํ๊ณ ํ๋ก๊ทธ๋จ์ ์ด๋ฅผ ๋ถ์ธ ๋ณ์ canFirstTruckGo ์ ์ ์ฅํฉ๋๋ค . ์ด์ ํ๊ณ์ฌ๊ฐ ์ค ๋์ผ๋ก ์ํ๋ ๋๋ก ํ ์ ์์ต๋๋ค. ํ๋ฃจ๊ฐ ๋๋๋ฉด ์ฝ๋
boolean canFirstTruckGo = officer.checkTruck(first);
๋ก ์ข
๊ธฐ
boolean canFirstTruckGo = true;
์ฌ๊ธฐ์ ๋งค์ฐ ์ค์ํ ์ ์ด ์์ต๋๋ค. return ๋ฌธ์ ๋ฉ์๋์ ๋ฐํ ๊ฐ์ ๋ฐํํ ๋ฟ๋ง ์๋๋ผ ๋ฉ์๋ ์คํ์ ์ค์งํฉ๋๋ค! return ๋ฌธ ๋ค์ ์ค๋ ์ฝ๋๋ ์คํ๋์ง ์์ต๋๋ค!
public boolean checkTruck(Truck truck) {
if (truck.weight > maxWeight) {
return false;
System.out.println("Turn around, you're overweight!");
} else {
return true;
System.out.println("Everything looks good, go ahead!");
}
}
๋ฉ์๋๊ฐ ์ด๋ฏธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ณ ์ข
๋ฃ๋์๊ธฐ ๋๋ฌธ์ ๋ด๋น์์ ์ค๋ช
์ ํ์๋์ง ์์ต๋๋ค! ํ๋ก๊ทธ๋จ์ ๋ฉ์๋๊ฐ ํธ์ถ๋ ์์น๋ก ๋์๊ฐ๋๋ค. ์ด๊ฒ์ ์ฃผ์ํ ํ์๋ ์์ต๋๋ค. Java ์ปดํ์ผ๋ฌ๋ return ๋ฌธ ๋ค์์ ์ฝ๋๋ฅผ ์์ฑํ๋ ค๊ณ ํ ๋ ์ค๋ฅ๋ฅผ ์์ฑํ ๋งํผ ๋๋ํฉ๋๋ค.
์ด๋ฒค์ ธ์ค: ํ๋ผ๋ฏธํฐ ์
์ฌ๋ฌ ๋ฐฉ๋ฒ์ผ๋ก ๋ฉ์๋๋ฅผ ํธ์ถํด์ผ ํ๋ ์ํฉ์ด ์์ต๋๋ค. ์ฐ๋ฆฌ ์์ ์ ์ธ๊ณต ์ง๋ฅ์ ๋ง๋ค์ด ๋ณด์ง ์๊ฒ ์ต๋๊น? Amazon์๋ Alexa๊ฐ ์๊ณ Apple์๋ Siri๊ฐ ์์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ฐ๋ฆฌ๋ ์ ๊ทธ๊ฒ์ ๊ฐ์ง๋ฉด ์ ๋ฉ๋๊น? :) ์ํ ์์ด์ธ๋งจ์์ ํ ๋ ์คํํฌ๋ ์์ ๋ง์ ๋๋ผ์ด ์ธ๊ณต ์ง๋ฅ์ธ ์๋น์ค๋ฅผ ๋ง๋ญ๋๋ค. ๊ทธ ๋ฉ์ง ์บ๋ฆญํฐ์๊ฒ ๊ฒฝ์๋ฅผ ํํ๊ณ ๊ทธ์ ์ด๋ฆ์ ๊ธฐ๋ฆฌ๊ธฐ ์ํด ์ฐ๋ฆฌ AI์ ์ด๋ฆ์ ์ง์ ํฉ์๋ค. :) ๊ฐ์ฅ ๋จผ์ ํด์ผ ํ ์ผ์ Jarvis์๊ฒ ๋ฐฉ์ ๋ค์ด์ค๋ ์ฌ๋๋ค์๊ฒ ์ธ์ฌํ๋ ๋ฒ์ ๊ฐ๋ฅด์น๋ ๊ฒ์ ๋๋ค.public class Jarvis {
public void sayHi(String name) {
System.out.println("Good evening, " + name + ". How are you?");
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Tony Stark");
}
}
์ฝ์ ์ถ๋ ฅ:
Good evening, Tony Stark. How are you?
๋งค์ฐ ์ข์! ์๋น์ค๋ ์ด์ ์๋์ ๋ง์ดํ ์ ์์ต๋๋ค. ๋ฌผ๋ก , ๊ทธ์ ์ฃผ์ธ์ธ ํ ๋ ์คํํฌ๊ฐ ๊ฐ์ฅ ์์ฃผ ์์ ๊ฒ์
๋๋ค. ํ์ง๋ง ๊ทธ๊ฐ ํผ์ ์ค์ง ์๋๋ค๋ฉด ์ด๋จ๊น์! ์ฐ๋ฆฌ์ sayHi() ๋ฉ์๋๋ ํ๋์ ์ธ์๋ง ํ์ฉํฉ๋๋ค. ๋ฐ๋ผ์ ๋ฐฉ์ ๋ค์ด์ค๋ ํ ์ฌ๋์๊ฒ๋ง ์ธ์ฌํ ์ ์๊ณ ๋ค๋ฅธ ์ฌ๋์ ๋ฌด์ํฉ๋๋ค. ๋งค์ฐ ์์ ๋ฐ๋ฅด์ง ์์ต๋๊น? ๋์ํ์ง ์์ต๋๊น? :/
์๋ฐ ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ
์ด ๊ฒฝ์ฐ ์ด๋ฆ์ ๊ฐ์ง๋ง ๋งค๊ฐ ๋ณ์๊ฐ ๋ค๋ฅธ ๋ ๊ฐ์ง ๋ฉ์๋๋ฅผ ์์ฑํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ต๋๋ค.public class Jarvis {
public void sayHi(String firstGuest) {
System.out.println("Good evening, " + firstGuest + ". How are you?");
}
public void sayHi(String firstGuest, String secondGuest) {
System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
}
}
์ด๋ฅผ ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ด๋ผ๊ณ ํฉ๋๋ค. ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ ํตํด ํ๋ก๊ทธ๋จ์ด ๋ ์ ์ฐํด์ง๊ณ ๋ค์ํ ์์
๋ฐฉ์์ ์์ฉํ ์ ์์ต๋๋ค. ์๋ ๋ฐฉ์์ ๊ฒํ ํด ๋ณด๊ฒ ์ต๋๋ค.
public class Jarvis {
public void sayHi(String firstGuest) {
System.out.println("Good evening, " + firstGuest + ". How are you?");
}
public void sayHi(String firstGuest, String secondGuest) {
System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Tony Stark");
jarvis.sayHi("Tony Stark", "Captain America");
}
}
์ฝ์ ์ถ๋ ฅ:
Good evening, Tony Stark. How are you?
Good evening, Tony Stark and Captain America. How are you?
ํ๋ฅญํฉ๋๋ค. ๋ ๋ฒ์ ๋ชจ๋ ์๋ํ์ต๋๋ค. :) ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ง ๋ชปํ์ต๋๋ค! ์๋์ด 3๋ช
์ด๋ผ๋ฉด? ๋ฌผ๋ก ์ธ ๊ฐ์ ๊ฒ์คํธ ์ด๋ฆ์ ํ์ฉํ๋๋ก sayHi() ๋ฉ์๋๋ฅผ ๋ค์ ์ค๋ฒ๋ก๋ํ ์ ์์ต๋๋ค. ํ์ง๋ง 4๊ฐ ๋๋ 5๊ฐ๊ฐ ์์ ์ ์์ต๋๋ค. ๋ฌดํ๋๊น์ง. sayHi() ๋ฉ์๋๋ฅผ ๋ฐฑ๋ง ๋ฒ ์ค๋ฒ๋ก๋ํ์ง ์๊ณ ์๋น์ค์๊ฒ ์ด๋ฆ์ ์ฒ๋ฆฌํ๋๋ก ๊ฐ๋ฅด์น๋ ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์์๊น์ ? :/ ๋ฌผ๋ก ์์ต๋๋ค! ๊ทธ๋ ์ง ์๋ค๋ฉด Java๊ฐ ์ธ๊ณ์์ ๊ฐ์ฅ ์ธ๊ธฐ ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ์ญ๋๊น? ;)
public void sayHi(String...names) {
for (String name: names) {
System.out.println("Good evening, " + name + ". How are you?");
}
}
( String... names )๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉ๋๋ฉด ๋ฌธ์์ด ๋ชจ์์ด ๋ฉ์๋์ ์ ๋ฌ๋จ์ ๋ํ๋
๋๋ค. ์ผ๋ง๋ ๋ง์์ง ๋ฏธ๋ฆฌ ์ง์ ํ ํ์๊ฐ ์์ผ๋ฏ๋ก ์ด์ ๋ฐฉ๋ฒ์ด ํจ์ฌ ๋ ์ ์ฐํด์ก์ต๋๋ค.
public class Jarvis {
public void sayHi(String...names) {
for (String name: names) {
System.out.println("Good evening, " + name + ". How are you?");
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
}
}
์ฝ์ ์ถ๋ ฅ:
Good evening, Tony Stark. How are you?
Good evening, Captain America. How are you?
Good evening, Black Widow. How are you?
Good evening, Hulk. How are you?
์ฌ๊ธฐ์ ์๋ ์ผ๋ถ ์ฝ๋๋ ์ต์ํ์ง ์์ ์ ์์ง๋ง ๊ฑฑ์ ํ์ง ๋ง์ญ์์ค. ํต์ฌ์ ๊ฐ๋จํฉ๋๋ค. ๋ฐฉ๋ฒ์ ๊ฐ ์ด๋ฆ์ ์ฐจ๋ก๋ก ๊ฐ์ ธ์ ๊ฐ ์๋์ ๋ง์ดํฉ๋๋ค! ๋ํ ์ ๋ฌ๋ ๋ฌธ์์ด ์์ ๊ด๊ณ์์ด ์๋ํฉ๋๋ค! 2๋ช
, 10๋ช
, ์ฌ์ง์ด 1000๋ช
๊น์ง - ์ด ๋ฐฉ๋ฒ์ ์๋์ ์์ ๊ด๊ณ์์ด ์ ์ ํ๊ฒ ์๋ํฉ๋๋ค. ๋ชจ๋ ๊ฐ๋ฅ์ฑ์ ๋ํด ๋ฐฉ๋ฒ์ ์ค๋ฒ๋ก๋ํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ํธ๋ฆฌํ๋ค๊ณ ์๊ฐํ์ง ์์ต๋๊น? :) ์ฌ๊ธฐ์ ๋ ๋ค๋ฅธ ์ค์ํ ์ ์ด ์์ต๋๋ค. ์ธ์์ ์์๊ฐ ์ค์ํฉ๋๋ค! ๋ฉ์๋๊ฐ ๋ฌธ์์ด๊ณผ ์ซ์๋ฅผ ๋ฐ๋๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค.
public class Person {
public static void sayYourAge(String greeting, int age) {
System.out.println(greeting + " " + age);
}
public static void main(String[] args) {
sayYourAge("My age is ", 33);
sayYourAge(33, "My age is "); // Error!
}
}
Person ํด๋์ค์ sayYourAge ๋ฉ์๋๊ฐ ๋ฌธ์์ด๊ณผ ์ซ์๋ฅผ ์
๋ ฅ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ํ๋ก๊ทธ๋จ์ ํน์ ์์๋ก ์ด๋ค์ ์ ๋ฌํด์ผ ํฉ๋๋ค! ๋ค๋ฅธ ์์๋ก ์ ๋ฌํ๋ฉด ์ปดํ์ผ๋ฌ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ณ ์ฌ์ฉ์๋ ์์ ์ ๋์ด๋ฅผ ๋งํ ์ ์์ต๋๋ค. ๊ทธ๊ฑด ๊ทธ๋ ๊ณ , ์ง๋ ์์
์์ ๋ค๋ฃฌ ์์ฑ์๋ ๋ฉ์๋์
๋๋ค! ๋ํ ๊ทธ๊ฒ๋ค์ ์ค๋ฒ๋ก๋ํ ์ ์์ผ๋ฉฐ(์ฆ, ๋งค๊ฐ ๋ณ์ ์งํฉ์ด ๋ค๋ฅธ ์ฌ๋ฌ ์์ฑ์๋ฅผ ์์ฑ) ์ ๋ฌ๋ ์ธ์์ ์์๋ ๊ทผ๋ณธ์ ์ผ๋ก ์ค์ํฉ๋๋ค. ๊ทธ๋ค์ ์ค์ ๋ฐฉ๋ฒ์
๋๋ค! :)
๋งค๊ฐ๋ณ์์ ๋ํด ๋ค์ ํ ๋ฒ
์, ์ฃ์กํฉ๋๋ค. ์์ง ์๋ฃํ์ง ์์์ต๋๋ค. :) ์ง๊ธ ๊ณต๋ถํ ์ฃผ์ ๋ ๋งค์ฐ ์ค์ํฉ๋๋ค. ํฅํ ๋ชจ๋ ์ธํฐ๋ทฐ์์ ์ด์ ๋ํด ์ง๋ฌธ์ ๋ฐ์ ํ๋ฅ ์ด 90%์ ๋๋ค! ๋ฉ์๋์ ์ธ์๋ฅผ ์ ๋ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ด์ผ๊ธฐํด ๋ด ์๋ค. ๊ฐ๋จํ ์๋ฅผ ๊ณ ๋ คํ์ญ์์ค.public class TimeMachine {
public void goToFuture(int currentYear) {
currentYear = currentYear+10;
}
public void goToPast(int currentYear) {
currentYear = currentYear-10;
}
public static void main(String[] args) {
TimeMachine timeMachine = new TimeMachine();
int currentYear = 2018;
System.out.println("What year is it?");
System.out.println(currentYear);
timeMachine.goToPast(currentYear);
System.out.println("How about now?");
System.out.println(currentYear);
}
}
ํ์๋จธ์ ์๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ๋ ๋ค ํ์ฌ ์ฐ๋๋ฅผ ๋ํ๋ด๋ ์ซ์๋ฅผ ์
๋ ฅ์ผ๋ก ์ฌ์ฉํ๊ณ ๊ทธ ๊ฐ์ ๋๋ฆฌ๊ฑฐ๋ ์ค์
๋๋ค(๊ณผ๊ฑฐ ๋๋ ๋ฏธ๋๋ก ๊ฐ๊ณ ์ถ์์ง ์ฌ๋ถ์ ๋ฐ๋ผ ๋ค๋ฆ). ๊ทธ๋ฌ๋ ์ฝ์ ์ถ๋ ฅ์์ โโ๋ณผ ์ ์๋ฏ์ด ์ด ๋ฐฉ๋ฒ์ ์๋ํ์ง ์์ต๋๋ค! ์ฝ์ ์ถ๋ ฅ:
What year is it?
2018
How about now?
2018
์ฐ๋ฆฌ๋ currentYear ๋ณ์๋ฅผ goToPast() ๋ฉ์๋ ์ ์ ๋ฌํ์ง๋ง ๊ทธ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์์์ต๋๋ค. ์ฐ๋ฆฌ๋ 2018๋
์ ์์๊ณ ์ฌ๊ธฐ์ ๋จธ๋ฌผ๋ ์ต๋๋ค. ํ์ง๋ง ์? :/ Java์ ํ๋ฆฌ๋ฏธํฐ๋ธ๋ ๊ฐ์ผ๋ก ๋ฉ์๋์ ์ ๋ฌ๋๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ทธ๊ฒ ๋ฌด์จ ๋ป์ด์ผ? goToPast() ๋ฉ์๋๋ฅผ ํธ์ถ ํ๊ณ ์ฌ๊ธฐ์ int ๋ณ์ currentYear(=2018)๋ฅผ ์ ๋ฌํ๋ฉด ์ด ๋ฉ์๋๋ currentYear ๋ณ์ ์์ฒด๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ์ด ์๋๋ผ ๋ณต์ฌ๋ณธ์ ๊ฐ์ ธ์ต๋๋ค. ๋ฌผ๋ก ์ด ๋ณต์ฌ๋ณธ์ ๊ฐ๋ 2018์ด์ง๋ง ๋ณต์ฌ๋ณธ์ ๋ํ ๋ณ๊ฒฝ ์ฌํญ์ ์๋ currentYear ๋ณ์์ ์ด๋ค ์์ผ๋ก๋ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค! ์ฝ๋๋ฅผ ๋ ๋ช
ํํ๊ฒ ๋ง๋ค๊ณ currentYear์์ ์ด๋ค ์ผ์ด ๋ฐ์ํ๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
public class TimeMachine {
public void goToFuture(int currentYear) {
currentYear = currentYear+10;
}
public void goToPast(int currentYear) {
System.out.println("The goToPast method has started running!");
System.out.println("currentYear inside the goToPast method (at the beginning) = " + currentYear);
currentYear = currentYear-10;
System.out.println("currentYear inside the goToPast method (at the end) = " + currentYear);
}
public static void main(String[] args) {
TimeMachine timeMachine = new TimeMachine();
int currentYear = 2018;
System.out.println("What was the year when the program started?");
System.out.println(currentYear);
timeMachine.goToPast(currentYear);
System.out.println("And what year is it now?");
System.out.println(currentYear);
}
}
์ฝ์ ์ถ๋ ฅ:
What was the year when the program started?
2018
The goToPast method has started running!
currentYear inside the goToPast method (at the beginning) = 2018
currentYear inside the goToPast method (at the end) = 2008
And what year is it now?
2018
์ด๋ goToPast() ๋ฉ์๋ ์ ์ ๋ฌ๋ ๋ณ์๊ฐ currentYear ์ ๋ณต์ฌ๋ณธ์ผ ๋ฟ์์ ๋ช
ํํ๊ฒ ๋ณด์ฌ์ค๋๋ค . ์ฌ๋ณธ์ ๋ณ๊ฒฝํด๋ "์๋ณธ" ๊ฐ์๋ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค. "์ฐธ์กฐ๋ก ์ ๋ฌ"์ ์ ๋ฐ๋๋ฅผ ์๋ฏธํฉ๋๋ค. ๊ณ ์์ด์๊ฒ ์ฐ์ตํ์! ๊ณ ์์ด ์์ ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐธ์กฐ๋ก ์ ๋ฌํ๋ ๊ฒ์ด ์ด๋ป๊ฒ ๋ณด์ด๋์ง ๋ด
์๋ค. :)
public class Cat {
int age;
public Cat(int age) {
this.age = age;
}
}
์ด์ ํ์๋จธ์ ์ ๋์์ผ๋ก ์ธ๊ณ ์ต์ด์ ์๊ฐ ์ฌํ ๊ณ ์์ด์ธ Smudge๋ฅผ ๊ณผ๊ฑฐ์ ๋ฏธ๋๋ก ๋ณด๋ด๋๋ฆฝ๋๋ค ! Cat ๊ฐ์ฒด ์ ํจ๊ป ์๋ํ๋๋ก TimeMachine ํด๋์ค๋ฅผ ์์ ํด ๋ณด๊ฒ ์ต๋๋ค .
public class TimeMachine {
public void goToFuture(Cat cat) {
cat.age += 10;
}
public void goToPast(Cat cat) {
cat.age -= 10;
}
}
์ด์ ๋ฉ์๋๋ ์ ๋ฌ๋ ์ซ์๋ง ๋ณ๊ฒฝํ์ง ์์ต๋๋ค. ์คํ๋ ค ํน์ Cat ์ ์ฐ๋ น ํ๋๋ฅผ ๋ณ๊ฒฝํฉ๋๋ค. ์๋ ์ซ์๊ฐ ๋ณ๊ฒฝ๋์ง ์์๊ธฐ ๋๋ฌธ์ ํ๋ฆฌ๋ฏธํฐ๋ธ์๋ ์ด๊ฒ์ด ์๋ํ์ง ์์๋ค๋ ๊ฒ์ ๊ธฐ์ตํ ๊ฒ์
๋๋ค. ๋ฌด์จ ์ผ์ด ์ผ์ด๋ ์ง ๋ณด์!
public static void main(String[] args) {
TimeMachine timeMachine = new TimeMachine();
Cat smudge = new Cat(5);
System.out.println("How old was Smudge when the program started?");
System.out.println(smudge.age);
timeMachine.goToFuture(smudge);
System.out.println("How about now?");
System.out.println(smudge.age);
System.out.println("Holy smokes! Smudge has aged 10 years! Back up quickly!");
timeMachine.goToPast(smudge);
System.out.println("Did it work? Have we returned the cat to its original age?");
System.out.println(smudge.age);
}
์ฝ์ ์ถ๋ ฅ:
How old was Smudge when the program started running?
5
How about now?
15
Holy smokes! Smudge has aged 10 years! Back up quickly!
Did it work? Have we returned the cat to its original age?
5
์ฐ์! ์ด์ ๊ทธ ๋ฐฉ๋ฒ์ ๋ญ๊ฐ ๋ฌ๋์ต๋๋ค. ์ฐ๋ฆฌ ๊ณ ์์ด๋ ๊ธ๊ฒฉํ ๋์์ง๋ง ๋ค์ ์ ์ด์ก์ต๋๋ค! :) ๊ทธ ์ด์ ๋ฅผ ์์๋ด
์๋ค. ํ๋ฆฌ๋ฏธํฐ๋ธ๊ฐ ์๋ ์์ ์ ๋ฌ๋ฆฌ ๊ฐ์ฒด๊ฐ ๋ฉ์๋์ ์ ๋ฌ๋ ๋ ์ฐธ์กฐ๋ก ์ ๋ฌ๋ฉ๋๋ค. ์๋ณธ ์ค๋จธ์ง ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๊ฐ changeAge() ๋ฉ์๋ ์ ์ ๋ฌ๋์์ต๋๋ค . ๋ฐ๋ผ์ ๋ฉ์๋ ๋ด์์ smudge.age๋ฅผ ๋ณ๊ฒฝํ๋ฉด ๊ฐ์ฒด๊ฐ ์ ์ฅ๋ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ฐธ์กฐํ๊ฒ ๋ฉ๋๋ค. ์ฒ์์ ๋ง๋ ๊ฒ๊ณผ ๋์ผํ Smudge์ ๋ํ ์ฐธ์กฐ์
๋๋ค. ์ด๊ฒ์ "์ฐธ์กฐ์ ์ํ ์ ๋ฌ"์ด๋ผ๊ณ ํฉ๋๋ค! ๊ทธ๋ฌ๋ ์ฐธ์กฐ๊ฐ ์๋ ๋ชจ๋ ๊ฒ์ด ๊ทธ๋ ๊ฒ ์ฌ์ด ๊ฒ์ ์๋๋๋ค. :) ์์ ๋ฅผ ๋ณ๊ฒฝํด ๋ด
์๋ค.
public class TimeMachine {
public void goToFuture(Cat cat) {
cat = new Cat(cat.age);
cat.age += 10;
}
public void goToPast(Cat cat) {
cat = new Cat(cat.age);
cat.age -= 10;
}
public static void main(String[] args) {
TimeMachine timeMachine = new TimeMachine();
Cat smudge = new Cat(5);
System.out.println("How old was Smudge when the program started?");
System.out.println(smudge.age);
timeMachine.goToFuture(smudge);
System.out.println ("Smudge went to the future! Has his age changed?");
System.out.println(smudge.age);
System.out.println ("And if you try going back?");
timeMachine.goToPast(smudge);
System.out.println(smudge.age);
}
}
์ฝ์ ์ถ๋ ฅ:
How old was Smudge when the program started running?
5
Smudge went to the future! Has his age changed?
5
And if you try going back?
5
๋ค์ ์๋ํ์ง ์์ต๋๋ค! ะ_ะ ๋ฌด์จ ์ผ์ด ์ผ์ด๋ฌ๋์ง ์์๋ด
์๋ค. :) goToPast / goToFuture ๋ฉ์๋ ๋ฐ ์ฐธ์กฐ๊ฐ ์๋ํ๋ ๋ฐฉ์๊ณผ ๊ด๋ จ ์ด ์์ต๋๋ค . ์, ์ฃผ๋ชฉํด์ฃผ์ธ์! ์ด๊ฒ์ ์ฐธ์กฐ์ ๋ฉ์๋๊ฐ ์๋ํ๋ ๋ฐฉ์์ ์ดํดํ๋ ๋ฐ ๊ฐ์ฅ ์ค์ํ ๊ฒ์
๋๋ค. ์ฌ์ค ์ฐ๋ฆฌ๊ฐ goToFuture (Cat cat) ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ์ ๋ฌ๋๋ ๊ฒ์ ์ฐธ์กฐ ์์ฒด๊ฐ ์๋๋ผ ๊ณ ์์ด ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ์ ๋ณต์ฌ๋ณธ์
๋๋ค. ๋ฐ๋ผ์ ๋ฉ์๋์ ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ ๋ ๊ฐ์ฒด์ ๋ํ ๋ ๊ฐ์ ์ฐธ์กฐ๊ฐ ์์ต๋๋ค. ์ด๊ฒ์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ์ดํดํ๋ ๋ฐ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ด๊ฒ์ด ๋ฐ๋ก ๋ง์ง๋ง ์์์ ๊ณ ์์ด์ ๋์ด๊ฐ ๋ณ๊ฒฝ๋์ง ์์ ์ด์ ์
๋๋ค. ์์ ์์์ ๋์ด๋ฅผ ๋ณ๊ฒฝํ ๋ ์ฐ๋ฆฌ๋ ๋จ์ํ goToFuture() ์ ์ ๋ฌ๋ ์ฐธ์กฐ๋ฅผ ์ทจํ์ต๋๋ค.๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ์์ ๊ฐ์ฒด๋ฅผ ์ฐพ๊ณ ๋์ด๋ฅผ ๋ณ๊ฒฝํ๋ ๋ฐ ์ฌ์ฉํ์ต๋๋ค( cat.age += 10 ). ๊ทธ๋ฌ๋ ์ด์ goToFuture() ๋ฉ์๋ ๋ด์์ ์ ๊ฐ์ฒด( cat = new Cat(cat.age) ) ๋ฅผ ๋ง๋ค๊ณ ์ด ๊ฐ์ฒด์๋ ๋ฉ์๋์ ์ ๋ฌ๋ ๊ฒ๊ณผ ๋์ผํ ์ฐธ์กฐ ๋ณต์ฌ๋ณธ์ด ํ ๋น๋ฉ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก:
- ์ฒซ ๋ฒ์งธ ์ฐธ์กฐ( Cat smudge = new Cat (5) )๋ ์๋ ๊ณ ์์ด(5์ธ)๋ฅผ ๊ฐ๋ฆฌํต๋๋ค.
- ๊ทธ๋ฐ ๋ค์ cat ๋ณ์์ goToPast() ๋ฉ์๋๋ฅผ ์ ๋ฌ ํ๊ณ ์ ๊ฐ์ฒด๋ฅผ ํ ๋นํ๋ฉด ์ฐธ์กฐ๊ฐ ๋ณต์ฌ๋์์ต๋๋ค.
cat.age += 10;
๊ทธ๋ฆฌ๊ณ ๋ฌผ๋ก main() ๋ฉ์๋์์ ์ฐ๋ฆฌ๋ ๊ณ ์์ด์ ๋์ด smudge.age ๊ฐ ๋ณ๊ฒฝ๋์ง ์์์์ ์ฝ์์์ ๋ณผ ์ ์์ต๋๋ค . ๊ฒฐ๊ตญ, ์ค๋จธ์ง๋ ์ฌ์ ํ 5๋
๋ ์ด์ ์ ์๋ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ ๋ณ์์ด๋ฉฐ ํด๋น ๊ฐ์ฒด์ ๋ํด ์๋ฌด ์์
๋ ์ํํ์ง ์์์ต๋๋ค. ๋ชจ๋ ์ฐ๋ น ๋ณ๊ฒฝ์ ์ ๊ฐ์ฒด์์ ์ํ๋์์ต๋๋ค.
GO TO FULL VERSION