메서드(Method), 메서드 오버로딩

메서드(method)

return문

return문 - 주의사항

 

 

[출처]자바의 정석

 

 

실습을 해보자.

	// 메서드 작성 위치
	public static int sum(int num1, int num2) { 
		return num1 + num2;
		// 두 정수를 입력 받아 두 정수의 합을 알려주는(리턴하는) 메서드
		// 리턴타입 : int (합계)
		// 메서드명 : sum
		// 매개변수 : int num1, int num2 (두 정수)
		
		// 매개변수 = (자료형 변수명, 자료형 변수명)
	}
	public static int sub(int num1, int num2) {
		if (num1 < num2) { // num2가 num1보다 크면 num2에서 num1을 빼주는 조건
			return num2 - num1;
		}
		return num1 - num2;
	}
	// 두 정수가 주어지면 두 정수의 합을 출력하는 메서드
	// 리턴타입 : 없음
	// 매개변수 : 두 정수(int num1, int num2)
	// 메서드명 : sum1
	public static void sum1(int num1, int num2) {
		System.out.println(num1 + num2); // 메서드 안에 출력문 포함
	}

	public static void main(String[] args) {
		/* method(메서드) : 기능(함수), function
		 * 메서드 선언 및 구현
		 * 접근제한자 리턴타입 메서드명(매개변수) {
		 * 기능 구현; }
		 * 
		 * - 접근제한자 : 접근할수 있는 주체의 제한범위
		 * - 리턴타입 : 반환값 (메서드 실행 후 결과로 알려주는 값의 자료형)
		 * - 메서드명 : 소문자로 작석
		 * - 매개변수 : 기능을 수행하기 위해 필요한 값
		 * - void : 리턴할 것이 없는 경우
		 * 
		 * - 메서드의 위치
		 *  - 클래스 안, 다른 메서드 밖
		 *  - 메서드의 순서는 아무 상관 없음
		 *  - 메서드는 순서대로 실행되지 않음, 호출이 되어야 실행
		 */
		int a = sum(10, 20);
		System.out.println(sum(10, 20)); // 30
		System.out.println(a); // 30
		
		int b = sub(30, 10);
		System.out.println(b); // 20
		
		sum1(20,30); // 50
		// System.out.println(sum1); //error

	}
	// 메서드 작성 위치

 

	public static void sum(int num1, int num2) { // +
		System.out.println(num1 + num2);
	}
	public static void sub(int num1, int num2) { // -
		System.out.println(num1 - Math.abs(num2));
	}
	public static int mul(int num1, int num2) { // *
		return num1 * num2;
	}
	public static double div(double num1, double num2) { // /
		return (double)num1 / num2;
	}
	public static int rem(int num1, int num2) { // %
		int rem = num1 % num2;
		return rem;
	}
	
	
	public static void main(String[] args) {
		// + - * / % 의 결과를 알려주는 메서드를 생성
		// main에서 호출하여 확인
		
		sum(20, 30);
		sub(30, 20);
		System.out.println(mul(10,10));
		double d = div(20, 3);
		System.out.printf("%.2f%n", d);
		System.out.println(rem(20, 3));
	}

	public static void printMulti(int num1) {
		for (int i = 1; i <= 9; i++) {
			System.out.println(num1 + " x " + i + " = " + (num1 * i));
		}
	}

	public static void main(String[] args) {
		/* 정수 (2~9까지중 하나) 해당 단의 구구단이 출력메서드
		 * 매개변수 : 메서드를 실행하기 위해서 외부에서 받아오는 값
		 * 리턴타입 : 메서드를 처리 후 메인에게 다시 돌려주는 값
		 * 메서드명 : printMulti
		 */
		printMulti(5);
		
	}

	public static boolean isPrime(int num) {
		int cnt = 0; // 약수의 개수가 2개인 소수
		for (int i = 1; i <= num; i++) {
			if (num % i == 0) {
				cnt++;
			}
		}
		if (cnt == 2) {
			return true;
		}
		return false;
		
	}

	public static void main(String[] args) {
		/* 정수가 주어지면 이 정수가 소수인지 아닌지 판별(true, false)
		 * 소수 : 1과 자신의 수 외에는 나누어 떨어지지 않는 수
		 * 리턴타입 : boolean
		 * 매개변수 : int num
		 * 메서드명 : isPrime
		 */
		for (int i = 1; i <= 10; i++) {
			if (isPrime(i)) {
				System.out.println(i + "는 소수입니다.");
			}else {
				System.out.println(i + "는 소수가 아닙니다.");
			}
		}
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			if (isPrime(i)) {
				sum += i;
			}
		}
		System.out.println("1 ~ 100까지 소수의 합 : " + sum);
		
	}

 	/* 최대공약수 두 정수를 매개변수로 받아, 최대공약수를 리턴하는 메서드 매개변수 : 두정수(int num1, int num2) 리턴타입 :
	 * 최대공약수(int) 메서드명 : gcd
	 */

	public static int gcd(int num1, int num2) {
		for (int i = num1; ; i--) {
			if (num1 % i == 0 && num2 % i == 0) {
				return i;
			}
		}
	}

	/*
	 * 최소공배수 두 정수를 메개변수로 받아, 최소공배수를 리턴하는 메서드 매개변수 : 두정수(int num1, int num2) 리턴타입 :
	 * 최소공배수(int) 메서드명 : lcm
	 */
	public static int lcm(int num1, int num2) {
		for (int i = num1; ; i+=num1) {
			if (i % num1 == 0 && i % num2 == 0) {
				return i; // 메서드에서 return만나면 값을 반환하고 종료~!!
			}
		}
	}
	
	public static int lcm2(int num1, int num2) { // num1과 num2의 최대공약수로 나누기
		return num1 * num2 / gcd(num1, num2); 
	}
	
	public static void main(String[] args) {

		System.out.println(gcd(6,12));
		System.out.println(lcm(15, 30));
		System.out.println(lcm2(15, 36));
		
	}

	public static void sum(int num1, int num2) {
		System.out.printf("%d + %d = %d%n", num1, num2, num1 + num2); // 덧셈 메서드
	}
	public static void sub(int num1, int num2) {
		System.out.printf("%d - %d = %d%n", num1, num2, num1 - num2); // 뺄셈 메서드
	}
	public static void mul(int num1, int num2) {
		System.out.printf("%d x %d = %d%n", num1, num2, num1 * num2); // 곱셈 메서드
	}
	public static void div(int num1, int num2) {
		System.out.printf("%d / %d = %.2f%n", num1, num2, (double)num1 / num2); // 나눗셈 메서드
	}
	public static void rem(int num1, int num2) {
		System.out.printf("%d %% %d = %d%n", num1, num2, num1 % num2); // 나머지 메서드
	}

	public static void main(String[] args) {
		/* 계산기 만들기
		 * 메뉴
		 * 1.덧셈| 2.뺄셈|3.곱셈| 4.나눗셈| 5.나머지| 6.종료
		 * ==> 메뉴 선택1
		 * ==> 숫자1> 입력받기(5)
		 * ==> 숫자2> 입력받기(3)
		 * 더하기 메서드를 호출하여 연산 (5+3)
		 * 결과 : 5 + 3 = 8
		 * 연산에 따른 switch 구문으로 메서드 호출
		 */
		
		while (true) {
			System.out.println("메뉴를 선택해 주세요");
			System.out.println("1.덧셈| 2.뺄셈|3.곱셈| 4.나눗셈| 5.나머지| 6.종료");
			Scanner scan = new Scanner(System.in);
			int menu = scan.nextInt(); // 메뉴 입력
			if (menu < 1 ||menu > 6) { // 1 ~ 6 범위 벗어나면 continue;
				System.out.println("잘못된 메뉴 입니다.");	
				continue;
			}
			if (menu == 6) { // 메뉴 6 종료
				System.out.println("종료 합니다.");
				break;
			}
			System.out.println("첫 번째 숫자 입력");
			int num1 = scan.nextInt();
			System.out.println("두 번째 숫자 입력");
			int num2 = scan.nextInt();
			switch (menu) {
			case 1 : 
				sum(num1, num2);
				break;
			case 2 :
				sub(num1, num2);
				break;
			case 3 :
				mul(num1, num2);
				break;
			case 4 :
				div(num1, num2);
				break;
			case 5 :
				rem(num1, num2);
				break;
			}
		}
		
	}

	public static void main(String[] args) {
		/* 메서드를 활용하여 배열을 활용
		 * */
		int arr[] = new int[] {11,3,5,7,4,8,9,6,2,10,1,15,16,12,14,13};
		printArray(arr);
		System.out.println();
		System.out.println("---정렬 후 arr---");
		int arr2[] = sortArray1(arr); //배열을 리턴
		printArray(arr); // 위에서 정렬된 배열이 출력
		
		System.out.println();
		System.out.println("--arr2--");
		printArray(arr2);
	}
	/* 주어진 정수 배열을 콘솔에 출력하는 메서드
	 * 매개변수 : 정수 배열 (int arr[])
	 * 리턴타입 : 출력 => void
	 * 메서드명 : printArray
	 * 5개씩 한줄로 나열
	 * */
	public static void printArray(int arr[]) {
		for(int i = 0; i < arr.length; i++) {
			if( i % 5 == 0 && i != 0) {
				System.out.println();
			}
			System.out.print(arr[i] + " ");
		}
	}
	
	/* 배열이 주어지면 배열을 오름차순 정렬하는 기능
	 * 매개변수 : 정수 배열(int arr[])
	 * 리턴타입 : 없음 => void
	 * 메서드명 : sortArray
	 * */
	public static void sortArray(int arr[]) {
		for(int i = 0; i < arr.length-1; i++) {
			for(int j = i+1; j < arr.length; j++) {
				if(arr[i] > arr[j]) {
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
				}
			}
		}
	}
	
	/* 배열이 주어지면 배열을 오름차순 정렬하고 배열을 리턴
	 * 매개변수 : 정수 배열(int arr[])
	 * 리턴타입 : 배열 자료형(int[])
	 * 메서드명 : sortArray1
	 * */
	public static int[] sortArray1(int arr[]) {
		for(int i = 0; i < arr.length-1; i++) {
			for(int j = i+1; j < arr.length; j++) {
				if(arr[i] > arr[j]) {
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
				}
			}
		}
		return arr;
	}

	/*
	 * 1. 번호를 랜덤으로 생성하는 기능 1 ~ 45까지 랜덤생성 
	 * 매개변수 : 
	 * 리턴타입 : 
	 * 메서드명 : random
	 */
	public static int random() {
		return (int)(Math.random()*45)+1;
	}

	/*
	 * 2. 배열에 1번의 랜덤번호를 저장하는 기능 
	 * 매개변수 : 
	 * 리턴타입 : 
	 * 메서드명 : randomArray
	 */
	public static void randomArray(int[]arr) {
		int cnt = 0;
		while(cnt < arr.length) {
			int r = random();
			if (!isContain(arr, r)) { // true = 중복된다.
				arr[cnt] = r;
				cnt++;
			}
		}
	}

	/*
	 * 3. 배열을 콘솔에 출력하는 기능 
	 * 매개변수 : 
	 * 리턴타입 : void 
	 * 메서드명 : printArray
	 */
	public static void printArray(int[] arr) {
		System.out.print("생성 번호 : ");
		for (int i : arr) {
			System.out.printf("[%2d]", i);
		}
	}

	/*
	 * 4. 같은 값이 있는지 확인하는 기능 
	 * 매개변수 : 배열, 랜덥값
	 * 리턴타입 : boolean
	 * 메서드명 : isContain
	 */
	public static boolean isContain(int[] num2, int random) {
		for (int i = 0; i < num2.length; i++) {
				if (num2[i] == random) {
				return true; // for문과 상관없이 메서드 종료
				}
			}
		return false;
	}

	/*
	 * 5. 등수를 알려주는 메서드 
	 * 매개변수 : 
	 * 리턴타입 : int => 등수를 리턴
	 * 메서드명 : lottoRank 
	 * --당첨기준-- 
	 * 6개 일치 : 1등 
	 * 5개 + 보너스번호 : 2등 
	 * 5개 일치 : 3등 
	 * 4개 일치 : 4등 
	 * 3개 일치 : 5등 
	 * 나머지 :꽝
	 */
	public static int lottoRank(int[] lotto, int[]user) {
		// lotto = 7개, user = 6개
		// lotto와 user는 개수가 다르기 때문에 바뀌어서 들어오면 erorr
		if (lotto.length <= user.length) {
			return -1;
		}
		int cnt = 0; // 일치 개수(보너스 제외)
		for (int i = 0; i < user.length; i++) { // 보너스를 제외시키기 위해서
			if (isContain(user, lotto[i])) {
				cnt++;
			}
		}
		// cnt : 보너스 제외 맞춘개수
		switch (cnt) {
		case 6 :return 1;
		case 5 :
			if (isContain(user, lotto[lotto.length-1])) {
				return 2;
			}else {
				return 3;
			}
		case 4 : return 4;
		case 3 : return 5;
		default:
			return -1;
		}
	}

	public static void main(String[] args) {
		/*
		 * 로또 번호 생성(1 ~ 45 랜덤으로 생성) 당첨확인
		 */
		int[] lotto = new int[7]; // 당첨번호 + 보너스번호 => 랜덤생성
		int[] user = new int[6]; // 사용자번호

		randomArray(lotto); // 번호생성
		randomArray(user); // 번호생성
		
		System.out.println("로또");
		printArray(lotto);
		
		System.out.println();
		
		System.out.println("유저");
		printArray(user);
		
		// 매개변수의 자리에 다른 값이 들어가도 자료형만 맞으면 에러가 나지 않음.
		System.out.println();
		int rank = lottoRank(lotto, user);
		if (rank == -1) {
			System.out.println("꽝 입니다.");
		}else {
			
			System.out.println(rank + "등 입니다.");
		}
		
	}

