KH 06일차 - 조건문과 반복문

1.    조건문 ( switch 문 )

-      변수나 연산식의 값에 따라 실행문 선택할 때 사용

-      Switch(변수) { }

-      변수와 값이 같을 때 수행되는 실행문을 결정시킬 수 있다.

 

2.    반복문 ( for문 , while문 , do-while문 )

-      중괄호 { } 블록 내용을 반복적으로 실행할 때 사용한다.

-      종류 : for 문, while 문, do – while문

-      1. For문 : 반복 횟수를 알고 있을 때 주로 사용한다.

-      For( 초기식; 조건식; 증감식 ) { 실행문 }

-      초기식은 int number = 10;에서 초기값을 생성하는 것과 비슷하게 식을 정의하는 것이다.

-      조건식은 if( )안에 있는 조건식과 비슷하게 참과 거짓을 판단하는 식이다.

-      참일 경우 중괄호 블록 { } 안에 있는 실행문을 반복해서 실행시키고, 거짓이 될 때 빠져나오게 된다.

-      순서 : 초기식 -> 조건식 -> 실행문 -> 증감식 -> 조건식 -> - - -

-      2. While문 : 조건식이 true일때동안 반복되게 된다.

-      While ( 조건식 ) { 실행문; }

-      for문과 while문은 모두 초기식, 조건식, 증감식이 있기에 서로 호환이 가능하다!

-      Do- while 문 : 무조건 1번은 실행시키고 2번째부터 실행시킬지 말지 결정할 때 사용한다.

-      Do { 실행문; } while ( 조건식 );

-      Do-while문에서는 ( 조건식 )뒤에 꼭 ‘ ; ‘를 붙어야 한다.

-      3. Break문 : 반복문을 끝내기 위해서 사용하게 된다.

-      4. Continue문 : for문에서는 증감식으로, while문과 do-while문에서는 조건식으로 이동시킬 때 사용한다.

-      Ex) 홀수일때는 출력실행문으로 가기 전에 증감식으로 이동시켜버리고 짝수일때는 출력실행문으로 갈 수 있도록 해줄 때 사용한다.

 

---

01. Swith 문

 

public class Sample43 {

     

      public static void main (String[] args) {

           

            int num = (int)(Math.random()*6) +1;

           

            switch(num) {

           

            case 1: // num의 값이 1이라면

                  System.out.println("1번이 나왔습니다.");

                  break; // 값이 일치하면 switch를 끝내라!라는 의미이다.

            case 2:  // num의 값이 2이라면

                  System.out.println("2번이 나왔습니다.");

                  break;

            case 3:  // num의 값이 3이라면

                  System.out.println("3번이 나왔습니다.");

                  break;

            case 4:  // num의 값이 4이라면

                  System.out.println("4번이 나왔습니다.");

                  break;

            case 5:  // num의 값이 5이라면

                  System.out.println("5번이 나왔습니다.");

                  break;

                  default :  // num의 값이 위의 값과 일치하지 않는다면 이것을 실행시켜라

                        System.out.println("6번이 나왔습니다.");

                  //    break; // default문에는 break를 사용하지 않는다. (**)

                  // default를 switch문 가장 앞에 사용하게 되면, break문을 사용해야 한다.

                  // ----> break문을 사용하지 않으면 switch블록이 깨지지 않은채 다른 break문을 만날때까지 밑의 실행문이 사용될 수 있으므로

                  // ----> break문의 위치를 옮기고 싶을 때에는 break문을 사용하는 것이 오류를 줄일 수 있다.

                  // ----> 참고로 default문의 위치 자체를 옮기는 것은 가능하다.

           

            } //switch문

            // default 대신 case 6: 라고 해도 괜찮다.

            // default는 필수가 아니다.

            // case 1 뒤에는 :를 사용햐야 한다. (*****)

            // default 뒤에도 : 를 사용해야 한다. (****)

            // switch문은 break를 만날때까지 그냥 쭉 밀고 실행되어버리기 때문에 break;문을 꼭 써야한다!!(******)

           

      } // main

 

} // end class

 

