제어문

kailyn·2024년 8월 20일
Java

JAVA

목록 보기
4/17

1. 조건문

1. 조건문 개요

1-1. 조건문이란?

💡 조건문은 **“조건식”**을 통해 특정 코드를 실행할지 말지를 제어해주는 구문이다. 특정 조건식의 결과가 참이라면 조건문 내부의 코드를 실행한다. 조건식은 **`true`, `false`**같이 **`boolean`**형 타입을 반환해주는 식을 말한다.
  • 한 가지 예를 들어보자. 현재 내가 배가 고프다면, 빵이든 밥이든 사 먹을 것이다. 이때 내가 배가 고픈가? 가 조건식이 된다.
    ”배가 고프다” 라는 조건이 참이라면 음식을 사 먹는다는 행동을 하지만 배가 고프지 않다면 아무 행동도 하지 않을 것이다.
    이렇게 특정 조건에 따라 다른 행동 또는 코드를 실행해야 할 때 조건문을 사용한다.

1-2. 조건문 종류

💡 조건문은 크게 2가지 if 문과 switch 문으로 분류된다. if문은 if 문, if-else 문, if-else if 문으로 나뉜다.

💡 의사코드 먼저 해보기!

2. if 문 개요

2-1. if 문 표현식

  • 자바에서 사용하는 if 문의 표현식은 아래와 같다.
if (조건식) {
    수행문;
    ...
}
  • if문은 조건식의 결과 값이 참(true)이면 { } 안에 있는 코드를 실행하고,
    조건식의 결과 값이 거짓(false)이면 { } 안에 있는 코드를 무시하고 넘어간다.

3. if 문 활용

  1. 단독 if 문 실행 흐름 확인

    • 정수 한 개를 입력 받아 그 수가 짝수이면 "입력하신 숫자는 짝수입니다." 라고 출력하고, 짝수가 아니면 출력하지 않는 구문을 작성해보자.
      단, 조건과 상관 없이 프로그램이 종료될 때 "프로그램을 종료합니다." 라고 출력되도록 한다.

    	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.print("숫자 한 개를 입력하세요 : ");
		int num = sc.nextInt();
		
		/* 짝수인지 물어보는 조건을 기술함
		 * 어떤 수를 2로 나누었을 때 나머지가 0이면 짝수이다. 즉, 2의 배수이다.
		 * */
		if(num % 2 == 0) {
		    /* 조건식 부분에 작성한 내용이 true일 때는 해당 내용을 실행한다.
		     * 하지만 false인 경우 if블럭 전체를 무시하고 건너 뛰며 실행하게 된다. */
		    System.out.println("입력하신 숫자는 짝수입니다.");
		}
		
		/* 조건문과 상관 없이 프로그램 종료를 확인하기 위한 용도의 출력 구문 */
		System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      숫자 한 개를 입력하세요 : **4**
입력하신 숫자는 짝수입니다.
프로그램을 종료합니다.

숫자 한 개를 입력하세요 : **5**
프로그램을 종료합니다.

숫자 한 개를 입력하세요 : **-12**
입력하신 숫자는 짝수입니다.
프로그램을 종료합니다.

  2. 중첩 if 문 실행 흐름 확인

    • if 문 안에서 또 다른 조건문을 사용할 수 있다.
    • 정수 한 개를 입력 받아 그 수가 양수인 경우에만 짝수인지를 확인하여 짝수이면 "입력하신 숫자는 양수이면서 짝수입니다." 라고 출력하고,
      둘 중 하나라도 해당하지 않으면 아무 내용도 출력하지 않는 구문을 작성해보자
      단, 조건과 상관 없이 프로그램이 종료될 때 "프로그램을 종료합니다." 라고 출력되도록 한다.

    public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.print("숫자를 한 개 입력하세요 : ");
		int num = sc.nextInt();
		
		/* 양수인지 조건 확인 */
		if(num > 0) {
		    /* 양수가 맞는 경우 다시 한 번 더 짝수인지 조건을 확인함 */
		    if(num % 2 == 0) {
		        /* 짝수가 맞는 경우 */
		        System.out.println("입력하신 숫자는 양수이면서 짝수입니다.");
		    }
		}
		
		/* 조건문과 상관 없이 프로그램 종료를 확인하기 위한 용도의 출력 구문 */
		System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      숫자를 한 개 입력하세요 : **4**
입력하신 숫자는 양수이면서 짝수입니다.
프로그램을 종료합니다.

숫자를 한 개 입력하세요 : **5**
프로그램을 종료합니다.

숫자를 한 개 입력하세요 : **-12**
프로그램을 종료합니다.
  • 내가 작성한 코드
    public class Application {

    /* 설명. 이제부터 실행용 클래스를 구분해서 사용한다.(main 메소드는 여기에만 포함 */

    public static void main(String[] args) {

        A_if aClass = new A_if();

        /* 필기. 단독 if문 흐름 확인용 메소드 호출 */
//        aClass.testSimpleIfStatement();

        /* 필기. 중첩 if문 흐름 확인용 메소드 호출 */
//        aClass.testNestedIfStatement();

//        B_ifElse bClass = new B_ifElse();

        /* 필기. 단독 if-else문 흐름 확인용 메소드 호출 */
//        bClass.testSimpleIfElseStatement();

        /* 필기. 중첩 if-else문 흐름 확인용 메소드 호출 */
//        bClass.testNestedIfElseStatement();

        C_ifElseIf cClass = new C_ifElseIf();

        /* 필기. 단독 if-else-if문 흐름 확인용 메소드 호출 */
//        cClass.testSimpleIfElseIfStatement();

        /* 필기. 단독 if-else-if문 흐름 확인용 메소드 호출 */

        /* 필기. 단독 if-else-if문 로직 개선 */
//        cClass.testNestedIfElseIfStatemnet();

        D_switch dClass = new  D_switch();

        /* 필기. switch문 흐름 확인용 메소드 호출 */
        dClass.testSimpleSwitchStatement();

    }
}
    import java.util.Scanner;

public class A_if {

    public void testSimpleIfStatement() {
        /* 수업목표. if문 단독 사용에 대한 흐름을 이해하고 적용할 수 있다. */
        Scanner sc = new Scanner(System.in);

        System.out.print("정수 한 개를 입력하세요: ");
        int input =sc.nextInt();

//        만약에(입력받은 값이 짝수면) {
//            "짝수입니다"라고 출력한다.
//        }
        if(input % 2 == 0){
            System.out.println("짝수입니다.");
        }
    }

    public void testNestedIfStatement() {
        /* 수업목표. 중첩된 if문의 흐름을 이해하고 적용할 수 있다. */
        Scanner sc = new Scanner(System.in);

        System.out.print("양수 하나를 입력해 주세요: ");
        int input = sc.nextInt();
        if(input > 0) {
            if(input % 2 != 0) {
                System.out.println("입력 받은 값은 양수이면서 홀수입니다.");
            }
        }

        if(input > 0 && input % 2 != 0) {
            System.out.println("위와 같은 조건");
        }
    }
}
    import java.util.Scanner;

public class B_ifElse {
    public void testSimpleIfElseStatement() {

        /* 수업목표. if-else문 단독 사용에 대한 흐름을 이해하고 적용할 수 있다. */
        Scanner sc = new Scanner(System.in);

        System.out.print("정수를 하나 입력하세요: ");
        int input = sc.nextInt();

//        만약에(홀수라면) {
//            "입력 하신 정수는 홀수입니다." 출력
//        } 그 밖에 {
//            "입력 하신 정수는 짝수입니다." 출력
//        }

        if(input % 2 != 0) {
            System.out.println("입력하신 정수는 홀수입니다.");
        } else {
            System.out.println("입력하신 정수는 짝수입니다.");
        }
    }

    public void testNestedIfElseStatement() {
        /* 수업목표. 중첩된 if-else 문의 흐름을 이해하고 적용할 수 있다. */
        Scanner sc = new Scanner(System.in);

        System.out.println("정수를 하나 입력하세요: ");
        int input = sc.nextInt();

        /* 필기. 정수를 하나 입력받아 양수와 음수를 구분하고 양수일 때만 짝수인지 아닌지 판별한다.(각 상태 모두 출력) */
        if(input > 0) {                 // 양수일 때
            System.out.println("양수입니다.");

            if(input % 2 == 0) {        // 양수이면서 짝수일 때
                System.out.println("양수이면서 짝수입니다.");
            } else {                    // 양수이면서 홀수일 때
                System.out.println("양수이면서 홀수입니다.");
            }
        } else {                        // 0 또는 음수
            System.out.println("0 또는 음수입니다.");

        }
    }
}
    import java.util.Scanner;