public class _01_BaseballGame {

	public static void main(String[] args) {
		/* 야구게임 메서드화
		 * 사용자번호는 직접 입력
		 * 컴퓨터번호는 랜덤생성(1 ~ 9, 중복x)
		 */
		Scanner scan = new Scanner(System.in);
		int[] comNum = new int[3];
		int[] myNum = new int[3];
		int max = 9, min = 1;
		int s = 0, b = 0;
		
		random(max, min);
		isContain2(comNum, min, max);

		while (true) {
			System.out.println("숫자 입력 > ");
			// 문자로 입력받기
			String myStr = scan.next(); // 숫자를 문자로 받음
			String[] myNumStr = myStr.split(""); // 한글자씩 잘라서 저장
			for (int i = 0; i < myNum.length; i++) {
				// 문자를 숫자로 변환해서 myNum에 저장
				myNum[i] = Integer.parseInt(myNumStr[i]);
			}
			s = Strike(myNum, comNum);
			b = ball(myNum, comNum);
			if (s == 3) {
				System.out.println("성공!! 정답~!!");
				array(myNum, comNum);
				break;
			}
			else if (s == 0 && b == 0) {
				System.out.println("out!!");
			}
			else {
				System.out.printf("[%d]STRIKE[%d]BALL", s, b);
			}
			System.out.println();
		}
		

	}
	/* 랜덤 수 생성 메서드
	 * 범위를 주지 않고 max, min 을 이용하여 범위 설정
	 * max = 9, min = 1
	 * (int)(Math.random()*개수)+시작;
	 * (int)(Math.random()*(max-min+1))+min;
	 */
	public static int random(int max, int min) {
		if (max < min) {
			int tmp = max;
			max = min;
			min = tmp;
		}
		return (int)(Math.random()*(max-min+1))+min;
	}
	
