디바이스 융합 자바(Java) day06 - 함수,오버로딩

1. 전체 복습(lv1)
5일간의 기초       <<
- 변수 3요소
   : 공간, 자료형, 식별자(주소)
   : 값이 없어도 실행은 되지만.. -> 초기화 이슈
- 타입 캐스팅(명시적 형변환, 자동 형변환)
- String 이라는 클래스로부터 str 생성 가능
   : String str = new String("apple");
   : String str = "kiwi";
- Scanner sc = new Scanner(System.in); -> 버퍼
- 연산자 -> 우선순위 파악!
- 제어문 : 조건문 / 반복문(반복되는 횟수 알면 for, 모르면 while)
    -> while(true) + 종료조건 필요 / for 중첩 반복문(디버깅표 아주 중요!)
- 자료구조 : 배열
- 알고리즘 : 교환, 정렬 -> 탐색을 용이하게 하기 위해, 최대값 찾기, flag

2. 함수(메서드)(lv2)
[함수]
int num = 4; 
double num2 = 3.14;

for(int i = 0; i < 3; i++){
       
}
--> for
- 함수끼리는 서로 공간을 공유하지 않는다.

-----------------------------------------------
package class01;

public class Test01 {

       // static : "객체와 무관하게"
       static void func() { // func 이름의 함수를 선언, 정의
             // 선언만 해주고 호출을 안해줌
             System.out.println("내가 만든 첫번째 함수!!!");
       }
       // 코드의 재사용성이 증가됨
       //  : 오류의 파급효과가 줄어듦
       //  : 유지 보수 용이

       public static void main(String[] args) { // 
             // 변수 3요소
             // 공간, 자료형, 식별자(주소)
             // 값xxx -> 초기화 이슈
             // 타입 캐스팅
             // String
             // Scanner sc = new Scanner(System.in); -> 버퍼
             // 연산자 -> 우선순위
             // 제어문 : 조건문 / 반복문 -> while(T) + 종료조건 / 중첩 반복문(디버깅표)
             // 자료구조 : 배열
             // 알고리즘 : 정렬 이슈! -> 탐색, 최대값 찾기, flag
             // 5일 정도 기초!

             // [함수]
             int num = 4; 
             double num2 = 3.14;
             func(); // 호출(사용) 위의 func() 호출!
             System.out.println("메인 함수 공간");

       }
}

- static : "객체와 무관하게"
- func(), main() 함수 존재
- void : y
- func() : f(x)

- 콘솔은 main함수를 실행시켰을 때 나오는 결과를 출력
   >> Test01의 공간이 아닌!!

- func();를 main함수 안에 호출!

- func()이란 함수를
  만듦으로서 코드의 재사용성이 증가됨
   : 오류의 파급효과가 줄어듦
   : 유지보수에 용이
---------------------------------------------
- 함수에 input과 output이 존재하지 않을 경우
package class01;

public class Test02 {
       // input x output x
       static void func1() {
             // 외부와 상관없이 호출하고싶은 것이 있을 때 사용
             // 특정 알림 멘트 출력하고 싶을 때
             System.out.println("주의! 경고!!");
       } // 코드 재사용성을 증가시키기 위해 쓴다!!

       public static void main(String[] args) {
             if(num < 0) {
                   func1();
              }

++++++++++++++++++++
              if(사용자가 제대로 입력했어도, 시스템 점검 상태면) {
                    func1();
              }
       }
}

- 함수를 쓰는 이유
   : 코드 재사용성을 증가시키기위해 쓴다!!

--------------------------------------------
- 함수에 input은 들어가고 output은 들어가지 않을 경우
package class01;

public class Test02 {

       // input x output x
       static void func1() {
             // 외부와 상관없이 호출하고싶은 것이 있을 때 사용
             // 특정 알림 멘트 출력하고 싶을 때
             System.out.println("주의! 경고!!");
       } // 코드 재사용성을 증가시키기 위해 쓴다!!

       // input o output x
       static void func2(int num) {
             System.out.println("func2()에서 받은 num : " + num);
       }

       public static void main(String[] args) {
             int a = 100;
             int b = 200;
             func2(a); // a의 "값"을 보내줌
             func2(b);
       }
}
- 순서
1. a = 100
    b = 200 변수 생성

2. func2 함수에 num이라는 4바이트 변수 생성

3. 
   func(a)
   :  num에 100이라는 숫자 대입
     + 끝나게 되면 func(100)
   func(b)
   : num에 200이라는 숫자 대입
     + 끝나게 되면 func(200)
---------------
package class01;

public class Test02 {

       // input x output x
       static void func1() {
             // 외부와 상관없이 호출하고싶은 것이 있을 때 사용
             // 특정 알림 멘트 출력하고 싶을 때
             System.out.println("주의! 경고!!");
       } // 코드 재사용성을 증가시키기 위해 쓴다!!

       // input o output x
       static void func2(int num) {
             System.out.println("func2()에서 받은 num : " + num);
             num += 10;
             System.out.println(num);
       }