public class C_ifElseIf {
    public void testSimpleIfElseIfStatement() {

        /* 수업목표. if-else-if문 단독 사용에 대한 흐름을 이해하고 적용할 수 있다. */
        System.out.println("산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.");
        System.out.println("연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.");
        System.out.println("나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.");

        System.out.println("어느 도끼가 너의 도끼냐? (1. 금도끼, 2. 은도끼, 3. 쇠도끼) : ");

        Scanner sc = new Scanner(System.in);
        int answer = sc.nextInt();

        if(answer == 1) {
            System.out.println("이런 거짓말쟁이!! 너에게는 아무런 도끼도 줄 수 없구나!! 이 욕심쟁이야!!");
        } else if (answer == 2) {
            System.out.println("욕심이 과하지는 않지만 그래도 넌 거짓말을 하고 있구나!! 어서 썩 꺼지거라!!");

        } else {
            System.out.println("오호~ 정직하구나~ 여기 있는 금도끼, 은도끼, 쇠도끼를 모두 다 가져가거라!!");
        }

        System.out.println("그렇게 산신령은 다시 연못 속으로 홀연히 사라지고 말았다...!");

    }

    public void testNestedIfElseIfStatemnet() {

        /* 수업목표. 중첩된 if-else-if문의 흐름을 이해하고 적용할 수 있다. */
        /* 필기.
         *  ohgiraffers 대학의 김XX교수님은 학생들 시험 성적을 수기로 계산해서 학점 등급을 매기는 채점방식을 사용하고 있다.
         *  90점 이상이면 'A', 80점 이상이면 'B', 70점 이상이면 'C', 60점 이상이면 'D', 마지막으로 60점 미만인 경우에는
         *  'F'로 학점을 주게 된다.
         *  (추가로, 각 등급의 중간점수(95, 85, 75...)인 경우 '+'를 붙여서 등급을 세분화 해보자.)
         *
         * 필기.
         *  출력 예시: XXX 학생의 점수는 86점이고, 등급은 B+이다.
         *           프로그램을 종료합니다.
        * */

        Scanner sc = new Scanner(System.in);
        System.out.println("학생 이름을 입력하세요: ");
        String name = sc.next();

        System.out.println("점수를 입력하세요: ");
        int point = sc.nextInt();

        String grade = "";

        if(point <= 100 && point >= 0) {
            if(point >= 90) {
                grade = "A";
            } else if (point >= 80) {
                grade = "B";
            } else if (point >= 70) {
                grade = "C";
            } else if (point >= 60) {
                grade = "D";
            } else  {
                grade = "F";
            }

            if(point % 10 >= 5 && point >= 65) {
                grade +=  "+";
            } else {
                grade = "F";
            }
            System.out.println(name + " 학생의 점수는 " + point + "이고, 등급은 " + grade + "입니다.");
            System.out.println("프로그램을 종료합니다.");
        }

    }
}

4. if-else 문 개요

4-1. if-else 문 표현식

if (조건식) {
    조건식이 true 일 때 실행되는 수행문;
    ...
} else {
    조건식이 false 일 때 실행되는 수행문;
		...
}
  • if문은 조건식의 결과 값이 참(true)이면 if { } 안에 있는 코드를 실행하고,
    조건식의 결과 값이 거짓(false)이면 else { } 안에 있는 코드를 실행한다.
  • 조건을 만족하는지 여부에 따라 둘 중 하나는 무조건 실행해야 하는 경우 많이 사용된다.