02. Swith 문의 응용

 

public class Sample44 {

     

      public static void main(String[] args) {

           

            char grade = 'B'; // 66

            //switch문은 문자도 사용이 가능하다.

           

            switch (grade) {

           

            case 'A':

            case 'a':

                  System.out.println("우수회원입니다.");

                  break;

                 

            case 'B':

            case 'b':

                  System.out.println("일반회원입니다.");

                  break; // 대문자 B이든 소문자 b이든 실행시키는 것은 같기에 break;문을 각각 사용하기 보다는 같이 사용하였다.

                 

            default :

                  System.out.println("손님입니다.");

           

            }// switch

           

      } // main

 

} //end class

 

03. Swith 문이 가능한 타입

 

public class Sample45 {

     

      public static void main (String [] args) {

           

            String position = "과장";

           

            // switch문은 정수, 문자, 문자열 모두 사용이 가능하다.

            // 하지만 실수는 불가능! 하다!

           

            switch(position) {

            case "부장" :

                  System.out.println("700만원");

                  break;

                 

            case "과장" :

                  System.out.println("500만원"); // ----> 시행된다.

                  break;

                 

                  default :

                        System.out.println("300만원");

                       

            } // switch

           

      } // main

 

} // end class

 

04. Swith 문이 가능한 타입2 - 실수는 0.1로 인해 불가능하다.

 

public class Sample46 {

     

      public static void main (String[] args) {

           

            double number = 3.14;

           

            // switch문은 실수 시행이 불가능하다!

           

            // switch (number) { // <------ 컴파일 오류가 발생한다.

           

            // case 0.1:

                  // System.out.println("0.1");

                  // break;

                 

            // case 0.3:

                  // System.out.println("0.3");

                  // break;

                 

            // case 0.9:

                  // System.out.println("0.9");

                  // break;

                 

                  // default:

                        // System.out.println(number);

           

            // } // switch문

           

      } // main

 

} //end class

 

05. Swith Expression 문

 

public class Sample47 {

     

      public static void main (String[] args) {

           

            // Java 12 : Switch Expression이 새로 생겼다.

            // 1. 새로운 switch문은 더 간결하고 읽고 쉽습니다.

            // 2. 또한 break문에 대한 필요성을 제거합니다.

            // 3. 코드 실행은 첫번째 일치 이후에 이루어지지 않습니다.

            // 4. 또 다른 주목할만한 차이점은 switch문을 변수에 직접 할당할 수 있다는 것입니다.

            // 5. 값을 반환하지 않고 스위치 표현삭에서 코드를 실핼 할 수도 있습니다.

            // 6. 이전 구문과 새구문 중에서 선택해서 사용할 수 있습니다.

            // switch문과 switch expression은 다른 것이다.

           

            int number = 7;

           

            switch(number) {

           

            case 7 -> { // switch Expression에서는 case : 에서 case ->로 변경이 되었다. (****)

                 

                  System.out.println("7");

                 

                  // break; 문이 없다는 것을 알 수 있다. (***)

                  // break; 자동으로 시행된다.

                  // {}를 사용하면 단순히 값을 되돌려주는 것이 아니라 실행문을 실행시킬 수 있다.

                  // {}가 중요하다!! (***)

                  // 값을 되돌려 줄때에는 case 1 -> 100;

                  // 실행문을 넣고 싶을 때에는 case 1 -> { } 으로 활용하는 것 같다.

                 

            } // case 7

           

            case 6 -> {

                 

                  System.out.println("6");

                 

            } // case 6

           

            } // switch

           

      } // main

 

} // end class

 

06. Swith Expression 문 - 2

 

public class Sample48 {

     