	/* 랜덤 배열 중복되지 않게 생성
	 * isContain을 _02_Method7_lotto 가져와서 사용
	 * 매개변수 : 배열, int min, int max
	 * 리턴x : void
	 */
	public static void isContain2(int[] comNum, int min, int max) {
		for (int i = 0; i < comNum.length; i++) {
			int r = random(max, min);
			if(!(_02_Method7_lotto.isContain(comNum, r))) { // 다른 클래스의 메소드 호출해서 사용
				comNum[i] = r;
			}
			else {
				i--;
			}
		}
	}
	/* strike 개수 카운트 메서드
	 * comNum, myNum 주고, 번호와 자리가 일치하면 count하는 메서드
	 * 리턴타입 : int
	 */
	public static int Strike(int[] myNum, int[] comNum) { // strike 카운트
		int s = 0;
		for (int i = 0; i < myNum.length; i++) {
			if (myNum[i] == comNum[i]) {
				s++;
			}
		}
		return s;
	}
	/* ball 개수 카운트 메서드
	 * comNum, myNum 주고, 번호가 일치하면 count하는 메서드
	 */
	public static int ball(int[] myNum, int[] comNum) { // ball 카운트
		int b = 0;
		for (int i = 0; i < comNum.length; i++) {
			for (int j = 0; j < comNum.length; j++) {
				if (myNum[i] != comNum[i] && myNum[i] == comNum[j]) {
					b++;
				}
			}
		}
		return b;
	}
	/* 배열 출력 메서드
	 */
	public static void array(int[] myNum, int[] comNum) {
		System.out.println("Computer > ");
		for (int i : comNum) {
			System.out.printf("[%d]", i);
		}
		System.out.println();
		System.out.println("User > ");
		for (int i : myNum) {
			System.out.printf("[%d]", i);
		}
	}
	
}

 

