์ค๋์ ์ ๋ฒ์๊ฐ์ ์ด์ด์ ์๋ฐ 4์ผ ์ฐจ ์์ ๋ด์ฉ ๋ณต์ต์ ํด๋ณด๊ฒ ์ต๋๋ค.
๊ทธ๋ผ ์์ํ๊ฒ ์ต๋๋ค.
ํจ์
ํจ์๋ output ํจ์๋ช
(input) ์ผ๋ก ๊ตฌ์ฑ์ด ๋์ด ์์ต๋๋ค. --> ํจ์์ ๊ธฐ๋ณธ ํํ
ํจ์๋ช
์ ๊ธฐ๋ฅ์ ๋ฐ๋ก ์์์๊ฒ ์ง์ด์ผ ํจ
ex) void main(String[] args)
=> output์ด ์๋ main ํจ์๋ค.
์ด main()์ args๋ฅผ ์ธ์๋ก ๊ฐ๋๋ค
input --> ex) ์
๋ ฅ ์ธ์ ์ธ์ arguments ๋งค๊ฐ๋ณ์ ํ๋ผ๋ฏธํฐ parameter
output --> ex) ๊ฒฐ๊ณผ ๊ฐ ๋ฐํ return ๋ฆฌํด ์ถ๋ ฅ๊ฐ
ํจ์์ 4๊ฐ์ง ์ ํ
- ์ฒซ๋ฒ์งธ ์ ํ : input x ouput x
- ๋๋ฒ์งธ ์ ํ : input o ouput x
- ์ธ๋ฒ์งธ ์ ํ : input x ouput o
- ๋ค๋ฒ์งธ ์ ํ : input o ouput o
(์ด ์ ํ๋ค์ ๊ทธ๋ฅ ์ดํด๋ฅผ ๋๊ธฐ ์ํ์ฌ ์ ํ์ ๋๋ ๊ฒ์ด๋ฉฐ ๊ณต์์ ์ผ๋ก ์๋ฐ์์ ๋๋ ๊ฒ์ ์๋๋๋ค.)
์ฒซ ๋ฒ์งธ ์ ํ
input x output x
// input x / ouput x
// void == output์ด ์๋ค๋ ๋ป
// static == ๊ฐ์ฒด์ ๋ฌด๊ดํ๊ฒ ๋ผ๋ ๋ป
public static void hello() {
System.out.println("์๋
ํ์ธ์! :D");
}
์ฝ๋๋ฅผ ๋ณด๋ฉด ์ ์ ์๋ค์ํผ input๊ณผ output์ด ๋ ๋ค ์๋ ํํ์ ํจ์์ ๋๋ค.
์ด์ ๋ฉ์ธ์์ ํจ์๋ฅผ ํธ์ถํด์ฃผ๋ฉด?
public static void main(String[] args) {
// ํจ์๋ฅผ ์ ์ธํ๋ ํ์์
// ํจ์๋ฅผ ์ฌ์ฉํ๋ ํ์๋ ์๋ก ๋ค๋ฆ
// ํจ์๋ฅผ ์ ์ธํ๋ ํ์ : ํจ์๋ฅผ ์ ์
// ํจ์๋ฅผ ์ฌ์ฉํ๋ ํ์ : ํจ์ ํธ์ถ
hello();
hello();
hello();
hello();
hello();
}
ํจ์์ ์ ์ ํด๋๋ ์๋ ํ์ธ์!๋ผ๋ ์ฝ๋๊ฐ ์ถ๋ ฅ๋๊ฒ ๋ฉ๋๋ค.
๋ ๋ฒ์งธ ์ ํ
input O output X
public class FunctionType2Task {
// ์ ์๋ฅผ 1๊ฐ ์ธ๋ถ์์ ๋ฐ์์ค๋ฉด
// x100์ ํด์ ํ๋ฉด์ ์ถ๋ ฅํด์ฃผ๋ ํจ์
public static void test(int num) {
num *= 100; // num = num * 100;
System.out.println(num);
}
input์ผ๋ก int num์ด ๋ค์ด์ค๊ฒ ๋์์ต๋๋ค.
int num์ ์ด๋ ํ ๊ฐ์ ์ ๋ ฅ๋ฐ๊ฒ ๋๋ฉด ์๋์ ์๋ ์ฝ๋๋ฅผ ํตํด ๊ณ์ฐ๋ ๊ฐ์ ์ถ๋ ฅํ๊ฒ ๋ฉ๋๋ค.
public static void main(String[] args) {
int num = 2;
test(num); // ํจ์๋ฅผ ํธ์ถํ ๋ ์ธ์๋ฅผ ์ ๋ฌํ๋ ๋ฐฉ์
// ํด๋น ๋ณ์์ "๊ฐ" ๋ง์ ์ ๋ฌ
// == call by value (๊ฐ์ ์ํ ํธ์ถ)
System.out.println("num= "+num);
}
}
num ๊ฐ์ 2๋ฅผ ๋ฃ์ด์ฃผ๋ฉด input์ 2๊ฐ ๋ค์ด๊ฐ๊ฒ ๋์ด ๊ณ์ฐ๋ ํ (2 * 100) test ํจ์์๋ 200์ด๋ผ๋ ๊ฐ์ด ๊ณ์ฐ๋์ด ์ถ๋ ฅ๋ ๋ชจ์ต์ ํ์ธํ์ค ์ ์์ต๋๋ค.
์ธ ๋ฒ์งธ ์ ํ
output O intput X
public class FunctionType3Task {
public static int test() {
// ์๋ฃํ๋ง ์์ฑํ๋ฉด ๋จ
int a = 3, b = 5;
int sum = a + b;
return sum; // ์ด๋ค ๊ฐ์ ๋ฐํํ๋์ง return ๋ค์ ์์ฑํด์ฃผ๋ฉด ๋จ
// ํจ์๊ฐ return์ ๋ง๋๋ฉด "์ฆ์" ํจ์๋ฅผ ์ข
๋ฃํจ
}
output์ด ์์ผ๋ฉด return ๊ฐ์ด ์๊ธฐ๊ฒ ๋ฉ๋๋ค.
public static void main(String[] args) {
System.out.println("์ดํฉ์ "+test()+"์
๋๋ค.");
int result = test();
System.out.println("์ดํฉ์ "+result+"์
๋๋ค.");
๊ทธ๋์ ์ถ๋ ฅ์ ํ์ ๊ฒฝ์ฐ์ input์ ์์ง๋ง return ๊ฐ์ ์ ์ด๋์ sum์ ์ํด a + b๊ฐ ๊ณ์ฐ๋์ด 8์ด๋ผ๋ ๊ฐ์ด test() ํจ์์ ์ ์ฅ๋ฉ๋๋ค.
๊ทธ๋์ ์ถ๋ ฅํ๋ฉด 8์ด ๋์ค๋ ๋ชจ์ต์ ํ์ธํ์ค ์ ์์ต๋๋ค.
๋ค ๋ฒ์งธ ์ ํ
input O output O
package class02;
// ํจ์ ์ ํ 4
// input 0 output o
public class FunctionType4Task {
// ์ธ๋ถ์์ ์ ์๋ฅผ 2๊ฐ ๋ฐ์์์
// ์ ์ 2๊ฐ์ ํฉ์ ๋ฐํํ๋ ํฉ์
// "๋ฐํ" = output์ด ์๋๊ฒ
public static int plus(int a,int b ) {
System.out.println("plusํจ์ ํธ์ถ๋จ");
// ๋ก๊ทธ์ญํ
return a + b;
// ์ธ๋ถ์์ ์ ์๋ฅผ 1๊ฐ ๋ฐ์์์
// ํด๋น ์ ์๊ฐ ์ง์์ธ์ง ํ์์ธ์ง ๋ฐํํ๋ ํจ์
// yes or no == boolean
}
public static boolean isEven(int num) { // ํจ์๋ช
์ด isXXX() hasXXX() --> boolean์ด๋ค.
if(num % 2 == 0) {
return true;
}
return false;
// return num % 2 == 0 ? true : false;
}
public static void main(String[] args) {
if(isEven(20)) {
System.out.println("์ง์");
}
else {
System.out.println("ํ์");
}
int result = plus(10,20);
System.out.println(result);
}
}
์ฒซ ๋ฒ์งธ ์ถ๋ ฅ๋๋ ๋ฌธ์ฅ์ ์ง์ ํ์ ํ๋ณ ๋ฌธ์ ์ ๋๋ค.
20์ ๋ฃ์ผ๋ ์ง์๋ผ๊ณ ์ถ๋ ฅ์ด ๋๋ ๋ชจ์ต์ ๋ณด์ค ์ ์์ต๋๋ค.
๋ ๋ฒ์งธ ์ถ๋ ฅ๋๋ ๋ฌธ์ฅ์ a์ b๋ฅผ ๋ํ๋ ํจ์์ธ๋ฐ input์ 10๊ณผ 20์ ๋ฃ์ผ๋ 30์ด ์ถ๋ ฅ์ด ๋ ๋ชจ์ต์ ํ์ธํ์ค ์ ์์ต๋๋ค.
ํจ์ ์ฐ์ต๋ฌธ์
์ด์ ํจ์์ ์ฌ๋ฌ ๊ฐ์ง ์ ํ๋ค์ ๋ํด ๋ฐฐ์๋ณด์์ผ๋ ํจ์๋ฅผ ํ์ฉํ ์ฐ์ต๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ฒ ์ต๋๋ค.
์ฐ์ต๋ฌธ์ 1๋ฒ )
test01์ด๋ผ๋ ํจ์๊ฐ ์์ต๋๋ค.
์ด ํจ์๋ ์ ์๋ฅผ 2๊ฐ ์ธ๋ถ์์ ์
๋ ฅ๋ฐ์์,
์ ์ 2๊ฐ์ ํ๊ท ๊ฐ์ ์ค์๋ก ๋ฐํํ๋ ํจ์์
๋๋ค.
test01์ ์์ฑํด์ฃผ์ธ์.
public class FunctionPracticeTest1 {
// ์
๋ ฅ์ ๋ฐ์ ๋ฐํ๊น์ง ํ๋ค๋ฉด input๊ณผ output์ด ๋๋ค ์๋ ํจ์์
๋๋ค.
// public static output ํจ์์ด๋ฆ(input) {
//
// }
public static double test01(int a,int b) {
double avg = (a + b) / 2.0;
return avg;
}
// ์ ์ 2๊ฐ์ ํ๊ท ๊ฐ์ ์ค์๋ก ๋ฐํํ๋ ํจ์
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("์ด ํจ์๋ ์ ์ 2๊ฐ์ ํ๊ท ๊ฐ์ ์ค์๋ก ๋ฐํํด์ฃผ๋ ํจ์ ์
๋๋ค.");
System.out.print("์ฒซ๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์์ค >> ");
int a = sc.nextInt();
System.out.print("๋๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์์ค >> ");
int b = sc.nextInt();
System.out.print("์ค์๋ก ๋ฐํ๋ ํ๊ท ๊ฐ์ "+test01(a,b)+"์
๋๋ค.");
}
}
์ด๋ฐ์์ผ๋ก ์ถ๋ ฅ๊ฒฐ๊ณผ๊ฐ ์ ๋์ค๋ ๊ฑธ ํ์ธํ์ค ์ ์์ต๋๋ค.
์ฐ์ต๋ฌธ์ 2)
test02๋ผ๋ ํจ์๊ฐ ์์ต๋๋ค.
ํจ์๋ฅผ ์คํํ๊ฒ๋๋ฉด, ์ฌ์ฉ์๋ก๋ถํฐ ์ ์๋ฅผ 5๋ฒ ์
๋ ฅ๋ฐ์์ ์๊ฒ๋ฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์
๋ ฅํ ์ ์๋ค์ ์ดํฉ์ ํ๋ฉด์ ์ถ๋ ฅํด์ค๋๋ค.
main์์ test02 ํจ์๋ฅผ ์ถ๋ ฅ์์ผ ํ๋ฉด์ ์ฌ๋ฐ๋ฅธ ๊ฐ์ด ๋์ค๋์ง ํ์ธํฉ๋๋ค.
public class FunctionPracticeTest2 {
public static void test02() {
Scanner sc = new Scanner(System.in);
int sum = 0;
for(int i=0; i < 5; i++) {
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ญ์์ >> ");
int num = sc.nextInt();
sum += num;
}
System.out.print("์ ์๋ค์ ์ดํฉ์ "+sum+"์
๋๋ค.");
}
public static void main(String[] args) {
test02();
}
}
5๊ฐ์ง ์ ์๋ค์ ์ดํฉ์ ๊ตฌํ๋ ํจ์์ฌ์ ๋ค ๋ํ 150์ด ์ ๋์ค๋ ๊ฑธ ํ์ธํ์ค ์ ์์ต๋๋ค.
ForEach๋ฌธ
forEach๋ฌธ์ ํฅ์๋ for๋ฌธ์ผ๋ก ๋ฐฐ์ด๊ณผ ํจ๊ป ์ฌ์ฉ๋๋ for๋ฌธ ์ ๋๋ค.
๊ธฐ๋ณธ์ ์ธ foreach๋ฌธ์ ํํ๋ ์๋์ ๊ฐ์ต๋๋ค.
for(๋ฐฐ์ด์ ์ ์ฅ๋ ์๋ฃํ ๋ณ์๋ช
: ๋ฐฐ์ด๋ช
) {
๋ฐ๋ณตํ ์ฝ๋
}
์ฝ๋๋ฅผ ๋ณด๋ฉฐ ์ ๋๋ก ์ดํดํด๋ด ์๋ค.
package class06;
public class ForEachTask {
public static void test(int[] datas) {
}
public static void main(String[] args) {
// new ์ฐ์ฐ์ : ๊ฐ๋ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ (heap)์ ๋ง๋ค์ด ์ค
int [] datas = new int[3];
for(int i=0; i < 3; i++) {
datas[i] = (i+1)*10;
}
System.out.println("[");
// forEach๋ฌธ, ํฅ์๋ for๋ฌธ , ๋ฐฐ์ด๊ณผ ํจ๊ป ์ฌ์ฉ๋๋ for๋ฌธ
for(int data:datas) {
// for(๋ฐฐ์ด์ ์ ์ฅ๋ ์๋ฃํ ๋ณ์๋ช
:๋ฐฐ์ด๋ช
)
// ๋ฐฐ์ด์ ํฌ๊ธฐ๋งํผ ์ํํจ
// index [0]๋ถํฐ ๋ณ์๊ฐ ํด๋น ์ธ๋ฑ์ค์ ๋ฐ์ดํฐ๋ฅผ ๋์ ํจ
System.out.println(data+"");
}
System.out.println("]");
test(datas);
// new๋ก ์ ์ํ ๋ณ์๋ฅผ ์ ๋ฌํ๋ ํจ์
// call by reference(์ฐธ์กฐ์ ์ํ ํธ์ถ)
System.out.println("[");
for(int data:datas) {
System.out.print(data+"");
}
System.out.println("]");
}
}
์ฝ๋๋ฅผ ํด์ํด๋ณด๋ฉด datas์ for๋ฌธ์ผ๋ก ์ธํ์ฌ 10 , 20 ,30์ด๋ผ๋ ๊ฐ์ด ์ ์ฅ๋์์ต๋๋ค.
๊ทธ๋ค์ ํฅ์๋ for๋ฌธ์ธ foreach๋ฌธ์ ์ฌ์ฉํ์ฌ datas์ ๊ฐ ์์๋ค์ ์์๋๋ก ๊ฐ์ ธ์ ์ถ๋ ฅํ๊ฒ ๋จ์ผ๋ก
datas [0] = 10 , datas [1] = 20 , datas[2] = 30์ผ๋ก 10 ,20, 30์ด ์ถ๋ ฅ๋๋ ๊ฒ์ ๋๋ค.
๊ทธ๋ค์ ์๋์ ์ฝ๋๋ ์ ์ฝ๋์ ๋น์ทํ์ง๋ง ln (new line)์ด ์์ด์ ์ค ๋ฐ๊ฟ์ด ๋์ง ์์
์์๋๋ก 10 , 20 ,30์ด ์ค ๋ฐ๊ฟ ๋์ง ์๊ณ ์ถ๋ ฅ๋๋ ๋ชจ์ต์ ํ์ธํ์ค ์ ์์ต๋๋ค.
๋ง๋ฌด๋ฆฌ
์ด๋ ๊ฒ ์ค๋ ์๋ฐ์์ ์ ๋ค์์ง 4์ผ ์ฐจ๊ฐ ๋์ต๋๋ค.
์ ์ ๋ชจ๋ฅด๋๊ฒ๋ค์ ๋ฐฐ์ฐ๊ฒ ๋๊ณ ์ดํด ์ ๋๋ ๊ฒ๋ค๋ ์๊ฒจ๋๋ ๊ฑฐ ๊ฐ์ต๋๋ค.
์ดํด๊ฐ ์๋๋๊ฒ์ ๊ผญ ์ดํดํ๊ณ ๋์ด๊ฐ๋ ๊ฒ ์ค์ํ ๊ฑฐ ๊ฐ์ต๋๋ค.
๋ด์ฃผ์ ์ ๊ฐ์ฌํ๊ณ ์ ๋ ๋ค์์ ๋ค์ ์ฐพ์์ค๊ฒ ์ต๋๋ค.
'ํ์คํ ๊ฐ๋ฐ์ ์์ฑ๊ณผ์ ๐ชซ > ใ Java ใ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ํด๋์ค ์์ (1) | 2024.07.10 |
---|---|
[Java] ๊ฐ์ฒด(Object)์ Class (1) | 2024.07.03 |
[Java] ์ด์ค for๋ฌธ๊ณผ ๋ฐฐ์ด (0) | 2024.07.02 |
[Java] ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ (0) | 2024.07.01 |
[Java] ์๋ฐ ๊ธฐ๋ณธ๋ถ๋ฒ ,๋ณ์ , ํจ์ , ํ๋ฆ ์ ์ด๋ฌธ (0) | 2024.06.26 |