      public static void main(String[] args) {

           

            // JAVA : Switch Expression - 2

           

            int number = 1;

           

            int result = switch(number) {

           

            case 1 -> 100; // case 1 // <---- 값을 되돌려주는 switch문

           

            case 2 -> 1+2+3; // case2

           

            case 3 -> number;

           

            // case 4 -> true; // 이 경우에는 블린 타입이기에 타입이 일치하지 않아 오류가 뜬다.

           

            // case 5 -> {          ;;    }  // <---- 오류 발생 : 복잡한 로직을 수행시키는 것은 불가능 하다.

            // switch는 단순한 값을 되돌려 줄 때 사용하는 것이다.

           

            default -> 0; // case3

           

            // 값을 생성하는 expression으로 사용할 때는 실행문과 달리 뒤어 " ; "을 붙어야 한다.

            // 타입을 일치하게 코드를 작성해야 한다.

            // switch expression에서는 이제 break;문이 자동으로 시행되기에 default 위치는 자유롭게 움직여도 괜찮다.

           

            }; // switch // int result를 정의하는 중이기에 ;을 붙어야 한다.

           

            System.out.println(result); // <----- number이 1에 해당되는 case1에서 100이라는 값을 되돌려주고 있기에

            // 100이 출력되게 된다.

            // {} 는 절대 생략하지 말아라!!

           

      } // main

 

} // end class

 

07. For 문

 

public class Sample49 {

     

      public static void main (String[] args) {

           

            // 반복문 - for 문

            // 1+2+3+4+5+6+7+8+9+10 = ?

           

            // 1. 초기식 : 변수를 정의 ( 단 1번만 수행! )

            // 2. 조건식 : for block을 반복수행할지, 말지를 결정

            // 3. 증감식 : 1에서 정의한 변수의 값을 변경

           

            int i; //(2) 그러나 int i를 main에서 선언함으로써 유효범위를 main으로 변경하게 되었다.

            //  i는 카운터 변수/ 루프제어변수라고 부르는데 (***)

            // i가 몇 번 반복할 지 정해주기 때문이다. (***)

           

            // 원래는 for ( int i = 1; i <=10; i++) { }였다.

            for ( i = 1; i<=10; i++) {

                  // 초기식은 정의를 위에서 미리 했을시에는 ( )내에서 생략이 가능하다. (**)

                  // 생략하더라도 ; 는 남겨둬야 한다. (***)

                  // 증감식도 어디에선가 기능만 잘 한다면, ( )에 꼭 넣을 필요는 없다. 생략이 가능하다.

                  // 증감식을 { } 블록 내에 넣을 수도 있다.

                  // 조건식도 { } 블록 내에 넣음으로써 ( ) 내에서 생략이 가능하지만 ; 는 꼭 남겨둬야 한다.

                  // 단 3개 모두 생략하게 될 시에는 JAVA에서는 무한루프로 결정해 버린다.

                  // 그렇기에 if -else와 break;를 활용해야 한다.

                 

                  System.out.println(i);  // 참이면 i를 출력해라!

                  // i가 11이 되어 거짓이 될 때에는 for문이 끝나버리게 된다.

                 

            } // for문

           

            // (1) System.out.println(i);  <-- 컴파일 오류가 발생한다.

            // i의 유효범위가 for 블록 내에서만 가능한 지역변수이기 때문이다.

            // i의 유효범위가 main으로 변경되었기에

           

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

            // (3) for문이 끝난 후의 i의 값을 알수 있다.

           

            // for ( ; ; ) { } 생략 버젼

            int i1 = 1;

            for ( ; ; ) { // 이렇게만 실행하면 무한루프로 되어버린다.

                 

                  if(i1<=10) { // 탈출조건이 꼭 필요하다!!

                        System.out.println(i1);

                  } else {

                       

                        // for문을 깨트려버려라!, for문을 끝내버려라!!

                       

                        break;

                       

                  }//if - else

                 

                  i1++;

            }

           

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

           

            // 이렇게 되면 코드가 꼬일 수 있으니, 그냥 for ( 초기식; 조건식; 증감식 ) {}의 형태로 활용하는 것이 좋다.

           

      } // main

 

} // end class

 