메서드 오버로딩(method overloading)이란?

 

오버로딩의 조건

 

오버로딩의 예

 

[출처]자바의 정석

 

실습을 해보자.

public class _01_Method8 {

	public static void main(String[] args) {
		/* 메서드 오버로딩
		 * - 동일한 이름을 가지는 메서드를 여러개 만드는 경우
		 * - 오버로딩 조건
		 * 1. 매개변수의 개수가 다르면 가능
		 * 2. 매개변수의 종류(자료형) 다르면 가능
		 * - 리턴타입과는 상관없음, 매개변수의 이름과도 상관없음
		 */
		_01_Method8 m = new _01_Method8(); // 객체를 생성
		System.out.println(m.sum(30,40));
		
		System.out.println(m.sum(10, 20, 30));
		System.out.println(m.sum(1.5,2.2));
		
	}

	// num1과 num2를 매개변수로 받아서 합을 돌려주는 메서드
	public int sum(int num1, int num2) { // static이 붙지 않았기 때문에 호출하려면 객체를 생성
		return num1 + num2;
	}
	public int sum(int num1, int num2, int num3) {
		return num1 + num2 + num3;
	}
	public double sum(double num1, double num2) {
		return num1 + num2;
	}
	// 리턴타입 상관x, 매개변수 이름 상관x
//	public int sum(double num1, double num2) { 
//		return num1 + num2;
//	}
}

 