5. if-else 문 활용

  1. 단독 if-else 구문 흐름을 확인

    • 정수 한 개를 입력 받아 그 수가 홀수 이면 "입력하신 숫자는 홀수입니다." 라고 출력하고,
      홀수가 아니면 "입력하신 숫자는 짝수입니다." 라고 출력하는 프로그램을 작성해보자.
      단, 조건과 상관 없이 프로그램이 종료될 때 "프로그램을 종료합니다." 라고 출력되도록 한다.

    public static void main(String[] args) {
	
	    Scanner sc = new Scanner(System.in);
	
	    System.out.print("정수를 하나 입력하세요 : ");
	    int num = sc.nextInt();
	
	    /* 조건식은 반드시 true 혹은 false가 나오도록 작성해야 한다. */
	    /* 짝수인지 조건 확인 */
	    if(num % 2 != 0){
	
	        /* 조건문이 참일 때 출력할 내용 */
	        System.out.println("입력 하신 숫자는 홀수입니다.");
	    }else{
	
	        /* 조건식이 거짓일 때 출력할 내용 */
	        System.out.println("입력 하신 숫자는 짝수입니다.");
	    }
	
	    /* 조건문과 상관 없이 프로그램 종료 시 출력할 내용 */
	    System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      정수를 하나 입력하세요 : **3**
입력 하신 숫자는 홀수입니다.
프로그램을 종료합니다.

정수를 하나 입력하세요 : **4**
입력 하신 숫자는 짝수입니다.
프로그램을 종료합니다.

  2. 중첩 if-else 구문 흐름을 확인

    • 숫자를 하나 입력 받아 양수이면 "입력하신 숫자는 양수입니다." 출력하고,
      음수이면 "입력하신 숫자는 음수 입니다." 출력한다.
      단, 0이면 "입력하신 숫자는 0 입니다." 라고 출력한다.
      조건과 상관 없이 프로그램이 종료될 때 "프로그램을 종료합니다." 라고 출력되도록 한다.

    public static void main(String[] args) {

      Scanner sc = new Scanner(System.in);

      System.out.print("정수를 하나 입력하세요 : ");
      int num = sc.nextInt();

      /* 0인지 아닌지 조건 확인 */
      if(num != 0){

          /* 0인 경우에 다시 한 번 조건을 비교함 */
          /* 0보다 큰 숫자인지 확인 */
          if(num > 0){

              /* 0보다 더 큰 경우 출력할 내용 */
              System.out.println("입력하신 숫자는 양수입니다.");
          }else{

              /* 0보다 더 작은 경우 출력할 내용 */
              System.out.println("입력하신 숫자는 음수입니다.");
          }

      }else{

          /* 0인 경우 출력할 내용 */
          System.out.println("입력하신 숫자는 0 입니다.");
      }

      /* 조건문과 상관 없이 프로그램 종료 시 출력할 내용 */
      System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      정수를 하나 입력하세요 : **0**
입력하신 숫자는 0 입니다.
프로그램을 종료합니다.

정수를 하나 입력하세요 : **2**
입력하신 숫자는 양수입니다.
프로그램을 종료합니다.

정수를 하나 입력하세요 : **-3**
입력하신 숫자는 음수입니다.
프로그램을 종료합니다.

6. if-elseif 문 개요

6-1. if-elseif 문 표현식

  • if와 else만으로는 다양한 조건 판단을 하기가 어렵다. 다음과 같은 상황은 if-else 만으로는 해결하기 어려워진다.
산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.
연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.
나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.
  • 이 때 나무꾼이 금도끼라고 할 때, 은도끼라고 할 때, 쇠도끼라고 할 때 각각에 대해 산신령의 답변이 달라진다.
  • 이런 상황에서 if-else if 문을 사용한다. else if는 개수에 제한 없이 사용할 수 있다.
if (조건식1) {
    수행문;
    ...
} else if(조건식2) {
		수행문;
		...
} else {
		수행문;
		...
}
  • if-else-if문은 조건식1의 결과 값이 참(true)이면 if { } 안에 있는 코드를 실행하고,
    조건식1이 false이면 조건식2를 확인하여 참(true)이면 else if { } 안에 있는 코드를 실행한다.
    조건식1, 2의 결과 값이 모두 거짓(false)이면 else { } 안에 있는 코드를 실행한다.

7. if-elseif 문 활용

  1. 단독 if-else-if문 실행 흐름을 확인

    public static void main(String[] args) {

      System.out.println("산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.");
      System.out.println("연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.");
      System.out.println("나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.");

      System.out.print("어느 도끼가 너의 도끼이냐? (1. 금도끼, 2. 은도끼, 3. 쇠도끼) : ");
      Scanner sc = new Scanner(System.in);
      int answer = sc.nextInt();

      /* 대답한 내용이 금도끼인지 확인하는 조건식 */
      if(answer == 1) {

          /* 금도끼라고 대답한 경우 출력할 내용 */
          System.out.println("이런 거짓말 쟁이!! 너에게는 아무런 도끼도 줄 수 없구나!! 이 욕심쟁이야!!");

      /* 대답한 내용이 은도끼인지 확인하는 조건식 */
      } else if(answer == 2) {

          /* 은도끼라고 대답한 경우 출력할 내용 */
          System.out.println("욕심이 과하지는 않지만 그래도 넌 거짓말을 하고 있구나!! 어서 썩 사라지거라!!");

      /* 위에 제시한 금도끼, 은도끼가 둘 다 아닌 경우(즉, 쇠도끼인 경우) */
      } else {

          /* 쇠도끼라고 대답한 경우 출력할 내용 */
          System.out.println("오호~ 정직하구나~ 여기 있는 금도끼, 은도끼, 쇠도끼를 다 가져가거라!!");
      }

      /* 대답 여부와 상관 없이 마지막에 실행하는 내용 */
      System.out.println("그렇게 산신령은 다시 연목 속으로 사라지고 말았다...");
}
    • 실행결과
      산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.
연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.
나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.
어느 도끼가 너의 도끼이냐? (1. 금도끼, 2. 은도끼, 3. 쇠도끼) : **1**
이런 거짓말 쟁이!! 너에게는 아무런 도끼도 줄 수 없구나!! 이 욕심쟁이야!!
그렇게 산신령은 다시 연목 속으로 사라지고 말았다...

산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.
연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.
나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.
어느 도끼가 너의 도끼이냐? (1. 금도끼, 2. 은도끼, 3. 쇠도끼) : **2**
욕심이 과하지는 않지만 그래도 넌 거짓말을 하고 있구나!! 어서 썩 사라지거라!!
그렇게 산신령은 다시 연목 속으로 사라지고 말았다...

산 속에서 나무를 하던 나무꾼이 연못에 도끼를 빠뜨리고 말았다.
연못에서 산신령이 나타나 금도끼, 은도끼, 쇠도끼를 들고 나타났다.
나무꾼에게 셋 중 어떤 도끼가 나무꾼의 도끼인지 물어보았다.
어느 도끼가 너의 도끼이냐? (1. 금도끼, 2. 은도끼, 3. 쇠도끼) : **3**
오호~ 정직하구나~ 여기 있는 금도끼, 은도끼, 쇠도끼를 다 가져가거라!!
그렇게 산신령은 다시 연목 속으로 사라지고 말았다...

  2. 중첩 if-else-if 구문 흐름을 확인

    • 김XX 교수님은 학생들 시험 성적을 수기로 계산해서 학점 등급을 매기는 채점 방식을 사용하고 있었다.
      90점 이상이면 'A', 80점 이상이면 'B', 70점 이상이면 'C', 60점 이상이면 'D' 를 60점 미만인 경우에는 'F' 를 학점 등급으로 하는 기준이다.
      추가로 각 등급의 중간 점수 (95, 85, 75 ...)인 경우 '+'를 붙여서 등급을 세분화 하다 보니 신경 쓸 게 이만 저만이 아니다.
      그래서 학생의 이름과 점수를 입력하면 자동으로 학점 등급이 계산되는 프로그램을 만들기로 했다.
    public static void main(String[] args) {

      /* 학생의 이름과 점수 입력 */
      Scanner sc = new Scanner(System.in);
      System.out.print("학생의 이름을 입력하세요 : ");
      String name = sc.nextLine();
      System.out.print("학생의 점수를 입력하세요 : ");
      int point = sc.nextInt();

      /* 학생의 등급을 저장하기 위한 변수 초기화 */
      String grade = "";

      /* 학점등급을 매기기 위해 점수를 확인 하기 위한 조건문 */
      if(point >= 90) {

          /* 점수가 90점 이상인 경우 */
          grade = "A";

          /* 등급은 A등급인데 그럼 +가 붙을 자격이 있는지(95점 이상인지) 다시 확인 */
          if(point >= 95) {

              /* 95점 이상인 경우 A등급에 +기호를 덧붙여 A+ 등급을 만들어준다. */
              grade += "+";
          }

      } else if(point >= 80) {

          /* 점수가 90점 미만, 80점 이상인 경우 */
          grade = "B";

          /* 등급은 B등급인데 그럼 +가 붙을 자격이 있는지(85점 이상인지) 다시 확인 */
          if(point >= 85) {

              /* 85점 이상인 경우 B등급에 +기호를 덧붙여 B+ 등급을 만들어준다. */
              grade += "+";
          }

      } else if(point >= 70) {

          /* 점수가 80점 미만, 70점 이상인 경우 */
          grade = "C";

          /* 등급은 C등급인데 그럼 +가 붙을 자격이 있는지(75점 이상인지) 다시 확인 */
          if(point >= 75) {

              /* 75점 이상인 경우 C등급에 +기호를 덧붙여 C+ 등급을 만들어준다. */
              grade += "+";
          }

      } else if(point >= 60) {

          /* 점수가 70점 미만, 60점 이상인 경우 */
          grade = "D";

          /* 등급은 D등급인데 그럼 +가 붙을 자격이 있는지(65점 이상인지) 다시 확인 */
          if(point >= 65) {

              /* 65점 이상인 경우 D등급에 +기호를 덧붙여 D+ 등급을 만들어준다. */
              grade += "+";
          }

      } else {

          /* 위 조건을 다 만족하지 못하는 점수가 60점 미만인 경우 */
          grade = "F";

          /* 등급이 F인 경우는 +를 붙이지 않는다. */

      }

      /* 위에서 결정된 등급을 점수와 함께 출력한다. */
      System.out.println(name + " 학생의 점수는 " + point + "이고, 등급은 " + grade + "입니다.");
      System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **60**
ohgiraffers 학생의 점수는 60이고, 등급은 D입니다.
프로그램을 종료합니다.

학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **77**
ohgiraffers 학생의 점수는 77이고, 등급은 C+입니다.
프로그램을 종료합니다.

학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **98**
ohgiraffers 학생의 점수는 98이고, 등급은 A+입니다.
프로그램을 종료합니다.

  3. 중첩 if-else-if 구문 흐름을 확인(심화)

    • 2번 예제를 효율적으로 개선하는 방식을 고민해본다.
    public static void main(String[] args) {

      /* 학생의 이름과 점수 입력 */
      Scanner sc = new Scanner(System.in);
      System.out.print("학생의 이름을 입력하세요 : ");
      String name = sc.nextLine();
      System.out.print("학생의 점수를 입력하세요 : ");
      int point = sc.nextInt();

      /* 학생의 등급을 저장하기 위한 변수 초기화 */
      String grade = "";

      /* 학점등급을 매기기 위해 점수를 확인 하기 위한 조건문 */
      if(point >= 90) {

          /* 점수가 90점 이상인 경우 */
          grade = "A";

      } else if(point >= 80) {

          /* 점수가 90점 미만, 80점 이상인 경우 */
          grade = "B";

      } else if(point >= 70) {

          /* 점수가 80점 미만, 70점 이상인 경우 */
          grade = "C";

      } else if(point >= 60) {

          /* 점수가 70점 미만, 60점 이상인 경우 */
          grade = "D";

      } else {

          /* 위 조건을 다 만족하지 못하는 점수가 60점 미만인 경우 */
          grade = "F";
      }

      /* 각 등급의 중간 점수 이상이면서 60점 이상인 경우인지 확인(즉, +를 붙이는 조건에 맞는지 확인) */
      if(point % 10 >= 5 && point >= 60 || point == 100) {

          /* 60점 이상이면서 10으로 나눈 나머지가 5보다 큰 경우 */
          grade += "+";
      }

      /* 위에서 결정된 등급을 점수와 함께 출력한다. */
      System.out.println(name + " 학생의 점수는 " + point + "이고, 등급은 " + grade + "입니다.");
      System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **50**
ohgiraffers 학생의 점수는 50이고, 등급은 F입니다.
프로그램을 종료합니다.

학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **77**
ohgiraffers 학생의 점수는 77이고, 등급은 C+입니다.
프로그램을 종료합니다.

학생의 이름을 입력하세요 : **ohgiraffers**
학생의 점수를 입력하세요 : **99**
ohgiraffers 학생의 점수는 99이고, 등급은 A+입니다.
프로그램을 종료합니다.

8. switch 문 개요

  • 조건식 하나로 많은 경우의 수를 처리할 때 사용하며 이때 조건식의 결과는 정수 또는 문자. 문자열 비교 가능
  • 조건식의 결과 값과 일치하는 case문으로 이동
  • default문은 일치하는 case문이 없을 때 수행(=else)

8-1. switch 문 표현식

  • 여러 개의 비교값 중 일치하는 조건에 해당하는 로직을 실행하는 것은 if-elseif와 유사하다. 따라서 일부 호환이 가능하다.
  • 하지만, switch문으로 비교 가능한 값은 정수, 문자, 문자열 형태의 값이다. 실수와 논리는 비교할 수 없다.
    또한 정확하게 일치하는 경우만 비교할 수 있으며 대소 비교를 할 수 없다는 게 차이점이다.
    case절에는 변수를 사용하지 못한다. (값만 비교 가능)
  • 또한, 문자열 비교는 jdk 1.7 이상부터 가능하다.
switch(비교할변수) {

		case 비교값1 : 
						비교값1과 일치하는 경우 실행할 구문; 
						break;
		case 비교값2 : 
						비교값2와 일치하는 경우 실행할 구문; 
						break;
		default : 
						case에 모두 해당하지 않는 경우 실행할 구문; 
						break;
}
  • switch 문은 입력 받은 값을 확인하여 해당 결과와 일치하는 case 문으로 분기한다.
    case 문에서 실행할 구문이 실행되고 break 문을 만나면 switch 문을 벗어난다.
    만약 break 문이 없다면 바로 다음에 따라오는 case 문이 실행된다.
  • switch 문은 if-else 구조로 변경이 가능하지만 if-else 구조로 작성된 모든 코드를 switch 문으로 변경할 수는 없다.

9. switch 문 활용

  1. switch문 실행 흐름을 확인

    • 정수 두 개와 연산 기호 문자를 입력 받아서 두 숫자의 연산 결과를 출력해보는 간단한 계산기 만들어보자.
    public static void main(String[] args) {

    /* 정수 두 개와 연산 기호 입력 */
    Scanner sc = new Scanner(System.in);
    System.out.print("첫 번째 정수 입력 : ");
    int first = sc.nextInt();
    System.out.print("두 번째 정수 입력 : ");
    int second = sc.nextInt();
    System.out.print("연산 기호 입력(+, -, *, /, %) : ");
    char op = sc.next().charAt(0);

    /* 연산의 결과를 저장할 변수 */
    int result = 0;

    /* 입력한 연산기호 문자에 따라 연산 결과가 달라짐 */
    switch(op) {
        case '+' :
            result = first + second;
            break;
        case '-' :
            result = first - second;
            break;
        case '*' :
            result = first * second;
            break;
        case '/' :
            result = first / second;			//second가 0이면 에러 발생(ArithmeticException)
            break;
        case '%' :
            result = first % second;
            break;
        /* default문은 생략 가능하지만 생략하는 경우 주석으로 생략 이유를 작성해주는 것이 좋다. */
        /* 산술연산 외에 다른 문자에 대한 처리는 생략하였음 */
    }

    System.out.println(first + " " + op + " " + second + " = " + result)
}
    • 실행결과
      첫 번째 정수 입력 : **12**
두 번째 정수 입력 : **10**
연산 기호 입력(+, -, *, /, %) : **+**
12 + 10 = 22

첫 번째 정수 입력 : **5**
두 번째 정수 입력 : **9**
연산 기호 입력(+, -, *, /, %) : **-**
5 - 9 = -4

첫 번째 정수 입력 : **10**
두 번째 정수 입력 : **5**
연산 기호 입력(+, -, *, /, %) : *****
10 * 5 = 50

  2. switch문으로 문자열 값 비교 테스트 및 break 테스트 (1)

    public static void main(String[] args) {

    /* switch문을 이용한 간단한 자판기 */
    System.out.println("=== Samhyook vending machine ===");
    System.out.println("  사이다   콜라   환타   바스  핫식스  ");
    System.out.println("==============================");
    System.out.print("음료를 선택해주세요 : ");

    /* 원하는 음료를 문자열로 입력받음 */
    Scanner sc = new Scanner(System.in);
    String selectedDrink = sc.nextLine();

    /* 원하는 음료에 맞는 가격을 저장할 변수 */
    int price = 0;

    /* 하지만 한 개의 메뉴를 선택해도 그 메뉴 이후의 메뉴가 전부 선택이 되는 이상한 자판기가 되었다.
     * 가격 또한 음료별로 다르지만 마지막 메뉴 가격인 10000원으로 고정되어 있다.
     * */
    switch(selectedDrink) {
        case "사이다" :
            System.out.println("사이다를 선택하셨습니다.");
            price = 500;
        case "콜라" :
            System.out.println("콜라를 선택하셨습니다.");
            price = 600;
        case "환타" :
            System.out.println("환타를 선택하셨습니다.");
            price = 700;
        case "바카스" :
            System.out.println("바카스를 선택하셨습니다.");
            price = 2000;
        case "핫식스" :
            System.out.println("핫식스를 선택하셨습니다.");
            price = 10000;
    }

    System.out.println(price + "원을 투입해주세요!");
}
    • 실행결과
      === OhGiraffers vending machine ===
  사이다   콜라   환타   바카스  핫식스  
==============================
음료를 선택해주세요 : **사이다**
사이다를 선택하셨습니다.
콜라를 선택하셨습니다.
환타를 선택하셨습니다.
바카스를 선택하셨습니다.
핫식스를 선택하셨습니다.
10000원을 투입해주세요!

  1. switch문으로 문자열 값 비교 테스트 및 break 테스트 (2)

    • 자판기를 구입한 OhGiraffers 슈퍼에서는 자판기 개발사에 항의를 했다.
      이제 정상적으로 자판기 기능을 수행할 수 있도록 코드를 개선해보자 (break 추가함)
    public static void main(String[] args) {

    System.out.println("------------------ 개선된 자판기 --------------------");
    System.out.println("=== OhGiraffers vending machine ===");
    System.out.println("  사이다   콜라   환타   바카스  핫식스  ");
    System.out.println("==============================");
    System.out.print("음료를 선택해주세요 : ");

    /* 원하는 음료를 문자열로 입력받음 */
    Scanner sc = new Scanner(System.in);
    String selectedDrink = sc.nextLine();

    /* 원하는 음료에 맞는 가격을 저장할 변수 */
    int price = 0;

    String order = "";

    switch(selectedDrink) {
        case "사이다" :
            order = "사이다";
            price = 500;
            break;
        case "콜라" :
            order = "콜라";
            price = 600;
            break;
        case "환타" :
            order = "환타";
            price = 700;
            break;
        case "바카스" :
            order = "바카스";
            price = 2000;
            break;
        case "핫식스" :
            order = "핫식스";
            price = 10000;
            break;
    }

    System.out.println(order + "를 선택하셨습니다.");
    System.out.println(price + "원을 투입해주세요!");
}
    • 실행결과
      ------------------ 개선된 자판기 --------------------
=== OhGiraffers vending machine ===
  사이다   콜라   환타   바카스  핫식스  
==============================
음료를 선택해주세요 : **사이다**
사이다를 선택하셨습니다.
500원을 투입해주세요!

------------------ 개선된 자판기 --------------------
=== OhGiraffers vending machine ===
  사이다   콜라   환타   바카스  핫식스  
==============================
음료를 선택해주세요 : **환타**
환타를 선택하셨습니다.
700원을 투입해주세요!
  • 내가 작성한 코드
    import java.util.Scanner;

public class D_switch {
    public void testSimpleSwitchStatement() {

        /* 수업목표. switch만 단독 사용 시 흐름을 이해하고 적용할 수 있다. */
        Scanner sc = new Scanner(System.in);
        System.out.println("본인의 등급을 입력하시오(G: 골드, S: 실버, B: 브론즈): ");
        char grade =sc.next().charAt(0);
        int point = 0;
        boolean flag = true;

        switch (grade) {
            case 'G' : point += 10;
            case 'S' : point += 10;
            case 'B' : point += 10;
                       break;
            default:
                flag = false;
                System.out.println("어디 회원 등급이세요?");
        }
        if(flag) {
            System.out.println("당신의 등급은 " + grade + "이며, 현재 포인트는 " + point + "입니다.");
        } else {
            System.out.println("그럼 이참에 회원 가입 하시죠!");
        }
    }

}

2. 반복문

1. 반복문 개요

1-1. 반복문이란?

💡 반복문은 특정 코드를 반복하여 수행할 수 있도록 제어하는 명령문이다.
  • 예를 들어보자. 1부터 1000 까지의 숫자를 출력해야 하는 프로그램이 있다고 하자.
    반복문을 사용하지 않는다면, 우리는 일일히 1000 줄의 코드를 작성해야 할 것이다.
     public static void main(String[] args) {
 
     System.out.println("1부터 1000까지 출력하기");
     System.out.println("출력 : 1");
     System.out.println("출력 : 2");
     System.out.println("출력 : 3");
 
     ...
 
     System.out.println("출력 : 998");
     System.out.println("출력 : 999");
     System.out.println("출력 : 1000"); 
 }
  • 이를 해결하기 위해서 반복문이 존재한다. 위의 코드를 반복문으로 작성할 때 단 몇 줄이면 충분하다.
    public static void main(String[] args) {

    System.out.println("1부터 1000까지 출력하기");

    for(int i = 1 ; i <= 1000; i++){
        System.out.println("출력 : " + i);
    }

}

1-2. 반복문 종류

💡 자바에서 사용하는 대표적인 반복문은 3가지가 있다. 1. for 문 2. while 문 3. do-while 문
  • 사실 반복문의 문법보다 어려운 것은 언제 반복문을 사용하는 지를 판단하는 것이다.
    언제 반복문을 사용하는 지에 대해서 예제들을 통해 하나씩 살펴보자.

2. for 문 개요

  • for문 진행 순
  1. 초기식
  2. 조건식
  3. 조건이 만족하면 중괄호
  4. 증감식
  5. i가 10이라는 값을 넘어서 11이라는 값이 나올 때 조건이 만족하지 않아서 for문 종료
💡 헷갈릴 때는 코드를 출력하는 부분에서 브레이크 포인트 체크하고 디버그 모드를 사용하자.
  • for문의 i는 지역 변수임.

2-1. for 문 표현식

  • for 문은 초기식, 조건식, 증감식을 포함하고 있으나 모든 값이 필수인 것은 아니다. 때에 따라서 일부식들은 생략해서 사용하기도 한다.
for(1-초기식; 2-조건식; 4-증감식) {
     3-조건을 만족하는 경우 수행할 구문(반복할 구문);
}
  • for 문의 흐름

  • 기본 반복문을 이용해서 조금씩 바꿔가며 우선 문법을 익숙해지는 것을 추천한다. 필요에 따라 변형해가며 테스트 해보자
    1. 증감식이 없는 경우
    2. 조건식이 없는 경우
    3. 초기식, 조건식, 증감식이 없는 경우
    4. 초기식, 조건식, 증감식 등을 변경하고 실행 값 예측해보기
    5. 역순으로 반복문 실행

3. for 문 활용

  1. 무엇을 반복하면 좋을지 생각해보는 예제 (1)

    public static void main(String[] args) {

    /* 무엇을 반복하는지를 확인하고, 반복문으로 개선해보기 */

    /* 10명의 학생 이름을 입력받아 이름을 출력해보자 */
    /* 반복해야 할 내용이 무엇인지와 몇 번 반복해야 하는지를 확인해보자!! */
    Scanner sc = new Scanner(System.in);

    System.out.print("1 번째 학생의 이름을 입력해주세요 : ");
    String student1 = sc.nextLine();
    System.out.println("1 번째 학생의 이름은 " + student1 + "입니다.");

    System.out.print("2 번째 학생의 이름을 입력해주세요 : ");
    String student2 = sc.nextLine();
    System.out.println("2 번째 학생의 이름은 " + student2 + "입니다.");

    System.out.print("3 번째 학생의 이름을 입력해주세요 : ");
    String student3 = sc.nextLine();
    System.out.println("3 번째 학생의 이름은 " + student3 + "입니다.");

    System.out.print("4 번째 학생의 이름을 입력해주세요 : ");
    String student4 = sc.nextLine();
    System.out.println("4 번째 학생의 이름은 " + student4 + "입니다.");

    System.out.print("5 번째 학생의 이름을 입력해주세요 : ");
    String student5 = sc.nextLine();
    System.out.println("5 번째 학생의 이름은 " + student5 + "입니다.");

    System.out.print("6 번째 학생의 이름을 입력해주세요 : ");
    String student6 = sc.nextLine();
    System.out.println("6 번째 학생의 이름은 " + student6 + "입니다.");

    System.out.print("7 번째 학생의 이름을 입력해주세요 : ");
    String student7 = sc.nextLine();
    System.out.println("7 번째 학생의 이름은 " + student7 + "입니다.");

    System.out.print("8 번째 학생의 이름을 입력해주세요 : ");
    String student8 = sc.nextLine();
    System.out.println("8 번째 학생의 이름은 " + student8 + "입니다.");

    System.out.print("9 번째 학생의 이름을 입력해주세요 : ");
    String student9 = sc.nextLine();
    System.out.println("9 번째 학생의 이름은 " + student9 + "입니다.");

    System.out.print("10 번째 학생의 이름을 입력해주세요 : ");
    String student10 = sc.nextLine();
    System.out.println("10 번째 학생의 이름은 " + student10 + "입니다.");

    System.out.println("10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!");
}
    • 실행결과
      1 번째 학생의 이름을 입력해주세요 : **일**
1 번째 학생의 이름은 일입니다.
2 번째 학생의 이름을 입력해주세요 : **이**
2 번째 학생의 이름은 이입니다.
3 번째 학생의 이름을 입력해주세요 : **삼**
3 번째 학생의 이름은 삼입니다.
4 번째 학생의 이름을 입력해주세요 : **사**
4 번째 학생의 이름은 사입니다.
5 번째 학생의 이름을 입력해주세요 : **오**
5 번째 학생의 이름은 오입니다.
6 번째 학생의 이름을 입력해주세요 : **육**
6 번째 학생의 이름은 육입니다.
7 번째 학생의 이름을 입력해주세요 : **칠**
7 번째 학생의 이름은 칠입니다.
8 번째 학생의 이름을 입력해주세요 : **팔**
8 번째 학생의 이름은 팔입니다.
9 번째 학생의 이름을 입력해주세요 : **구**
9 번째 학생의 이름은 구입니다.
10 번째 학생의 이름을 입력해주세요 : **십**
10 번째 학생의 이름은 십입니다.
10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!

    개선 코드

    public static void main(String[] args) {

    /* 반복해야 하는 내용은
     * 1. 안내문구 출력
     * 2. 학생 이름 입력 받아 변수에 저장
     * 3. 저장된 이름을 출력
     *
     * 반복 횟수는 1 부터 10까지 1씩 증가하며 총 10번을 반복한다.
     * */
    Scanner sc = new Scanner(System.in);

    for(int i = 1; i <= 10; i++) {
        System.out.print(i + " 번째 학생의 이름을 입력해주세요 : ");
        String student = sc.nextLine();
        System.out.println(i + " 번째 학생의 이름은 " + student + "입니다.");
    }

    System.out.println("10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!");
}
    • 실행결과
      1 번째 학생의 이름을 입력해주세요 : **일**
1 번째 학생의 이름은 일입니다.
2 번째 학생의 이름을 입력해주세요 : **이**
2 번째 학생의 이름은 이입니다.
3 번째 학생의 이름을 입력해주세요 : **삼**
3 번째 학생의 이름은 삼입니다.
4 번째 학생의 이름을 입력해주세요 : **사**
4 번째 학생의 이름은 사입니다.
5 번째 학생의 이름을 입력해주세요 : **오**
5 번째 학생의 이름은 오입니다.
6 번째 학생의 이름을 입력해주세요 : **육**
6 번째 학생의 이름은 육입니다.
7 번째 학생의 이름을 입력해주세요 : **칠**
7 번째 학생의 이름은 칠입니다.
8 번째 학생의 이름을 입력해주세요 : **팔**
8 번째 학생의 이름은 팔입니다.
9 번째 학생의 이름을 입력해주세요 : **구**
9 번째 학생의 이름은 구입니다.
10 번째 학생의 이름을 입력해주세요 : **십**
10 번째 학생의 이름은 십입니다.
10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!

  1. 무엇을 반복하면 좋을지 생각해보는 예제 (2)

    public static void main(String[] args) {

    /* 무엇을 반복하는지를 확인하고, 반복문으로 개선해보기 */
    /* 문장 속에서 규칙 찾기 */

    /* 1 ~ 10까지의 합계를 구하시오
     * 이렇게만 작성되어 있으면 처음 프로그래밍 하는 사람에게는 꽤나 난감하다.
     * 어느 정도 익숙한 사람에게는 저 문제에서 해결해야 하는 내용과 규칙이 머릿속에 자연스럽게 그려지지만
     * 처음 접하는 사람한테는 그렇지 않다.
     * 단계적으로 접근할 수 있도록 위의 내용을 좀 풀어서 다시 작성해본다면
     *
     * 1부터 10까지 1씩 증가시키면서 증가시키는 값을 저장할 변수에 계속 누적시켜 변수에 저장된 값을 출력하세요 가 된다.
     * */

    /* 코드로 작성해보자 */
    /* 1부터 10까지를 변수에 저장 */
    int num1 = 1;
    int num2 = 2;
    int num3 = 3;
    int num4 = 4;
    int num5 = 5;
    int num6 = 6;
    int num7 = 7;
    int num8 = 8;
    int num9 = 9;
    int num10 = 10;

    /* 결과를 누적시켜 담아줄 변수 선언 */
    /* 더한 값을 누적시킬 변수는 통상 0으로 초기화를 한다. */
    int sum = 0;

    /* sum에 변수의 값 하나씩 담기 */
    sum += num1;
    sum += num2;
    sum += num3;
    sum += num4;
    sum += num5;
    sum += num6;
    sum += num7;
    sum += num8;
    sum += num9;
    sum += num10;

    /* sum에 저장된 값 출력 */
    System.out.println("sum : " + sum);
}
    • 실행결과
      sum : 55

개선 코드

public static void main(String[] args) {

    /* 무엇을 반복하면 좋을까? 반복해야 할 행동을 생각해보자
     *
     * 반복해야 할 내용
     * 1. 변수에 1씩 증가하는 값 담기
     * 2. 저장된 값을 sum에 누적시키기
     *
     * 반복 횟수는? 1부터 10까지 1씩 증가(10번 반복)
     *
     * 반복하지 않을 내용
     * 1. 값을 누적해서 저장할 sum을 초기화
     * 2. sum에 누적된 값 출력
     * */

    /* 개선해보자!! */
    int sum = 0;

    for(int i = 1; i <= 10; i++) {
        sum += i;
    }

    System.out.println("sum : " + sum);

}
  • 실행결과
    sum : 55

  1. 반복문을 쓸 수 밖에 없게 만드는 예제 (1)

    public static void main(String[] args) {

    /* 5 ~ 10 사이의 난수를 발생시켜서
     * 1부터 발생한 난수까지의 합계를 구해보자.
     * */
    int random = (int) (Math.random() * 6) + 5;

    System.out.println("random : " + random);

    /* 뭔가 더해서 담기 위해 sum 변수를 0으로 초기화 */
    int sum = 0;

    /* 발생한 난수에 따라 더하는 숫자가 달라지기 때문에 조건문을 이용해서 처리해보자  */
    if(random == 5) {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
    } else if(random == 6) {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
        sum += 6;
    } else if(random == 7) {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
        sum += 6;
        sum += 7;
    } else if(random == 8) {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
        sum += 6;
        sum += 7;
        sum += 8;
    } else if(random == 9) {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
        sum += 6;
        sum += 7;
        sum += 8;
        sum += 9;
    } else {
        sum += 1;
        sum += 2;
        sum += 3;
        sum += 4;
        sum += 5;
        sum += 6;
        sum += 7;
        sum += 8;
        sum += 9;
        sum += 10;
    }

    System.out.println("1부터 " + random + "까지의 합은 : " + sum);
}
    • 실행코드
      random : 9
1부터 9까지의 합은 : 45

random : 5
1부터 5까지의 합은 : 15

    개선코드

    public static void main(String[] args) {
    
    int random = (int) (Math.random() * 6) + 5;
    int sum = 0;

    for(int i = 1; i <= random; i++) {
        sum += i;
    }

    System.out.println("1부터 " + random + "까지의 합은 : " + sum);
}
    • 실행결과
      random : 5
1부터 5까지의 합은 : 15

random : 6
1부터 6까지의 합은 : 21

  2. 반복문을 쓸 수 밖에 없게 만드는 예제2

    public static void main(String[] args) {

    /* 숫자 두 개를 입력 받아 작은 수 에서 큰 수까지의 합계를 구하세요
     * 단, 두 숫자는 같은 숫자를 입력하지 않는다는 가정으로 해결해본다.
     * */

    /* 정수 두 개 입력 */
    Scanner sc = new Scanner(System.in);
    System.out.print("첫 번째 정수 입력 : ");
    int first = sc.nextInt();
    System.out.print("두 번째 정수 입력 : ");
    int second = sc.nextInt();

    /* 결과를 누적해서 담을 변수를 0으로 초기화 */
    int sum = 0;

    /* 첫 뻔재 정수가 더 큰 경우 */
    if(first > second) {

        /* 둘 중 더 작은 second가 시작하는 값이 되고, 더 큰 first가 끝나는 값이 된다. */
        for(int i = second; i <= first; i++) {
            sum += i;
        }

    /* 반대로 두 번쨰 정수가 더 큰 경우 */
    } else {

        /* 둘 중 더 작은 first가 시작하는 값이 되고, 더 큰 second가 끝나는 값이 된다. */
        for(int i = first; i <= second; i++) {
            sum += i;
        }
    }

    System.out.println("sum : " + sum);

    /* 결국 작은 수 부터 시작해서 큰 수까지의 합계를 구하는 것이기 때문에
     * first와 second 중 어느 것이 더 큰 수인지를 확인하면
     * 작은수 ~ 큰수 까지의 합계를 구하는 로직으로 바꿀 수 있다.
     * */

    /* 더 큰 값과 작은 값을 저장할 변수를 초기화한다. */
    int min = 0;
    int max = 0;

    if(first > second) {

        /* 처음 입력한 숫자가 더 크게 되면 first가 max이고, 자동으로 second는 min이다. */
        max = first;
        min = second;

    /* 반대 조건인 경우 */
    } else {

        /* 처음 입력한 숫자가 더 작으면 first는 min이고, 자동으로 second는 max이다. */
        min = first;
        max = second;
    }

    /* 반복문의 시작값은 min, 종료값은 max로 해 두면 된다. */
    int sum2 = 0;

    for(int i = min; i <= max; i++) {
        sum2 += i;
    }

    System.out.println("sum2 : " + sum2);
}
    • 실행결과
      첫 번째 정수 입력 : **32**
두 번째 정수 입력 : **12**
sum : 462
sum2 : 462

  1. 중첩 반복문으로 넘어가기 전에 할 예제

    public static void main(String[] args) {

    /* 키보드로 2~9 사이의 구구단을 입력받아
     * 2~9 사이인 경우 해당 단의 구구단을 출력하고,
     * 그렇지 않은 경우 "반드시 2~9 사이의 양수를 입력해야 합니다. 출력" */

    /* 구구단은 곱하는 수가 1부터 시작해서 9까지 1씩 증가하며 곱하는 규칙을 가지고 있다.
     * 아래에서 규칙을 발견하고 규칙대로 for문을 이용하여 구구단을 출력하는 구문을 작성해보자
     * 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
     * */

    Scanner sc = new Scanner(System.in);
    System.out.print("출력할 구구단의 단 수를 입력하세요 : ");
    int dan = sc.nextInt();

    /* 입력한 숫자가 2 ~ 9 사이인지 조건 확인 */
    if(dan >= 2 && dan <= 9) {

        /* 2~9까지 입력한 경우 구구단 출력 */
        /* 먼저 작성한 후에 규칙 찾아서 개선하기 */
        //System.out.println(dan + " * " + 1 + " = " + (dan * 1));
        //System.out.println(dan + " * " + 2 + " = " + (dan * 2));
        //System.out.println(dan + " * " + 3 + " = " + (dan * 3));
        //System.out.println(dan + " * " + 4 + " = " + (dan * 4));
        //System.out.println(dan + " * " + 5 + " = " + (dan * 5));
        //System.out.println(dan + " * " + 6 + " = " + (dan * 6));
        //System.out.println(dan + " * " + 7 + " = " + (dan * 7));
        //System.out.println(dan + " * " + 8 + " = " + (dan * 8));
        //System.out.println(dan + " * " + 9 + " = " + (dan * 9));

        /* 반복문으로 변경 */
        for(int su = 1; su <= 9; su++) {
            System.out.println(dan + " * " + su + " = " + (dan * su));
        }

        /* 2~9 사이의 값이 아닌 경우 */
    } else {

        /* 2~9 사이의 값이 아닌 경우 출력할 구문 */
        System.out.println("반드시 2~9 사이의 양수를 입력해야 합니다.");
    }

    System.out.println("프로그램을 종료합니다.");
}
    • 실행결과
      출력할 구구단의 단 수를 입력하세요 : **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
프로그램을 종료합니다.

4. 중첩 for 문 활용

  1. 중첩 for문을 이용한 구구단 2단부터 9단까지 출력 (1)

    public static void main(String[] args) {

    /* for문 안에서 for문을 이용할 수 있다. */
    /* 2단부터 단을 1씩 증가시키는 반복문 */
    for(int dan = 2; dan < 10; dan++) {

        /* 단이 1개씩 증가하는 동안 수행할 내용은 해당 단의 구구단을 출력하는 것이다. */
        for(int su = 1; su < 10; su++) {

            System.out.println(dan + " * " + su + " = " + (dan * su));
        }

        /* 한 단이 출력되고 나면 한 줄을 띄운다 */
        System.out.println();
    }

}
    • 실행결과
      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 * 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 * 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 * 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 * 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 * 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 * 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 * 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. 중첩 for문을 이용한 구구단 2단부터 9단까지 출력(2) - 개선 버전

    public static void main(String[] args) {

    /* 단을 2단부터 9단까지 하나씩 증가시킨다. */
    for(int dan = 2; dan < 10; dan++) {

        /* 한 단씩 구구단을 출력하는 메소드를 호출하며 인자로 단을 전달한다. */
        printGugudanOf(dan);
        /* 한 단을 출력하고 한 줄을 띄운다. */
        System.out.println();
    }
}

public static void printGugudanOf(int dan) {

    /* 매개변수로 전달받은 단을 1 ~ 10까지 곱한 내용을 출력해준다. */
    for(int su = 1; su < 10; su++) {
        System.out.println(dan + " * " + su + " = " + (dan * su));
    }
}
    • 실행결과
      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 * 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 * 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 * 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 * 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 * 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 * 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 * 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. 키보드로 입력 받은 정수 만큼의 행만큼 별을 출력

    public static void main(String[] args) {

    /* 키보드로 출력할 행을 입력 */
    Scanner sc = new Scanner(System.in);
    System.out.print("출력할 행 수를 입력하세요 : ");
    int row = sc.nextInt();

    /* 입력한 행 만큼 반복 */
    for(int i = 1; i <= row; i++) {

        /* 별을 5개 출력하는 것을 반복 */
        //for(int j = 1; j < 6; j++) {
        //System.out.print("*");
        //}
        printStar(5);

        /* 별을 출력하고 난 뒤 줄 바꿈 */
        System.out.println();
    }
}

public static void printStar(int times) {

    for(int i = 1; i <= times; i++) {
        System.out.print("*");
    }
}
    • 실행결과
      출력할 행 수를 입력하세요 : **5**
*****
*****
*****
*****
*****

  1. 키보드로 입력 받은 정수 만큼의 행만큼 별을 삼각형 모양으로 출력

    public static void main(String[] args) {

    /* 출력할 줄 수 입력 */
    System.out.print("출력할 줄 수를 입력하세요 : ");
    Scanner sc = new Scanner(System.in);
    int row = sc.nextInt();

    for(int i = 1; i <= row; i++) {

        /* 행 수만큼만 별을 출력하는 반복문 */
        //for(int j = 1; j <= i; j++) {
        //System.out.print("*");
        //}
      
        printStar(i);
        System.out.println();
    }
}

public static void printStar(int times) {

    for(int i = 1; i <= times; i++) {
        System.out.print("*");
    }
}
    • 실행결과
      출력할 줄 수를 입력하세요 : **5**
*
**
***
****
*****

5. while 문 개요

5-1. while 문 표현식

  • for문, while문은 서로 호환이 가능하다. 따라서 어느 쪽을 선택해도 좋지만, for문은 반복 횟수를 알고 있을 때 while문은 조건에 따라 반복할 때 주로 사용한다.
    for 문 사용할 때while 문을 사용할 때
    반복 횟수를 알고 있을 때무한 루프나 특정 조건을 만족할 때까지 반복할 때
    배열과 주로 사용파일 읽기, 쓰기 시 주로 사용
  • while 문은 조건식이 true 면 반복할 구문이 계속 실행된다. 조건식에는 비교 또는 논리 연산식이 자주 온다.
    조건식이 false 가 되면 while문을 종료한다.
1-초기식;

while(2-조건식) {
		3-조건을 만족하는 경우 수행할 구문(반복할 구문);
		4-증감식;
}
  • while 문의 흐름(for문의 흐름과 동일한 것을 볼 수 있다)

  • while 문도 for문과 마찬가지로 변형해가며 테스트를 해보는 것을 추천한다.

  1. 증감식이 없는 경우

    1. 조건식이 true인 경우

    2. 초기식, 조건식, 증감식이 없는 경우

    3. 초기식, 조건식, 증감식 등을 변경하고 실행 값 예측해보기

    4. 역순으로 반복문 실행

    등등 필요에 따라 더 기본 반복문을 변형해가며 테스트 해보자

6. while 문 활용

  1. while문 연습을 위한 예제 (1)

    public static void main(String[] args) {

    /* 입력한 문자열의 인덱스를 이용하여 문자 하나씩 출력해보기 */
    /* 문자열 입력 */
    Scanner sc = new Scanner(System.in);
    System.out.print("문자열 입력 : ");
    String str = sc.nextLine();

    /* charAt() : 문자열에서 인덱스에 해당하는 문자를 char형으로 반환하는 기능 */
    /* length() : String 클래스의 메소드로 문자열의 길이를 int형으로 반환한다. */

    /* index는 0부터 시작하고 마지막 인덱스는 항상 길이보다 한 개 작은 숫자를 가진다.
     * 만약 존재하지 않는 인덱스에 접근하게되면 StringIndexOutOfBoundsException이 발생한다.!!*/
    System.out.println("========== for문 ===========");
    for(int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);

        System.out.println(i + " : " + ch);
    }

    System.out.println("========== while문 ===========");
    int index = 0;
    while(index < str.length()) {

        char ch = str.charAt(index);
        System.out.println(index + " : " + ch);

        index++;
    }
}
    • 실행결과
      문자열 입력 : **test**
========== for문 ===========
0 : t
1 : e
2 : s
3 : t
========== while문 ===========
0 : t
1 : e
2 : s
3 : t

  2. while문 연습을 위한 예제 (2)

    public static void main(String[] args) {

    /* 정수 하나를 입력 받아 1부터 입력받은 정수까지의 합계를 구한다. */
    Scanner sc = new Scanner(System.in);
    System.out.print("정수를 하나 입력하세요 : ");
    int num = sc.nextInt();

    int i = 1;
    int sum = 0;
    
    while(i <= num) {
        sum += i;
        i++;
    }

    System.out.println("1부터 입력 받은 정수 " + num + "까지의 합은 " + sum + "입니다.");

    sc.close();

}
    • 실행결과
      정수를 하나 입력하세요 : **15**
1부터 입력 받은 정수 15까지의 합은 120입니다.

  3. while문 연습을 위한 예제 (3)

    public static void main(String[] args) {

    /* 중첩 while문을 이용한 구구단 출력하기 */
    int dan = 2;
    while(dan < 10){

        int su = 1;
        while(su < 10){
            System.out.println(dan + " * " + su + " = " + (dan * su));
            su++;
        }

        System.out.println();
        dan++;
    }
    
}
    • 실행결과
      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 * 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 * 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 * 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 * 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 * 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 * 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 * 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

7. do-while 문 개요

7-1. do-while 문 표현식

  • 조건식을 확인하며 반복을 할지 안할지 판단하는 것은 while과 동일하지만 한가지 다른 점이 있다.
    do-while 문의 경우 무조건 1번은 반복할 구문을 실행한다. (while문은 조건을 확인한 후 구문이 실행된다.)
초기식;

do {
     1회차에는 무조건 실행하고, 이후에는 조건식을 확인하여 조건을 만족하는 경우 수행할 구문(반복할 구문);
     증감식;
} while(조건식);
  • do-while 문의 흐름

  • for 문, while 문과 같은 반복문이 이미 있는데 do-while은 어디에 사용할까 의문이 들 수 있다. for 문과 while 문은 “조건식”을 먼저 체크한 후 해당 조건식이 true 일 경우 특정 구문이 실행된다. 그에 비해 do-while 문은 일단 한번 실행 된 후 조건을 체크 하기 때문에 무조건 한번은 실행 되야 하는 반복문에 유리하다.

8. do-while 문 활용

  1. 단순 do-while문 실행 흐름을 확인

    public static void main(String[] args) {

    /* 반복문의 기본 흐름 테스트 */

    /* 조건을 false로 두고 실행 되는지 테스트 */
    do {

        /* 조건식의 결과와 상관 없이 최초 1번은 무조건 동작함 */
        System.out.println("최초 한 번 동작함...");
        
    } while(false);

    System.out.println("반복문 종료 확인...");

}
    • 실행결과
      최초 한 번 동작함...
반복문 종료 확인...

  2. do-while문 연습을 위한 예제 (1)

    public static void main(String[] args) {

    /* 키보드로 문자열 입력 받아 반복적으로 출력
     * 단, exit가 입력되면 반복문을 종료한다.
     * */
    Scanner sc = new Scanner(System.in);
    String str = "";

    do {

        System.out.print("문자열을 입력하세요 : ");
        str = sc.nextLine();
        System.out.println(str);

        /* equals() : 문자열은 == 비교가 불가능하다. 문자열이 같은지를 비교하는 기능을 제공하는데 뒤에서 다시 다루게 된다. */
    } while(!str.equals("exit"));

    System.out.println("프로그램을 종료합니다.");

    sc.close();
    
}
    • 실행결과
      문자열을 입력하세요 : **test**
test
문자열을 입력하세요 : **ohgiraffers**
ohgiraffers
문자열을 입력하세요 : **exit**
exit
프로그램을 종료합니다.

3. 분기문

1. 분기문 개요

1-1. 분기문이란?

💡 분기문이란 조건문 또는 반복문 안에서 실행 흐름을 바꿀 수 있는 구문이다. 우리는 이미 분기문을 접한 적이 있다. switch 문에서 `break` 라고 입력한 것도 분기문의 종류 중 하나이다.

1-2. 분기문 종류

💡 자바에서 분기문은 `break` 와 `continue` 가 있다. `break`는 조건문이나 반복문 등에서 탈출을 하는 분기문인 반면에 `continue` 는 반복문 끝으로 이동시키며 다름 반복으로 넘어가게 한다. 즉, `continue`는 반복문을 벗어나는 것이 아닌 반복을 계속 수행하며 이는 `break` 문과 큰 차이이다.

2. break 문 개요

2-1. break 문 표현식

while(조건식) { 
		...
		if(특정조건){
			break; 
		}
		...
}
  • break 문은 switch 문 또는 반복문을 빠져나올 때 사용한다.
  • break 문은 주로 if 문과 함께 사용되는데, 특정 조건을 만족하면 반복문을 빠져나오도록 도와주는 역할을 한다.

3. break 문 활용

  1. 분기문(break) 기본 흐름에 대해 테스트

    public static void main(String[] args) {

    /* break문은 반복문 내에서 사용한다.
     * 해당 반복문을 빠져 나올 때 사용하며, 반복문의 조건문 판단 결과와 상관 없이 반복문을 빠져나올 때 사용한다.
     * 일반적으로 if(조건식) { break; } 처럼 사용된다.
     * 단, switch문은 반복문이 아니지만 예외적으로 사용된다.
     * */

    /* break문을 이용하여 무란루프를 활용한 1~100까지 합계 구하기 */
    int sum = 0;
    int i = 1;

    while(true) {

        sum += i;

        /* 반복문 조건과 별개로 반복문을 빠져나오기 위한 조건을 다시 작성 */
        if(i == 100) {

            /* i가 100인 조건을 만족하는 경우 반복문을 빠져나옴 */
            break;
        }

        i++;
    }

    System.out.println("1부터 100까지의 합은 " + sum + "입니다.");

}
    • 실행결과
      1부터 100까지의 합은 5050입니다.

  2. 중첩 반복문 내에서 분기문(break)의 기본 흐름에 대해 테스트

    public static void main(String[] args) {

    /* 중첩 반복문 내에서 분기문의 흐름 */
    /* break는 모든 반복문을 종료하는 것이 아닌, 자신에게 가장 인접한 반복문 실행만 멈춘다. */

    /* 구구단 2~9단까지 출력
     * 단 각 단의 수가 5보다 큰 경우는 출력을 생략한다.
     * */

    for(int dan = 2; dan < 10; dan++) {

        /* 여기까지만 빠져나옴 */
        for(int su = 1; su < 10; su++) {

            if(su > 5) {
                /* su가 5보다 큰 경우 해당 반복문을 빠져나온다. */
                break;
            }

            /* 반복문을 빠져나오지 않는 경우 구구단을 출력 */
            System.out.println(dan + " * " + su + " = " + (dan * su));
        }

        System.out.println();
    }

}
    • 실행결과
      2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10

3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15

4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25

6 * 1 = 6
6 * 2 = 12
6 * 3 = 18
6 * 4 = 24
6 * 5 = 30

7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35

8 * 1 = 8
8 * 2 = 16
8 * 3 = 24
8 * 4 = 32
8 * 5 = 40

9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45

종료 코드 0(으)로 완료된 프로세스

  1. 중첩 반복문 내에서 분기문(break)를 이용하여 한 번에 여러 개의 반복문 중지시키기

    public static void main(String[] args) {

    /* 이름을 부여하기 전과 후 비교해보기 */
    label:

    for(;;){
        for(int i = 0; i < 10; i++){
            System.out.println(i);
            if(i == 3){
                break label;
            }
        }
    }

}
    • 실행결과
      ======== label: 주석할 시
0
1
2
3
0
1
2
3
0
1
2
....

======== label: 주석 안할 시
0
1
2
3

4. continue 문 개요

4-1. continue 문 표현식

for(초기식;조건식;증감식) { 
		...
		if(특정조건){
			continue; 
		}
		...
}
  • continue 문은 해당 반복 회차의 끝으로 이동시켜 증감식을 실행시키게 한 후 다음 반복으로 넘어가게 해준다.
  • 보통 반복문 내에서 특정 조건에 대해 예외를 처리하고자 할 때 사용한다.

5. continue 문 활용

  1. 분기문(continue) 기본 흐름에 대해 테스트

    public static void main(String[] args) {

    /* 1부터 100 사이의 4의 배수이면서 5의 배수인 값 출력 */
    for(int i = 1; i <= 100; i++) {

        if(i % 4 == 0 && i % 5 == 0) {

            /* i값이 4와 5의 공배수 인 경우 i값 출력 */
            System.out.println(i);
        } else {

            /* 공배수가 아닌 경우 증감식으로 넘어감 */
            continue;
        }
    }

}
    • 실행결과
      20
40
60
80
100

  2. 중첩 반복문 내에서 분기문(continue)의 기본 흐름에 대해 테스트

    public static void main(String[] args) {

    /* 중첩 반복문 내에서 분기문의 흐름 */
    /* continue는 모든 반복문을 건너 뛰는 것이 아닌, 자신에게 가장 인접한 반복문 실행만 건너뛴다. */

    /* 구구단 2~9단까지 출력
     * 단 각 단의 수가 짝수인 경우 출력을 생략한다.
     * */
    for(int dan = 2; dan < 10; dan++){

        /* 여기까지 빠져나옴 */
        for(int su = 1; su < 10; su++){
            if(su % 2 == 0){

                /* su가 짝수인 경우 해당 회차 반복 내용을 건너 뛰고 증감식으로 이동 */
                continue;
            }
            System.out.println(dan + " * " + su + " = " + dan * su);
        }
        System.out.println();
    }
    
}
    • 실행결과
      2 * 1 = 2
2 * 3 = 6
2 * 5 = 10
2 * 7 = 14
2 * 9 = 18

3 * 1 = 3
3 * 3 = 9
3 * 5 = 15
3 * 7 = 21
3 * 9 = 27

4 * 1 = 4
4 * 3 = 12
4 * 5 = 20
4 * 7 = 28
4 * 9 = 36

5 * 1 = 5
5 * 3 = 15
5 * 5 = 25
5 * 7 = 35
5 * 9 = 45

6 * 1 = 6
6 * 3 = 18
6 * 5 = 30
6 * 7 = 42
6 * 9 = 54

7 * 1 = 7
7 * 3 = 21
7 * 5 = 35
7 * 7 = 49
7 * 9 = 63

8 * 1 = 8
8 * 3 = 24
8 * 5 = 40
8 * 7 = 56
8 * 9 = 72

9 * 1 = 9
9 * 3 = 27
9 * 5 = 45
9 * 7 = 63
9 * 9 = 81

  3. 중첩 반복문 내에서 분기문(continue)를 이용하여 한 번에 여러 개의 반복문 건너뛰기

    public static void main(String[] args) {

    /* 한 번에 모든 반복문의 반복회차를 건너뛰기 테스트 */
    label:
    for(int dan = 2; dan < 10; dan++){

				/* 해당 반복문을 빠져나옴 */
        for(int su = 1; su < 10; su++){
            if(su % 2 == 0){

                /* su가 짝수인 경우 해당 회차 반복 내용을 건너 뛰고 이름이 부여된 증감식으로 이동 */
                continue label;
            }

            System.out.println(dan + " * " + su + " = " + dan * su);
        }

        System.out.println();
    }

}
    • 실행결과
      2 * 1 = 2
3 * 1 = 3
4 * 1 = 4
5 * 1 = 5
6 * 1 = 6
7 * 1 = 7
8 * 1 = 8
9 * 1 = 9
profile
kailyn
나는 할 수 있다...!
이전 포스트

메소드와 API

다음 포스트

배열

0개의 댓글