break문과 continue문
- 반복문 내에서 특정 조건식과 결합하여 반복문의 실행 흐름을 제어하는 용도로 사용
break문과 continue문
- 반복문 내에서 조건식에 따라 반복문을 종료하는 용도로 사용
- 주로 if문과 조합하여 반복문을 빠져나갈 조건을 설정
<기본문법>
for(초기식; 조건식; 증감식) 또는 while(조건식) {
if(조건) {
break; // 현재 소속된 반복문의 블록문을 빠져나감(종료)
}
}
- for문에서 break문
int i;
for(i=1; i<=10; i++) {
System.out.println(i);
// i값이 5일 때 for문 빠져나감
if(i==5) {
System.out.println("i = 5이므로 for문 종료!");
break;
}
}
System.out.println("for문 종료 후 i 값= " + i);
- while문에서 break문
i=1; //초기식
while(i<=10) { //조건식
System.out.println(i);
if(i==5) {
System.out.println("i = 5이므로 while문 종료!");
break;
}
i++;
}
System.out.println("while문 종료 후 i 값= " +i);
- 1~100까지 정수의 합 계산(total 변수에 저장)
-단, 합계가 1000보다 클 경우 반복문을 종료하고 빠져나간 뒤 1000보다 커지는 시점의 정수(x)를 출력
// 변수 선언 및 초기화
int total = 0;
int x;
// 반복문
for(x = 1; x <= 100; x++) {
total += x;
if(total > 1000) {
break; // 합계(total) 가 1000 보다 클 때 for문 종료
}
}
// total 과 x 값 출력
System.out.println("1 ~ " + x + "까지 정수의 합 = " + total);
System.out.println("합계가 1000보다 클 때 x = " + x);
- 1 + (-2) + 3 + (-4) + 5 + (-6) + ...생략... 형식으로 계속 더 할 때 총합이 100 이상이 되는 x 값을 출력(break문 사용) <힌트> 정수가 짝수일 때는 음수 형태로 변환하여 합계 누적
// while문 사용
x = 0;
total = 0;
// total이 100보다 작을 동안 반복(=100 이상 시 종료)
while(total<100 ) {
x++;
if(x%2==0) {
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
}
System.out.println();
System.out.println("x = " + x);
System.out.println("total = " + total);
- break문을 사용한 while문
x=1;
total =0;
while(true) { // true값을 줘서 무한반복
if(x%2==0) {
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
x++;
if(total>=100) {
break;
}
}
System.out.println();
System.out.println("x = " + x);
System.out.println("total = " + total);
x=1;
total =0;
while(true) { // true값을 줘서 무한반복
if(x%2==0) {
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
if(total>=100) {
break;
}
x++;
}
System.out.println();
System.out.println("x = " + x);
System.out.println("total = " + total);
⇒ 증감식의 위치에 따라 결과값이 다르게 나옴
- 초기식을 생략한 형태의 for문
for(; total<100; x++) { //횟수가 정해져있는 for문
if(x%2==0) { // 짝수
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
if(total>=100) {
break;
}
}
- 조건식을 생략한 형태의 for문
for(x=1; ; x++) { // 몇번 반복하는지 모를 때
if(x%2==0) { // 짝수
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
if(total>=100) {
break;
}
- 증감식을 생략한 형태의 for문
for(; total<100; ) {
if(x%2==0) { // 짝수
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
if(total>=100) {
break;
}
x++; //for문 내에서 제어변수의 값을 증가할 경우 증감식 생략 가능
}
- 모든 요소를 생략한 형태의 for문
for( ; ; ) { //위에 초기식 변수 선언 및 초기화 되어있음
if(x%2==0) { // 짝수
System.out.println(-x);
total += -x; // 음수값 변환 누적
} else { //홀수
System.out.println(x);
total += x; // 양수값 그대로 누적
}
if(total>=100) {
break;
}
x++; //for문 내에서 제어변수의 값을 증가할 경우 증감식 생략 가능
}
- 중첩 for문을 사용하여 구구단 2~9단 출력 => 단, 구구단의 단이 5단일 때 반복문 종료
for(int dan=2; dan<=9; dan++) {
System.out.println("<" + dan + "단>");
if(dan ==5) {
System.out.println("5단 종료");
break;
}
for(int i=1; i<=9; i++) {
System.out.printf("%d*%d = %d\\n", dan, i, dan*i);
}
System.out.println();
}
Label 기능
- 반복문의 앞에 위치하여 break 또는 continue의 동작 지점을 지정
- break문 또는 continue문 뒤에 해당하는 레이블의 이름을 지정할 경우 Label 위치의 다음 반복문에 break 또는 continue문이 적용됨
- 주로, 중첩 반복문에서 반복문을 한꺼번에 빠져나가기 위해 사용
- 반복문 앞 또는 위에 주로 대문자로 된 문자를 작성하고 콜론을 붙임
<기본문법>
레이블명:
바깥쪽반복문() {
안쪽반복문() {
if(조건식) {
break 레이블명; // 또는 continue 레이블명;
}
}
}
EXIT_FOR: // 레이블명
for(int dan=2; dan<=9; dan++) {
System.out.println("<" + dan + "단>");
for(int i=1; i<=9; i++) {
if(dan ==5) {
// 현재 단이 5단일 때 반복문을 종료하는 것이 아니라
// 안쪽 for문을 빠져나가고 바깥쪽 for문의 다음 반복 진행
break EXIT_FOR;
}
System.out.printf("%d*%d = %d\\n", dan, i, dan*i);
}
System.out.println();
}
메서드(Method)
- 동작(작업)의 최소 단위(= 작업을 수행하는 코드들의 모음) ex) "밥먹다"의 기능을 메서드로 표현(밥을 떠서 입에 넣고 씹기 등)
- 메서드는 반드시 호출되어야만 실행될 수 있음 Caller : 호출하는 메서드 Worker : 호출 당하는 메서드
- Argument(전달인자) : 메서드 호출 시 메서드에 전달하는 값 Parameter(매개변수) : 이 전달인자를 전달 받아 저장하는 변수
- 파라미터는 있을 수도 있고, 없을 수도 있음
- 메서드가 호출되면 작업을 수행한 후에 반드시 호출한 위치로 돌아감 이 때, 호출한 곳으로 전달하는 값을 리턴값(Return value)이라고 함
- 리턴 타입을 명시한 메서드는 반드시 return 문을 사용하여 데이터를 리턴 -단, 리턴타입이 void 인 메서드는 return문을 생략해도 되고 리턴값 없이 return문만 기술할 수 있다! -메서드 내에서 return문을 만나면 즉시 메서드를 종료하고 돌아감
- -if문 등의 조건식을 사용하여 return문을 실행할 경우 반드시 어떤 경우에도 return문이 실행되도록 조건식을 작성해야함.
- main() 메서드는 자바에서 유일하기 호출하지 않아도 프로그램 실행 시점에서 자동으로 호출되는 메서드 => main() 메서드를 자바 프로그램의 시작점(Starting Point)이라고 함.
- 메서드 호출 시 메서드 매개변수와 일치하는 타입 및 개수의 데이터 전달이 필수! (메서드 호출 형태로 정의 형태가 일치해야함)
< 메서드 정의 기본 문법 >
[접근제한자] 리턴타입 메서드명([매개변수선언....]) {
//메서드 호출 시 수행할 코드들...
[return [리턴값];]
}
public static void main(String[] args) { // 메서드의 기본형태
<메서드 형태 4가지>
- 파라미터도 없고, 리턴값도 없는 메서드
- 파라미터도 없고, 리턴값만 있는 메서드
- 파라미터만 있고, 리턴값은 없는 메서드
- 파라미터도 있고, 리턴값도 있는 메서드
1. 파라미터도 없고, 리턴값도 없는 메서드
- 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
- 리턴값이 없으므로 리턴타입 부분에 특수한 데이터타입 void 타입을 명시 (void = 리턴값이 없다는 의미)
메서드 호출 기본문법
리턴값이 없는 경우
메서드명([데이터...])
리턴값이 있는 경우
- 데이터타입 변수명 = 메서드명([데이터...]) => 리턴되는 데이터를 변수에 저장할 경우
- System.out.println(메서드명([데이터...]); => 리턴되는 데이터를 출력하거나 직접 연산에 사용하는 경우
2. 파라미터도 없고, 리턴값만 있는 메서드
- 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
- 리턴값이 있으므로 리턴 할 때마다 데이터와 일치하는 데이터타입을 리턴타입 부분에 명시(문자열을 리턴하려면 String 타입을 명시)
3. 파라미터만 있고, 리턴값은 없는 메서드
- 파라미터가 있으므로 메서드 선언부 소괄호() 안에 외부로부터 호출 시 전달받는 데이터를 저장할 변수(매개변수) 선언
- 리턴값은 없으므로 리턴타입 부분을 void로 설정
4. 파라미터도 있고, 리턴값도 있는 메서드 정의(2번 유형 + 3번 유형)
- 파라미터도 없고, 리턴값도 없는 메서드 호출 연습
package method;
public class Test {
public static void main(String[] args) {
// 1. 파라미터도 없고, 리턴값도 없는 메서드 호출 연습
// "Hello, World!" 문자열을 10번 출력하는 printHello() 메서드 호출
printHello(); // 파라미터가 없으므로 소괄호 안에 아무것도 전달하지 않음
// main 메서드 끝과 Test 메서드 끝 사이에 입력해야함
} // main 메서드 끝
// ==========================================
// 1. 파라미터도 없고, 리턴값도 없는 메서드 정의 연습
// "Hello, World!" 문자열을 10번 출력하는 printHello() 메서드 정의
// => 리턴값이 없으므로 리턴타입에 void 타입 명시
// => 파라미터가 없으므로 메서드 선언부 소괄호 안에 아무것도 명시하지 않음
public static void printHello() {
// printHello() 메서드가 호출되면 "Hello, World!" 문자열 10번 출력
for(int i=1;i<=10;i++) {
System.out.println("Hello, World!");
}
}
} // Test 클래스 끝
1-1) 구구단 2~9단까지 출력하는 gugudan() 메서드 호출
package method;
public class Test {
public static void main(String[] args) {
// 구구단 2~9단까지 출력하는 gugudan() 메서드 호출
gugudan();
} // main 메서드 끝
public static void gugudan() {
for(int dan=2; dan<=9; dan++) {
System.out.println();
System.out.println("<"+dan+"단>");
for(int n=1; n<=9;n++) {
System.out.printf("%d*%d=%d\\n", dan,n,dan*n);
}
}
}
} // Test 클래스 끝
- 파라미터는 없고, 리턴값만 있는 메서드 정의 연습
1~10까지 정수의 합(55)을 계산하여 리턴하는 sum() 메서드 호출하고, 리턴되는 정수의 합(55)을 변수 total에 저장 후 출력
package method;
public class Test {
public static void main(String[] args) {
// 2. 파라미터는 없고, 리턴값만 있는 메서드 호출 연습
// 1~10까지 정수의 합(55)을 계산하여 리턴하는 sum() 메서드 호출하고,
// 리턴되는 정수의 합(55)을 변수 total에 저장 후 출력
int total=sum();
System.out.printf("1~10까지 정수의합:%d\\n",total);
} // main 메서드 끝
// 2. 파라미터는 없고, 리턴값만 있는 메서드 정의 연습
// 1~10까지 정수의 합(55)을 계산하여 리턴하는 sum() 메서드 정의
// => 메서드 파라미터가 없으므로 선언부 소괄호() 안에 아무것도 명시하지 않음
// => 리턴값이 있으므로 리턴할 데이터와 일치하는 데이터타입을
// 리턴타입 부분에 명시(정수의합(정수)을 리턴하므로 int 타입을 명시)
public static int sum() {
// 1~10까지 정수의 합을 계산하여 결과값을 리턴
int total=0;
for(int i=1; i<=10; i++) {
total+=i;
}
return total;
}
} // Test 클래스 끝
main의 total과 return의 total은 다른거임!
2-1) 오늘의 날씨("맑음")을 문자열로 리턴하는 getWeather() 메서드 정의
package method;
public class Test {
public static void main(String[] args) {
String todayWeather = getWeather();
System.out.println("오늘의 날씨: " + todayWeather);
} // main 메서드 끝
public static String getWeather() {
String today="맑음";
return today;
}
} // Test 클래스 끝
- 파라미터만 있고, 리턴값은 없는 메서드 호출 연습
package method;
public class Test2 {
public static void main(String[] args) {
// 3. 파라미터만 있고, 리턴값은 없는 메서드 호출 연습
// => 문자열을 1개 전달하면 해당 문자열을 출력하는 print() 메서드 호출
print("안녕하세요!");
}// main() 메서드 끝
public static void print(String str) { //String str="안녕하세요!"
System.out.println(str);
}
} //Test2 클래스 끝
3-1) 정수를 1개 전달하면 해당 정수에 대해 "홀수", "짝수" 판별하는 checkNumber() 메서드 호출
package method;
public class Test {
public static void main(String[] args) {
// => 정수를 1개 전달하면 해당 정수에 대해 "홀수", "짝수" 판별하는
// checkNumber() 메서드 호출
checkNumber(1);
} // main 메서드 끝
// => 정수를 1개 전달하면 해당 정수에 대해 "홀수", "짝수" 판별하는 checkNumber() 메서드 정의
public static void checkNumber(int num) {
if(num %2 ==1) {
System.out.println(num + "은 홀수!");
} else {
System.out.println(num + "은 짝수!");
}
}
} // Test 클래스 끝
- 파라미터도 있고, 리턴값도 있는 메서드 호출 연습
package method;
public class Test {
public static void main(String[] args) {
// 4. 파라미터도 있고, 리턴값도 있는 메서드 호출 연습
// => 정수 1개를 전달하면 해당 정수에 대해 "홀수", "짝수" 판별하고
// 판별 결과 문자열을 리턴하는 checkNumber2() 메서드 호출
String result = checkNumber2(1);
System.out.println("판별결과: "+result);
} // main 메서드 끝
public static String checkNumber2(int num) {
if (num %2 == 1) {
System.out.println(num+"은 홀수!");
return "홀수";
} else {
System.out.println(num+"은 짝수!");
return "짝수";
}
}
} // Test 클래스 끝
=> if문 등의 조건식을 사용하여 return문을 실행할 경우 반드시 어떤 경우에도 return문이 실행되도록 조건식을 작성해야함.
만약, if-else문을 사용한다면
if(num%2==1) {
return "홀수";
} else if(num%2==0) {
return "짝수";
}
return "";
}
String result = "";
if(num%2==1) {
result="홀수";
} else if(num%2==0) {
result="짝수";
}
return result;
}
5. 파라미터가 2개 이상인 메서드 호출
package method;
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, "새우깡"); //int, String 형태의 데이터 전달
System.out.println("동생이 바꿔다 준 것 : "+mySnack);
}
// 5. 파라미터가 2개 이상인 메서드 정의
// => 전달되는 데이터가 int, String 형태이므로
// 파라미터 선언 순서도 int, String 순서로 선언해야 된다!
public static String sister_5(int money, String snack) {
System.out.println("오빠가 준 돈 : " + money + "원");
System.out.println("오빠가 준 과자 : " + snack);
System.out.println(snack+"을 쿠쿠다스로 교환했다!");
snack="쿠쿠다스";
//snack 변수 값 리턴
return snack;
}
}
Test3
5-1) 정수 2개를 전달하면 두 정수의 합을 리턴하는 메서드를 호출하고 리턴값을 출략(ex. 10, 20 전달 시 10+20 결과인 30 리턴)
package method;
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("두 수를 더한 결과 = "+sum(10,20));
} //main() 메서드 끝
public static int sum(int i, int j) {
System.out.println("숫자1= "+i);
System.out.println("숫자2= "+j);
return i+j;
}
} //Test3 클래스 끝
- System.out.println("두 수를 더한 결과 = "+result);
- System.out.println("두 수를 더한 결과 = "+sum(10,20));
5-2) 연산자 문자 1개와 정수 2개를 전달하면 두 정수에 대한 어떤 연산을 수행한 후 결과값을 리턴하는 메서드 호출하고 리턴되는 값을 출력
package method;
public class Test3 {
public static void main(String[] args) {
// => 연산자 문자 1개와 정수 2개를 전달하면
// 두 정수에 대한 어떤 연산을 수행한 후
// 결과값을 리턴하는 메서드 호출하고 리턴되는 값을 출력
// ex) '+', 10, 20 전달 시 10 + 20 결과인 30 리턴
// ex) '-', 10, 20 전달 시 10 - 20 결과인 -10 리턴
int result2 = opertation('+', 10, 20);
System.out.println("연산 결과 = " + result2);
result2 = opertation('-', 10, 20);
System.out.println("연산 결과 = " + result2);
result2 = opertation('*', 10, 20);
System.out.println("연산 결과 = " + result2);
} //main() 메서드 끝
// 5. 파라미터가 2개 이상인 메서드 정의 연습
// => 연산자 문자 1개와 정수 2개를 전달받아
// 두 정수에 대한 어떤 연산을 수행한 후 결과값을 리턴하는 메서드 정의
public static int opertation(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;
// }
int result = 0; // 연산 결과를 저장할 변수
if(opr == '+') { // 덧셈
return num1 + num2;
} else if(opr == '-') {
return num1 - num2;
} else {
// 잘못된 연산자가 입력되었을 경우
// 오류 메세지 출력 후 0 리턴(가정)
System.out.println("연산자가 올바르지 않습니다!");
}
return result;
// 주의! 변수 값을 리턴하는 경우 반드시 변수값 초기화 필수!
}
} //Test3 클래스 끝
'JAVA' 카테고리의 다른 글
| [JAVA] 접근제한자 (0) | 2023.09.11 |
|---|---|
| [JAVA] 객체지향 프로그래밍 이해하고 입출금기능 있는 은행잔고 클래스 만들기 (0) | 2023.09.11 |
| [JAVA] 중첩 while문 (0) | 2023.09.11 |
| [JAVA] do ~ while문 (0) | 2023.09.11 |
| [JAVA] while문 (0) | 2023.09.11 |