가변인자 메서드

public class _02_Method9 {

	public static void main(String[] args) {
		/* 가변인자 메서드
		 * - 매개변수의 개수가 고정되어 있지 않은 경우
		 */
		System.out.println(sum(1,2,3));
		System.out.println(sum(1,2,3,4,5,6));
		System.out.println(sum(1,2,3,4,5,6,7,8,9));
		
	}

	public static int sum(int...num) { // num을 배열처럼 사용
		int result = 0;
		for (int tmp : num) {
			result += tmp;
		}
		return result;
	}
}

 

재귀 메서드

public class _03_Method10 {

	public static void main(String[] args) {
		/* 재귀 메서드 : 메서드 안에서 본인의 메서드를 호출하는 메서드(드물게 사용)
		 * ! : 팩토리얼
		 * 1부터 자신의 수까지 곱하는 값을 표현
		 * 0! = 1
		 * 1! = 1
		 * 2! = 1*2
		 * 3! = 1*2*3
		 * 4! = 1*2*3*4
		 * 5! = 1*2*3*4*5
		 */
		System.out.println(fac(5));
		System.out.println(factorial(5));
		
	}
	/* 기능 : 양수가 주어지면 주어진 양수의 팩토리얼 값을 알려주는 메서드
	 * 리턴타입 : 팩토리얼 값 => int
	 * 매개변수 : 양수 => int num
	 */
	public static int fac(int num) {
		if (num < 0) { // num가 0보다 작은 값이 들어오면
			return 0; // 스택오버플로가 발생
		}
		if(num == 0 || num == 1) {
			return 1;
		}
		int res = 1;
		for (int i = 2; i <= num; i++) {
			res *= i;
		}
		return res;
	}
	
	public static int factorial(int num) {
		if (num < 0) { // num가 0보다 작은 값이 들어오면
			return 0; // 스택오버플로가 발생
		}
		if(num == 0 || num == 1) {
			return 1;
		}
		return num * factorial(num-1);
		
	}
}

public class _04_Homework {

	public static void main(String[] args) {
		/* 두 정수 a, b가 주어졌을 때 a와 b사이에 속한 모든 정수의 합을 리턴하는 메서드
		 * 예) a = 3, b = 5  => 3 + 4 + 5
		 * 예) a = 5, b = 1  => 1 + 2 + 3 + 4 + 5
		 * 예) a = 3, b =3  => 3
		 */
		_04_Homework add = new _04_Homework();
		System.out.println(add.sum(4, 1));
		

	}
	public int sum(int a, int b) { // a=2 , b=6
		int sum = 0;
		if (a > b) {
			int tmp = a;
			a = b;
			b = tmp;
		}
		for (int i = a; i <= b; i++) {
			sum += i;
		}
		return sum;
	}
}