       public static void main(String[] args) {
             int a = 100;
             int b = 200;
             func2(a); // a의 "값"을 보내줌
             System.out.println("a = " + a);

             // func2(b);
       }
}
--> 출력하게 되면?
func2(a)에서 받은 num : 100
110
a = 100

// func2()에서의 num은 증가하지만
   main 함수에서의 a는 증가하지 않는다.

문제
package class01;

public class Test02 {

       // input x output x
       static void func1() {
             // 외부와 상관없이 호출하고싶은 것이 있을 때 사용
             // 특정 알림 멘트 출력하고 싶을 때
             System.out.println("주의! 경고!!");
       } // 코드 재사용성을 증가시키기 위해 쓴다!!

       // input o output x
       static void func2(int kim) {
             System.out.println("a : " + ++kim);
       }

       public static void main(String[] args) {
             int kim = 100;
             func2(kim);
             kim++;
             func2(kim);
             System.out.println("main() : " + kim);
       }
}
------
예상 답안
a =101
a : 102
main() : 101

실제 답
a =101
a : 102
main() : 101

-------------------------------
package class01;

public class Test02 {

       // input x output x
       static void func1() {
             // 외부와 상관없이 호출하고싶은 것이 있을 때 사용
             // 특정 알림 멘트 출력하고 싶을 때
             System.out.println("주의! 경고!!");
       } // 코드 재사용성을 증가시키기 위해 쓴다!!

       // input o output x
       static void func2(int lee) { // 변수 3요소
             // kim에서 lee로 바뀌어도 main에서 출력하는건 문제가 없음
             System.out.println("a : " + ++lee);
       }

       public static void main(String[] args) {
             int kim = 100;
             func2(kim); // 값
             kim++;
             func2(kim);
             System.out.println("main() : " + kim);
       }
}
----------------강사님의 문제! 어떻게 나올 것인가?
package class01;

public class Test03 {
       static void func1() {
             int num=10;
             num++;
             System.out.println("func1(): "+num);
       }
   
       static void func2(int a) {
             a++;
             func1();
             System.out.println("func2(): "+a);
       }

       public static void main(String[] args) {
             int num=1;
             int a=100;
      
             func1();
             func2(num);
       }
}

내 답!
func1() : (num)11
func1() : 11
func2() : (a)2
 정답!!!
그림판

--------------------------

- 함수명 중복정의 허용
   : 식별자에서 변수는 같은 공간에서 동일한 이름을 선언할 수 없다
    ex ) int a
          int a(불가능)(빨간줄)
   : 함수명은 중복선언을 허용해준다
  조건
   : 인자의 개수가 다르거나, 
     인자의 자료형이 달라야만 한다!!

  이 것을 ★★★오버로딩★★★ 이라고 한다!!!!
  System.out.println() 함수는 오버로딩(함수명 중복정의 허용)으로
  선언되어있었다! 우리는 지금까지 호출해서 쓴 것!

package class01;

public class Test04 {

       // "함수명 중복정의 허용"
       // : 인자의 개수가 다르거나,
       //   인자의 자료형이 달라야만 한다!
       // ★★★오버로딩
       static void add(int a, int b) {
             System.out.println(a+b);
       }
       static void add(int a, int b, int c) {
             System.out.println(a+b+c);
       }
       static void add(int a, int b, int c, int d) {
             System.out.println(a+b+c+d);
       }
       static void add(int a, int b, int c, int d, int e) {
             System.out.println(a+b+c+d+e);
       }

       static void f(int a) {
             System.out.println("a");
       }
       static void f(double a) {
             System.out.println("b");
       }
       static void f(String a) {
             System.out.println("c");
       }

       public static void main(String[] args) {

             // 식별자에서 변수는 같은 공간에 동일한 이름을 선언할 수 없다
             // 함수명은 중복선언을 허용해준다
             // System.out.println() 함수는 오버로딩(함수명 중복정의 허용)으로
             // 선언되어있었다!. 우리는 지금까지 호출해서 쓴 것!
             System.out.println(10);
             System.out.println("apple");
             System.out.println(3.14);
             f(3.14);
             f("a");
       }
}

.....낚이지 말 것 ㅋㅋㅋㅋㅋㅋㅋㅋ
대어를 낚으셨자너 ㅋㅋㅋㅋㅋ
...창피하자너 ㅠㅠ
f(3.14); >> b
f("a"); >> c

--------------------------------
- output은 있고 input은 없는 함수

package class03;

public class Test05 {

       // output o input x
       static int func3(){
             return 123; // 자기 자신을 호출한 위치로 값을 반환 + 함수를 종료
       }
       static int f1() {
             int num=123;
             return num;
       }
       static int f2() {
             int num=10;
             return num; // 함수를 즉시 종료
             // System.out.println("f2() 동작완료"); 
             // return으로 syso은 실행되지 못하고 함수 종료
       }