08. For 문 - 실수타입(X)

 

public class Sample50 {

     

      public static void main (String[] args) {

           

            for( float x = 0.1f; x<=1.0f; x+=0.1f ) {

                  System.out.println(x);

                  // 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.70000005, 0.8000001, 0.9000001가 출력 됨

                  // Why? 0.1의 경우에는 0.1 자체는 잘 찍히지만 0.1을 가지고 곱하거나 더하면 결과가 근사치로 출력이 되어 버린다.

                  // 그렇기에 for문에서는 "실수"를 카운터변수로 사용하지 않는다!!(***)

                  // float, double타입 모두 실수타입이기에 카운터변수로 사용하지 않는다!!!

                  // 즉, 정수를 카운터 변수의 값으로 사용해야 된다!!(***)

                 

            } // for문

           

      } // main

 

} // end class

 

09. While 문

 

public class Sample51 {

     

      public static void main (String[] args) {

           

            int i = 1; // 카운터 변수 // (1) 초기식 : 카운터의 변수 정의

           

            while ( i <= 10 ) { // (2) 조건식 : 조건식 평가

                 

                  System.out.println(i);

                 

                  i++; // (3) 증감식

                 

            } // while문

           

      } // main

 

} // end class

 

10. Swith 문 응용

 

public class Sample52 {

     

      public static void main (String[] ags) {

           

            int sum = 0;

            int i = 1;

           

            while (i<=100) {

                 

                  sum += i; // 복합대입연산자

                  // sum = sum + i

                 

                  i++;

                 

            } // while

           

            System.out.println("1~"+(i-1)+"합 : " + sum);

           

            // i-1을 하는 이유는 i의 값이 거짓으로 나올때는 101이 될뿐만이 아니라 그때에는 sum에 더해지지 않기 때문이다.

            // 그렇기 때문에 i-1을 함으로써 참일때의 범위와 더해진 값을 구해주는 것이다.

           

      } // main

 

} // end class

 

11. Scanner

 

import java.util.Scanner;

 

// Source - Organize import를 클릭하면 뜨게 된다.

 

public class Sample53 { // do - while문 ( Scanner ******)

     

      public static void main (String[] args) {

           

            System.out.println("메세지를 입력하세요.");

            System.out.println("프로그램을 종료하려면 q를 입력하세요.");

           

            String inputString; // 변수의 목적 : 사용자의 입력 문자열을 저장하는 용도

           

            // 키보드로부터, 입력데이터를 받고자 할때, Scanner라는 것을 사용한다.

            // 콘솔창에서 입력할 수 있게 해준다.

           

            // 콘솔창에 입력하게 되면 아래의 내용이 출력되고 입력할 수 있다.

            // 프로그램을 종료하려면 q를 입력하세요.

            // > 메세지1 // 내가 입력 + 엔터

            //  메세지1

            // > 안뇽 // 내가 입력 + 엔터

            //  안뇽

            // >q // 내가 입력 + 엔터

            // q

 

            // 프로그램 종료

           

            Scanner scanner = new Scanner(System.in); // 외워야 한다!! (********)

            // Scanner 객체명 = new Scanner(System.in); // 이것을 외워야 한다. (*******)

           

            do {

                  System.out.print(">"); // '>' 입력위치를 알려주는 기호 : 이를 'prompt'라고 한다.

                 

                  // 사용자가 입력한 문자열을 마치 스캐너가 스캐닝해서 이미지를 만들어 주듯이

                  // 문지열로 만들어 되돌려 주는 문장

                  inputString = scanner.nextLine(); // 변수의 초기화 // 외워야 한다!! (********)

                  // Scanner는 사용자가 무엇을 입력하기 전까지는 대기상태로 만든다.

                  // enter을 누르기 전까진 대기

                 

                  System.out.println(inputString); // 사용자가 입력한 문자열 출력

                 

            } while (!inputString.equals("q")); // 변수의 값이 문자열 'q'이면 true

            // 참이면 다시 실행하게 된다. ---> q가 될때까지 계속 실행하게 된다.

           

            System.out.println();

            System.out.println("프로그램 종료");

           

      } // main

     

