반응형
/*
* 메서드(Method)
* - 동작(작업)의 최소 단위(= 작업을 수행하는 코드들의 모음)
* ex) '밥먹다' 의 기능을 메서드로 표현(밥을 떠서 입에 넣고 씹기 등)
* - 메서드는 반드시 호출되어야만 실행될 수 있음
* => 호출하는 메서드 : Caller, 호출 당하는 메서드 : Worker
* - 메서드 호출 시 메서드에 전달하는 값을 전달인자(Argument)라고 하며,
* 이 전달 인자를 전달받아 저장하는 변수를 매개변수(Parameter)라고 함
* => 파라미터는 있을 수도 있고, 없을 수도 있다.
* - 메서드가 호출되면 작업을 수행한 후에 반드시 호출한 위치로 돌아감
* => 이 때, 호출한 곳으로 전달하는 값을 리턴값(Return value)이라고 함
* - 리턴타입을 명시한 메서드는 반드시 return 문을 사용하여 데이터 리턴
* => 단, 리턴타입이 void 인 메서드는 return 문을 생략해도 되고
* 리턴값 없이 return 문만 기술할 수 있다!
* => 메서드 내에서 return 문을 만나면 즉시 메서드를 종료하고 돌아감
* => if 문 등의 조건식을 사용하여 return 문을 실행할 경우
* 반드시 어떤 경우에도 return 문이 실행되도록 조건식을 작성해야함
*
* - main() 메서드는, 자바에서 유일하게 호출하지 않아도
* 프로그램 실행 시점에서 자동으로 호출되는 메서드
* => main() 메서드를 자바 프로그램의 시작점(Starting point)이라고 함
* - 메서드 호출 시 메서드 매개변수와 일치하는 타입 및 갯수의
* 데이터 전달이 필수! (메서드 호출 형태로 정의 형태가 일치해야함)
*
* < 메서드 정의 기본 문법 >
* [제한자] 리턴타입 메서드명([매개변수선언...]) {
* // 메서드 호출 시 수행할 코드들...
* [return [리턴값];]
* }
*
* < 메서드 호출 기본 문법 >
* 1. 리턴값이 없는 경우
* 메서드명([데이터...]);
*
* 2. 리턴값이 있는 경우
* 1) 데이터타입 변수명 = 메서드명([데이터...]);
* => 리턴되는 데이터를 변수에 저장할 경우
* 2) System.out.println(메서드명([데이터...]);
* => 리턴되는 데이터를 출력하거나 직접 연산에 사용하는 경우
*
* < 메서드 형태 4가지 >
* 1. 파라미터도 없고, 리턴값도 없는 메서드
* 2. 파라미터는 없고, 리턴값만 있는 메서드
* 3. 파라미터만 있고, 리턴값은 없는 메서드
* 4. 파라미터도 있고, 리턴값도 있는 메서드
*/public class Ex {
public static void main(String[] args) {
//Method
//----------------- worker 메서드 호출 ---------------------
// 1. 파라미터(전달할 값)도 없고, 리턴값(돌려받을 값)도 없는 메서드 호출
System.out.println("동생아! 불 좀 끄고 가라!");
sister_1(); //sister_1() 메서드 호출
// =>매개변수(파라미터)가 없으므로 소괄호에 전달할 데이터도 없음
System.out.println("동생이 불을 끄고 갔다!");
//주의! 리턴값이 없는 메소드를 출력문에서 호출 or 변수에 대입 불가
// System.out.println(sister_1());//오류
System.out.println("============================");
// 2. 파라미터는 없고, 리턴값만 있는 메서드 호출
System.out.println("동생아! 물 좀 떠온나!");
// sister_2();
// => 리턴값이 있는 메서드 호출 후 변수에 저장하거나 출력문에 사용 가능
// 만약, 아무 동작도 없을 경우 메서드 호출 후 리턴값은 버려짐
// String result = sister_2();
// System.out.println("동생이 가져다 준 것 : "+ result);
//리턴값을 변수에 저장하지 않고 직접 사용 가능
System.out.println("동생이 가져다 준 것 : "+ sister_2());
}//main() 메서드 끝
//------------------ worker 메서드 정의 ----------------------
// 1. 파라미터도 없고, 리턴값도 없는 메서드 정의
// => 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
// => 리턴값이 없으므로 리턴타입 부분에 특수한 데이터타입인 void 타입을 명시
// (void = 리턴값이 없다는 의미)
public static void sister_1() {
//sister_1메서드가 호출했을때 수행할 작업들을 기술
System.out.println("동생 : 오빠가 불 끄라고 해서 불을 껐다!");
}//메서드를 종료하면 메서드를 호출한 곳으로 이동(되돌아감)
//-------------------------------------------------------------
// 2. 파라미터는 없고, 리턴값만 있는 메서드 호출
// => 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
// => 리턴값이 있으므로 리턴할 데이터와 일치하는 데이터타입을
// 리턴타입 부분에 명시(문자열을 리턴하므로 String 타입을 명시)
public static String sister_2() {
System.out.println("동생 : 오빠가 물 떠오라고 시켜서 물을 떠다 줬다!");
// return 문을 사용하여 리턴타입 String 에 해당하는 데이터 리턴
return "물"; // 리터럴을 직접 리턴하는 방법
// 리턴값을 변수에 저장한 후 변수를 return 문에 기술하는 방법
// String item = "물";
// return item;
}
}//Ex 클래스 끝
/*
동생아! 불 좀 끄고 가라!
동생 : 오빠가 불 끄라고 해서 불을 껐다!
동생이 불을 끄고 갔다!
============================
동생아! 물 좀 떠온나!
동생 : 오빠가 물 떠오라고 시켜서 물을 떠다 줬다!
동생이 가져다 준 것 : 물
*/public class Test {
public static void main(String[] args) {
// 1. 파라미터도 없고, 리턴값도 없는 메서드 호출 연습
// "Hello, World!" 문자열을 10번 출력하는 printHello() 메서드 호출
printHello();
System.out.println("---------------------");
// 구구단 2단 ~ 9단까지 출력하는 gugudan() 메서드 호출
gugudan();
System.out.println("---------------------");
// 2. 파라미터는 없고, 리턴값만 있는 메서드 호출 연습
// 1 ~ 10까지 정수의 합(55)을 계산하여 리턴하는 sum() 메서드 호출하고,
// 리턴되는 정수의 합(55)을 변수 total 에 저장 후 출력
int total = sum();
System.out.println("1 ~ 10까지 정수의 합: " + total);
System.out.println("-----------------------");
// System.out.println("오늘의 날씨 : " + getWeather());
String todayWeather = getWeather();
System.out.println("오늘의 날씨 : " + todayWeather);
}
// "Hello, World!" 문자열을 10번 반복 출력하는 printHello() 메서드 정의
// => 리턴값이 없으므로 리턴타입에 void 타입 명시
// => 파라미터가 없으므로 메서드 선언부 소괄호 안에 아무것도 명시하지 않음
public static void printHello() {
for (int i = 1; i <= 10; i++) {
System.out.println("Hello, World");
}
}// printHello() 끝
// 구구단 2단 ~ 9단까지 출력하는 gugudan() 메서드 정의
// => 리턴값이 없으므로 리턴타입에 void 타입 명시
// => 파라미터가 없으므로 메서드 선언부 소괄호 안에 아무것도 명시하지 않음
public static void gugudan() {
for (int dan = 2; dan <= 9; dan++) {
System.out.println("< " + dan + "단 >");
for (int i = 1; i <= 9; i++) {
System.out.println(dan + " * " + i + " = " + dan * i);
}
System.out.println();
} // gugudan() 끝
}//main() 메서드 끝
// 2. 파라미터는 없고, 리턴값만 있는 메서드 정의 연습
// 1 ~ 10 까지 정수의 합(55)을 계산하여 리턴하는 sum() 메서드 정의
// => 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
// => 리턴값이 있으므로 리턴할 데이터와 일치하는 데이터타입을
// 리턴타입 부분에 명시(정수의 합(정수)을 리턴하므로 int 타입을 명시)
public static int sum() {
int total = 0;
for (int i = 0; i <= 10; i++) {
total += i;
}
return total;
}
// ---------------------------------------
// 오늘의 날씨("흐림")를 문자열로 리턴하는 getWeather() 메서드 정의
public static String getWeather() {
// return "흐림";
String today = "흐림";
return today;
}
}
/*
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
---------------------
< 2단 >
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
< 3단 >
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
< 4단 >
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
< 5단 >
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
< 6단 >
6 * 1 = 6
6 * 2 = 12
6 * 3 = 18
6 * 4 = 24
6 * 5 = 30
6 * 6 = 36
6 * 7 = 42
6 * 8 = 48
6 * 9 = 54
< 7단 >
7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
< 8단 >
8 * 1 = 8
8 * 2 = 16
8 * 3 = 24
8 * 4 = 32
8 * 5 = 40
8 * 6 = 48
8 * 7 = 56
8 * 8 = 64
8 * 9 = 72
< 9단 >
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81
---------------------
1 ~ 10까지 정수의 합: 55
-----------------------
오늘의 날씨 : 흐림
*/public class Test1_2 {
public static void main(String[] args) {
//메서드 유형 1번 연습
//파라미터도 없고 리턴값도 없는 메서드
//------------- 메서드 호출 --------------
//=>메서드가 호출되면 자신의 이름을 10번 출력하는 printName() 메서드
printName();
//메서드 유형 2번 연습
//파라미터 x, 리턴값o
// => 메서드가 호출되면 10 + 20 의 결과값을 리턴하는 sum() 메서드
int result = sum();
System.out.println(result);
// System.out.println(sum());
}
//--------------- 메서드 정의 ---------------
public static void printName() {
for(int i =1; i <= 10; i++) {
System.out.println("자바");
}
}
public static int sum() {
// int sum = 10 +20 ;
// return sum;
return 10+20;
}
}
/*
자바
자바
자바
자바
자바
자바
자바
자바
자바
자바
30
*/public class Ex2 {
public static void main(String[] args) {
//3. 파라미터 o , 리턴값 x
System.out.println("동생아! 돈 줄테니 과자 사먹어라!");
// int myMoney = 200;
// sister_3(myMoney);
// => 메서드 호출 시 전달할 데이터는 메서드명 뒤의 소괄호 내에 기술
// 메서드 파라미터에 리터럴값 직접 전달하거나
// 변수를 사용하여 값을 저장한 뒤 파라미터에 전달 가능
sister_3(200);
System.out.println("======================================");
//4. 파라미터 o,리턴값 o
System.out.println("동생아! 200원 줄테니 내 새우깡도 사다 도!");
// sister_4(200);
String snack = sister_4(1000);
System.out.println("동생이 사다준 것 : " + snack);
}
//메서드 정의
// 3. 파라미터만 있고, 리턴값은 없는 메서드 정의
// => 파라미터가 있으므로 메서드 선언부 소괄호() 안에
// 외부로부터 호출 시 전달받는 데이터를 저장할 변수(매개변수) 선언
// => 리턴값은 없으므로 리턴타입 부분을 void 로 지정
public static void sister_3(int money) { //int money = 200
// 파라미터로 선언된 int형 변수 money 에 메서드 호출 시 전달된 값 저장됨
// => sister_3(200) 호출 시 int money = 200 과 동일한 코드로 취급됨
System.out.println("동생: 오빠가 준 돈 = " + money + "원");
// 현재 메서드 내에서 money 변수를 자유롭게 사용 가능
// 단, 메서드를 벗어나면 존재하지 않는 변수로 취급됨
money-=200;
System.out.println("동생: 새우깡 사먹고 " + money + "원 남았다." );
} // sister_3() 메서드 끝
// public static void sister_3(int money) {
// System.out.println("동생 : 오빠가 준 돈 = " + money + "원");
// money -= 200;
//
// // if문을 사용하여 잔돈이 남았을 때 잔돈을 출력하지 않고 메서드 종료
// // => 만약, 잔돈이 남지 않았을 경우 "잔돈 0원" 출력
// if(money > 0) {
// // 현재 수행중인 메서드를 종료하고 빠져나가기 위해서는
// // 특정 조건일 때 return 문이 실행되도록 해야한다!
// return;
// }
//
// System.out.println("동생 : 잔돈 " + money + "원");
//
// } // sister_3() 메서드 끝
public static String sister_4(int money) {
System.out.println("동생: 오빠가 준 돈 = " + money + "원");
money-=200;
System.out.println("동생: 새우깡 사먹고 " + money + "원 남았다." );
// return "새우깡", money; // 주의! return 문 뒤의 값은 하나만 기술!
return "새우깡";
}
}
/*
동생아! 돈 줄테니 과자 사먹어라!
동생: 오빠가 준 돈 = 200원
동생: 새우깡 사먹고 0원 남았다.
======================================
동생아! 200원 줄테니 내 새우깡도 사다 도!
동생: 오빠가 준 돈 = 1000원
동생: 새우깡 사먹고 800원 남았다.
동생이 사다준 것 : 새우깡
*/public class Test2 {
public static void main(String[] args) {
// => 문자열을 1개 전달하면 해당 문자열을 출력하는 print() 메서드 호출
print("Java");
System.out.println("----------------------------");
// => 정수를 1개 전달하면 해당 정수에 대해 "홀수", "짝수" 판별하는
// checkNumber() 메서드 호출
checkNumber(5);
System.out.println("----------------------------");
// => 정수 1개를 전달하면 해당 정수에 대해 "홀수", "짝수"를 판별하고
// 판별 결과 문자열을 리턴하는 checkNumber2() 메서드 호출
String result = checkNumber2(10);
System.out.println("판별결과 : " + result);
}
// => 문자열을 1개 전달받아 해당 문자열을 출력하는 print() 메서드 정의
// => 외부로부터 전달받은 문자열 저장하기 위한 변수를 소괄호() 안에 선언
public static void print(String str) {
System.out.println(str);
}
// =================================================================
// 3. 파라미터만 있고, 리턴값은 없는 메서드 정의
// => 정수를 1개 전달받아 해당 정수에 대해 "홀수", "짝수" 판별하는
// checkNumber() 메서드 정의
public static void checkNumber(int num) {
if(num % 2 == 0) {
System.out.println(num + " : 짝수");
}else {
System.out.println(num + " : 홀수");
}
}
// => 정수 1개를 전달받아 해당 정수에 대해 "홀수", "짝수"를 판별하고
// 판별 결과 문자열을 리턴하는 checkNumber2() 메서드 정의
public static String checkNumber2(int num) {
if(num % 2 == 0) {
return "짝수";
}else {
return "홀수";
}
}
// => 정수 1개를 전달받아 해당 정수에 대해 "홀수", "짝수"를 판별하고
// 판별 결과 문자열을 리턴하는 checkNumber2() 메서드 정의
// public static String checkNumber2(int num) {
// if(num % 2 == 1) {
// return "홀수";
// } else {
// return "짝수";
// }
// ---------------------------------
// if(num % 2 == 1) {
// return "홀수";
// } else if(num % 2 == 0) {
// return "짝수";
// }
//
// return "";
// ---------------------------------
// if 문과 else if 문 내에서 직접 리턴하지 않고
// 리턴 데이터를 별도의 변수에 저장만 한 뒤, if문 종료 후 return 수행
// String result = "";
//
// if(num % 2 == 1) {
// result = "홀수";
// } else if(num % 2 == 0) {
// result = "짝수";
// }
//
// return result;
// }
}
/*
Java
----------------------------
5 : 홀수
----------------------------
판별결과 : 짝수
*/public class Ex3 {
public static void main(String[] args) {
// 5. 파라미터가 2개 이상인 메서드
String snack = "새우깡";
int myMoney = 1000;
System.out.println("동생아 니가 사온 새우깡이랑 1000원 줄테니 쿠쿠다스로 바꿔온나!");
String mySnack = sister_5(1000,"새우깡");
System.out.println("동생이 바꿔다 준 것 : " + mySnack);
}
// 5. 파라미터가 2개 이상인 메서드 정의
// => 전달되는 데이터가 int, String 형태이므로
// 파라미터 선언 순서도 int, String 순서로 선언해야된다!
public static String sister_5(int myMoney, String snack) {
System.out.println("동생: 오빠가 준 돈 = " + myMoney + "원");
System.out.println("동생: 오빠가 준 과자 = " + snack);
System.out.println(snack + "을 쿠쿠다스로 교환했다!");
snack = "쿠쿠다스";
// snack 변수 값 리턴
return snack;
}
}
/*
동생아 니가 사온 새우깡이랑 1000원 줄테니 쿠쿠다스로 바꿔온나!
동생: 오빠가 준 돈 = 1000원
동생: 오빠가 준 과자 = 새우깡
새우깡을 쿠쿠다스로 교환했다!
동생이 바꿔다 준 것 : 쿠쿠다스
*/public class Test3 {
public static void main(String[] args) {
// 5. 파라미터가 2개 이상인 메서드 호출 연습
// => 정수 2개를 전달하면 두 정수의 합을 리턴하는 메서드를 호출하고
// 리턴값을 출력(ex. 10, 20 전달 시 10 + 20 결과인 30 리턴)
int result = sum(10,20);
System.out.println("두 정수의 합 = " + result);
System.out.println("==============================");
int result2 = operation('+',10,20);
System.out.println("연산결과 = " + result2);
result2 = operation('-', 10, 20);
System.out.println("연산 결과 = " + result2);
result2 = operation('*', 10, 20);
System.out.println("연산 결과 = " + result2);
}
// ------------------------------------------------------------
// => 정수 2개를 전달받아 두 정수의 합을 리턴하는 메서드를 정의
// ex. 10, 20 전달 시 10 + 20 결과인 30 리턴
public static int sum(int num1, int num2) {
return num1 + num2;
}
// public static int sum2(char ch, int num1, int num2) {
// if(ch == '+') {
// return num1 + num2;
// }else if (ch == '-'){
// return num1 - num2;
// }else {
// System.out.println("연산결과가 올바르지 않습니다");
// return 0; //
// }
// }
// 5. 파라미터가 2개 이상인 메서드 정의 연습
// // => 연산자 문자 1개와 정수 2개를 전달받아
// 두 정수에 대한 어떤 연산을 수행한 후 결과값을 리턴하는 메서드 정의
public static int operation(char opr, int num1, int num2) {
int result = 0; //연산결과를 저장할 변수
if(opr == '+') {
result = num1 + num2;
}else if (opr == '-'){
result= num1 - num2;
}else {
// 잘못된 연산자가 입력되었을 경우
// // 오류 메세지 출력 후 0 리턴(가정)
System.out.println("연산결과가 올바르지 않습니다");
}
return result;
// 주의! 변수 값을 리턴하는 경우 반드시 변수값 초기화 필수!
}
// public static int operation(char opr, int num1, int num2) {
// 연산자 문자(char 타입) 판별(== 사용)
// if(opr == '+') { // 덧셈
// return num1 + num2;
// } else if(opr == '-') {
// return num1 - num2;
// } else {
// // 잘못된 연산자가 입력되었을 경우
// // 오류 메세지 출력 후 0 리턴(가정)
// System.out.println("연산자가 올바르지 않습니다!");
// return 0;
// }
}
/*
두 정수의 합 = 30
==============================
연산결과 = 30
연산 결과 = -10
연산결과가 올바르지 않습니다
연산 결과 = 0
*/반응형
'JAVA' 카테고리의 다른 글
| [Java] Class 연습 (0) | 2021.10.28 |
|---|---|
| [Java] Class (0) | 2021.10.28 |
| [Java] 배열 테스트 문제 (0) | 2021.10.28 |
| [Java] 배열(Array) (0) | 2021.10.26 |
| [Java] 반복문 (0) | 2021.10.26 |