       public static void main(String[] args) {

             int num=1;
             num=f1();
             System.out.println("num= "+num);
             System.out.println(f2());


             /*
             int num = func3();
             // 1. func3()의 값을 알아야 한다!
             // 2. 대입 연산자를 수행
             System.out.println("num = " + num);
             System.out.println(func3());
              */
       }
}

 

--------------------------
void = 반환이 없음
int = 반환이 존재

- output도 있고 input도 있는 함수
package class03;

public class Test06 {

       // output o input o
       static int func4(int a, int b) {
             int res = ++a + b;
             return a+b;
       }
       static int func4(int a, int b, int c) {
             return a+b+c;
       }

       public static void main(String[] args) {
             int a = 10;
             int b = 20;
             System.out.println("a = " + a);
             System.out.println("b = " + b);
             System.out.println(func4(a, b));
       }
}
// 선언 -> 호출
// input, output : return -> "값"
// 오버로딩
그림판

---------------------

[함수 심화] : 재귀 함수
>> 재귀함수(순환함수)
   ex ) 팩토리얼(4! = 4x3! = 24)
        f(n) = n*f(n-1)
        N! = Nx(N-1)! 
   나를 내놓기 위해서 또 다른 나를 쓰는 함수
   >> 재귀함수

Exception!
StackOverflowError( 공간 부족! )

위 사항의 그림판

- 종료조건이 필요하다!!
- 1! = 1xf(0)이 아니라 1이다.
 그렇기에 "만약 n이 1이면 1값을 가져와라!"

package class04;

// [함수 심화] : 재귀(당장은 몰라도 큰 문제가 있지는 않다)
// 재귀함수(순환함수) ex) 팩토리얼
public class Test07 {
       // 5! = 5 * 4!
       // 4! = 4 * 3!
       //    ...
       // 1! = 1
       static int fac(int n) { // 팩토리얼 함수(재귀함수 사용)
             System.out.println(n); // n 출력
             if(n==1) { // 종료조건
                   return 1;
             }
             return n*fac(n-1); // 끝내기 위해서는 종료조건 필요!
       }

       public static void main(String[] args) {
             System.out.println(fac(5)); // 5! 출력하기
       }
}

그림판

 

17일에 시험도 있음
[과제 - 17일까지]
퀵 정렬

[5 1 9 10 4 2 7 3 6 8]
↑↑                     ↑
 p L                      H

pivot(피벳, 피봇, 기준)

p에 대하여 L, H가 올바른지 확인
5보다 작은 애들만 LOW
5보다 큰 애들만 HIGH

[5 1 9 10 4 2 7 3 6 8]
↑   ↑            ↑
 p    L             H

L먼저 체크 : p보다 큰 수를 만나면 스톱!
H      체크 : p보다 작은 수를 만나면 정지!
L <-> H 교환 : 교환알고리즘 사용
  >>많이 틀리는 것
  >> 교환의 대상은 배열임에 유의!
[5 1 3 10 4 2 7 9 6 8]
↑   ↑            ↑
 p    L             H

[5 1 3 10 4 2 7 9 6 8]
↑       ↑   ↑
 p        L    H

[5 1 3 2 4 10 7 9 6 8]
↑         ↑↑
 p          H L
         (교차발생)
루프 시행중에 교차(CROSS)발생하면
       >> STOP 멈춰라!

[4 1 3 2 5 10 7 9 6 8]
↑         ↑↑
 p          H L
pivot과 H를 교환 
     >> 1회전 정렬

q(배열, 0, 9){
       q(배열, 0, H-1);
       q(배열, L, 9);
}

ex ) 
package class04;

public class Test08 {
       static void func1(int i) {
             i += 10;
       }
       static void func2(int[] arr) {
             arr[0] = -100;
             arr[arr.length-1] = -123;
       }


       public static void main(String[] args) {
             int num = 10;
             int[] data = {1,2,3,4,5};

             func1(num);
             System.out.println("num = " + num);
             func2(data);
             for(int i = 0; i<data.length; i++) {
                   System.out.print(data[i] + " ");
             }
       }
}

-----------------------
package class04;

import java.util.Random;

public class Test09 {
// 배열을 넣으면, 짝수를 모두 -- 시키는 로직
       static void func(int[] arr) {
             for(int i = 0; i < arr.length; i++) {
                   if(arr[i]%2==0) {
                         arr[i]--;
                   }
              }
       }

       public static void main(String[] args) {
             int[] data = new int[5];

             Random rand = new Random();
             for(int i = 0; i < data.length; i++) {
                   data[i] = rand.nextInt(10)+1;
             }
             for(int i = 0; i < data.length; i++) {
                   System.out.print(data[i] + " ");
             }
             System.out.println();

             func(data);

             for(int i = 0; i < data.length; i++) {
                   System.out.print(data[i] + " ");
             }
       }
}

-정리
1. 함수
쓰더라도 호출을 해야만 출력 완료
★★★ 오버로딩 ★★★
System.out.println(int)
System.out.println(double)
System.out.println(String)

재귀