      // ""처럼 공백도 없는 문자열을 비어있는 문자열이라고 한다.

 

} // end class

 

12. While 문 응용 - if문

 

public class Sample54 { // break 문 예제

     

      // 무작위 정수를 생성했을 때, 만일 6이 나오면, 무한루프를 빠져나가는 예제

      // 무한루프(반복문)을 빠져나가기 위해, break문 사용!

     

      public static void main (String[] args) throws Exception {

           

            // 무한루프를 만들면, 반드시 "탈출조건"을 생각해라!!

            while(true) { // 무한루프 : 조건이 (true)를 넣었기에 항상 참이기 때문에, 무한으로 반복 수행

                  // for ( ; ; ) {} 도 무한루프이다.

                 

                  int num = (int)(Math.random()*6) +1; // 1~6 사이의 무작위 정수 생성

                  System.out.println(num);

                 

                  //탈출조건

                  if(num == 6) { // 만일, 무작위 정수가 6이라면....

                       

                        break; // while 반복문을 "깨트려라!" break -> 반복 종료!

                             

                   } //if

                 

            } // while

           

             System.out.println("프로그램 종료");

           

      } // main

 

} // end class

 

13. For 문 - 중첩사용

 

public class Sample55 {

     

      public static void main(String[] args) throws Exception{

           

            Outter: for (char upper = 'A'; upper <= 'Z' ; upper++) {

                 

                  for(char lower = 'a'; lower <= 'z' ; lower ++ ) {

                       

                        System.out.println( upper + "-" + lower);

                       

                        if(lower == 'g') {

                             

                              break Outter;

                              // break;만이라고 치면 밖에 있는 for까지 깨트릴 수 없기에 밖의 for에 Outter이라는 스티커를 붙임으로써

                              // 한 번에 깨트릴 수 있게 코딩한 것이다.

                              // 스티커(라벨)의 이름은 마음대로 붙여도 괜찮다.

                             

                        } // if

                       

                  } // for 속 for

                 

            } // for

           

            System.out.println("프로그램 실행종료!");

           

            // A-a

            // A-b

            // A-c

            // A-d

            // A-e

            // A-f

            // A-g

            // 프로그램 실행종료!

            // 이라고 출력된다.

           

      } // main

 

} // end class

 

14. For 문 - 구구단

 

public class Sample56 { // 구구단

     

      public static void main(String[] args) {

           

            int dansu = 2; // 구구단의 단수를 저장

           

            Outter : for( ; dansu <= 9 ; dansu++ ) { // 단수를 반복하는 반복문 ( 2-9단까지 )

                 

                  // System.out.println(dansu);

                 

                  System.out.println(dansu + "단");

                 

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

                       

                        // System.out.println("\t"+i);   // "\t"를 치게 되면 tab키를 누른 것처럼 들여쓰기가 되어 나온다.

                       

                        System.out.println("\t" + dansu + "x" + i + "=" + (dansu*i));

                       

                        // 출력 결과는 아래처럼 나오게 된다. ( 3-9단은 생략함 )

                        // 2단

                        // 2x1=2

                        // 2x2=4

                        // 2x3=6

                        // 2x4=8

                        // 2x5=10

                        // 2x6=12

                        // 2x7=14

                        // 2x8=16

                        // 2x9=18

                       

                        if ((dansu==9)&(i==7)) {

                             

                              break Outter; // Outter까지 끝내버려라!!

                              // (dansu*i)==63 도 가능하기는 하지만 9*7뿐만이 아니라 7*9또한 63의 결과값이 나올 수 있으므로

                              // (dansu==9)&(i==7) 이라고 조건을 주거나 (dansu*i==63)&(dansu==9)라는 형식으로 특정지어줘야 한다.

                             

                        } // 9*7에서 끝내기 위한 if

                             

                  } // inner - for

                 

            } // outer - for

           

      } // main

 

} // end class

 

15. 과제 2 - 1

 

public class Sample57 { // 대면 - 2조

     

      public static void main (String[] args) { // 과제 2 - v.1

           

            //1. 여러분이 길을 걸어가다가, 동굴에 빠졌습니다.

            //2. 동굴의 깊이는 100미터입니다.

            //3. 하루동안 열심히 올라가면 20미터를 올라갑니다.

            //4. 자는 동안에는 5미터를 다시 미끄러져 내려갑니다.

           

            // 과제 : 과연 동굴에서 빠져나오기 위해서는, 몇 일이 걸릴까요?

           

            // 기준값 : 동굴 100미터, 하루동안 올라가는 20미터, 미끄러져 내려가는 5미터

            // 주의 : 몇일에 걸쳐 올라갔는데, 내가 동굴에서 빠져 나왔는지, 아닌지를 언제 판단해야 하느냐?

            // 주의2 : 만일 딱 100미터 올라왔다고 합시다! 그러면, 이거리를 동굴을 빠져나왔다고 생각할 수 있느냐?        

            // 101미터 부터

           

            // 낮에 파악한다면 낮과 밤을 구분해야 하는건가..?

           

            final int climb = 20;

            final int slide = -5;

            final int cave = -100;

            int move = 0;

            int days = 0;

           

            while( ( cave + move ) <= 0 ) {  // 실행문

                 

                  move += climb;

                  days++;

                 

                  System.out.println("현재 올라온 거리 : "+move + "m"); // 낮에 올라간 후의 현재 거리 확인

                 

                  if(( cave + move ) <= 0 ) {

                        move += slide;

                        System.out.println("미끄러지고 난 후의 거리 : "+move + "m"); // 밤에 미끄러진 현재 거리 확인

                  } // if - 밤

                             

                  System.out.println("날짜 : "+ days + "일"); // 오늘의 날짜 확인

                 

             } // while - 낮 - 밤

           

            System.out.println("탈출입니다!");

            System.out.println("동굴에서 빠져나오는데 걸린 날짜는 총 " + days + "일 입니다."); // 총 몇일 걸렸는지 확인

           

      } // main

 

 

} // end class

 

16. 과제 2 - 2

 

public class Sample58 {

     

      public static void main (String[] args) {  // 과제 2 - v.2

           

            //1. 여러분이 길을 걸어가다가, 동굴에 빠졌습니다.

            //2. 동굴의 깊이는 100미터입니다.

            //3. 하루동안 열심히 올라가면 20미터를 올라갑니다.

            //4. 자는 동안에는 5미터를 다시 미끄러져 내려갑니다.

           

            // 과제 : 과연 동굴에서 빠져나오기 위해서는, 몇 일이 걸릴까요?

           

            // 기준값 : 동굴 100미터, 하루동안 올라가는 20미터, 미끄러져 내려가는 5미터

            // 주의 : 몇일에 걸쳐 올라갔는데, 내가 동굴에서 빠져 나왔는지, 아닌지를 언제 판단해야 하느냐?

            // 주의2 : 만일 딱 100미터 올라왔다고 합시다! 그러면, 이거리를 동굴을 빠져나왔다고 생각할 수 있느냐?        

            // 101미터 부터

           

            // 낮에 파악한다면 낮과 밤을 구분해야 하는건가..?

           

            int move = 0;

            int days = 0;

           

            while( move<=100 ) {

                 

                  move += 20;

                  days++;

                  System.out.println(days + "일차에 올라온 거리 : " + move + "m");

                  move -=5;

 

                 

            } // while

           

            System.out.println("탈출 : " + days + "일");

           

      } // main

 

 

} // end class