009. if, if~else문 실습 , Switch 문 + 실습

2023.02.06 (월)

if , if~ else문 실습

• Test033
  - if문
  - if ~ else 문 실습
  - 0, 홀수, 짝수 판별

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 홀수, 짝수 → 판별 → 단일 if 문 구성

// 홀수, 짝수, 영 → 판별 → if 문 중첩

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test033
{
	public static void main(String [] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n;

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		String result = "판정불가";

		if (n==0)
			result = "영";
		else if (n%2==0)
			result = "짝수";
		else if (n%2!=0)
			result = "홀수";
		/*
		else                          // result 값이 초기화 되어있기 때문에 괜찮음.
			result = "판정불가";      // 단, result 값이 초기화 되어있지 않다면 
		*/                            // else구문 생략시 컴파일 에러 발생

		System.out.println(">> " + n + "은(는) " + result + "입니다.");
	}
}

// 실행 결과

/*
임의의 정수 입력 : 0
>> 0은(는) 영입니다.
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 1
>> 1은(는) 홀수입니다.
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 2
>> 2은(는) 짝수입니다.
계속하려면 아무 키나 누르십시오 . . .
*/

※ 조건문 작성시에는 선행 조건을 잘 파악하는 것이 중요하다.

---

• Test034
  - if문
  - if ~ else 문 실습
  - 2의 배수 / 3의 배수 / 2와 3의 배수 / 2와 3의 배수 아님 판별

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 사용자로부터 임의의 정수를 입력받아
// 다음과 같은 판별 결과를 출력하는 프로그램을 구현한다

// 2의 배수 / 3의 배수 / 2와 3의 배수 / 2와 3의 배수 아님

// 실행 예
// 임의의 정수 입력 : 4
// 4 → 2의 배수
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력 : 9
// 9 → 3의 배수
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력 : 12
// 12 → 2와 3의 배수
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력 : 17
// 17 → 2와 3의 배수 아님
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test034
{
	public static void main(String[] args) throws IOException
	{
		// 주요 변수 선언
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n;

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		//결과 출력
		if (n%2==0 && n%3==0)
		{
			System.out.println(n + " → 2와 3의 배수");
		}
		else if (n%2==0)
		{
			System.out.println(n + " → 2의 배수");
		}
		else if (n%3==0)
		{
			System.out.println(n + " → 3의 배수");
		}
		/*
		else
		{
			System.out.println(n + " → 2와 3의 배수 아님");
		}
		*/
		else if (n%2!=0 && n%3!=0)		//  긍정 && 긍정 → 부정 || 부정
		{								//	부정 && 부정 → 긍정 || 긍정
			System.out.println(n + " → 2와 3의 배수 아님");
		}
		else
		{
			System.out.println(n + " → 판정 불가");
		}

	}
}

//실행 결과

/*
임의의 정수 입력 : 54
54 → 2와 3의 배수
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 27
27 → 3의 배수
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 88
88 → 2의 배수
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 67
67 → 2와 3의 배수 아님
계속하려면 아무 키나 누르십시오 . . .
*/

※ 가급적이면 else 로 마지막 구문을 닫기 보다는
    앞 수식의 부정을 통해서 "판정불가" 등의 수식을 걸어두고
    추가적인 예상 외의 로직이 나올 것을 산정하여 명확하게 걸어주는 편이 좋다. 

---

• Test035
  - if문
  - if ~ else 문 실습
  - 윤년/평년 판별 

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 사용자로부터 임의의 연도를 입력받아
// 입력받은 연도가... 윤년인지 평년인지 판별하여
// 그 결과를 출력하는 프로그램을 구현한다.
// 단, 입력은 BufferedReader 를 활용하고,
// if 조건문을 활용하여 연산을 수행할 수 있도록 한다.

// 실행 예)
// 임의의 연도 입력 : 2023
// 2023년 → 평년
// 계속하려면 아무 키나 누르세요...

// 임의의 연도 입력 : 2024
// 2023년 → 윤년
// 계속하려면 아무 키나 누르세요...

// 임의의 연도 입력 : 2000
// 2023년 → 윤년
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test035
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int nYear; //임의의 연도
		String res; //결과 값

		System.out.print("임의의 연도 입력 : ");
		nYear = Integer.parseInt(br.readLine());

		if (nYear%400==0)
		{
			res = "윤년";
		}
		else if (nYear%100==0)
		{
			res = "평년";
		}
		else if (nYear%4==0)
		{
			res = "윤년";
		}
		else
		{
			res = "평년";
		}
		// 위의 식을 줄여쓰면 아래와 같다.
		/*
		if (nYear%400==0 && nYear%100!=0 && nYear%4==0)
		{
			res = "윤년";
		}
		else 
		{
			res = "평년";
		}
		*/

		System.out.printf("%d년 → %s\n", nYear, res);

	}
}

// 실행 결과

/*
임의의 연도 입력 : 2024
2024년 → 윤년
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 연도 입력 : 2200
2200년 → 평년
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 연도 입력 : 2400
2400년 → 윤년
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 연도 입력 : 2023
2023년 → 평년
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test036
  - if문
  - if ~ else 문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 사용자로부터 임의의 두 정수와 연산자를 입력받아
// 해당 연산자의 연산 처리 결과를 출력하는 프로그램을 구현한다.
// 단, if 조건문을 활용하여 처리할 수 있도록 하며,
// 연산 결과는 편의상 정수 기반으로 처리될 수 있도록 한다.

// 실행 예)
// 첫 번째 정수 입력	: 10
// 두 번째 정수 입력	: 3
// 연산자 입력[+ - * /]	: +

// >> 10 + 3 = 13
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test036
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("첫 번째 정수 입력 : ");
		int n1 = Integer.parseInt(br.readLine());

		System.out.print("두 번째 정수 입력 : ");
		int n2 = Integer.parseInt(br.readLine());

		System.out.print("연산자 입력[+ - * /] : ");
		char op = (char)System.in.read();

		if (op=='+')
			System.out.printf("\n>> %d + %d = %d\n", n1, n2, n1+n2);
		else if (op=='-')
			System.out.printf("\n>> %d - %d = %d\n", n1, n2, n1-n2);
		else if (op=='*')
			System.out.printf("\n>> %d * %d = %d\n", n1, n2, n1*n2);
		else if (op=='/')
			System.out.printf("\n>> %d / %d = %d\n", n1, n2, n1/n2);
		else
			System.out.printf("\n오류입니다.\n");

	}
}

// 실행결과

/*
첫 번째 정수 입력 : 5
두 번째 정수 입력 : 4
연산자 입력[+ - * /] : +

>> 5 + 4 = 9
*/
/*
첫 번째 정수 입력 : 4
두 번째 정수 입력 : 8
연산자 입력[+ - * /] : -

>> 4 - 8 = -4
*/
/*
첫 번째 정수 입력 : 65
두 번째 정수 입력 : 18
연산자 입력[+ - * /] : *

>> 65 * 18 = 1170
*/
/*
첫 번째 정수 입력 : 95
두 번째 정수 입력 : 5
연산자 입력[+ - * /] : /

>> 95 / 5 = 19
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test037
  - if문
  - if ~ else 문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 사용자로부터 임의의 정수 세 개를 입력받아
// 작은 수에서 큰 수 순으로 출력하는 프로그램을 구현한다.

// 실행 예)
// 첫 번째 정수 입력 : 753
// 두 번째 정수 입력 : 42
// 세 번째 정수 입력 : 125

// >> 처리 결과 : 42 125 753
// 계속하려면 아무 키나 누르세요...

// 실행 예)
// 첫 번째 정수 입력 : 45
// 두 번째 정수 입력 : 13
// 세 번째 정수 입력 : 45

// >> 처리 결과 : 13 45 45
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test037
{
	public static void main(String[] args) throws IOException
	{		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int a,b,c;		// 사용자가 입력하는 임의의 정수를 담아둘 변수

		int temp;
		
		System.out.print("첫 번째 정수 입력 : ");
		a = Integer.parseInt(br.readLine());
		System.out.print("두 번째 정수 입력 : ");
		b = Integer.parseInt(br.readLine());
		System.out.print("세 번째 정수 입력 : ");
		c = Integer.parseInt(br.readLine());


		if (a > b)		 // ① 첫 번째 정수 vs. 두 번째 정수 크기 비교
		{ 
			// 자리 바꿈 (a 와 b)
			a=a^b;
			b=b^a;
			a=a^b;
		} 
		if (a > c)		// ② 첫 번째 정수 vs. 세 번째 정수 크기 비교

		{
			// 자리 바꿈 (a 와 c)
			a=a^c;
			c=c^a;
			a=a^c;
		}
		if (b > c)		// ③ 두 번째 정수 vs. 세 번째 정수 크기비교
		{
			// 자리 바꿈 (b 와 c)
			b=b^c;
			c=c^b;
			b=b^c;
		}
		
		//최종 결과 출력
		System.out.printf("\n>> 처리 결과 : %d %d %d\n", a, b, c);
	}
}

// 실행 결과

/*
첫 번째 정수 입력 : 1358
두 번째 정수 입력 : 21345
세 번째 정수 입력 : 5123

>> 처리 결과 : 1358 5123 21345
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test038
  - if문
  - if ~ else 문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - if문
	   - if ~ else 문 실습
=================================================*/

// 사용자로부터 임의의 정수 5개를 입력받아
// 짝수별, 홀수별 합계를 출력하는 프로그램을 구현한다.
// 단, Scanner 를 활용하여 데이터를 입력받을 수 있도록 한다

// 실행 예)
// 임의의 정수 5개 입력(공백 구분) : 11 2 13 4 15					// 누적 합!

// >> 짝수의 합은 6 이고, 홀수의 합은 39 입니다. 
// 계속하려면 아무 키나 누르세요...

import java.util.Scanner;

public class Test038
{
	public static void main(String[] args)
	{
		// 주요 변수 선언
		Scanner sc = new Scanner(System.in);

		int num1, num2, num3, num4, num5;
		//-- 사용자로부터 입력받은 다섯 개의 정수를 담아낼 변수 선언
		
		int evenSum=0;			//-- 짝수의 합을 담아낼 변수 선언(누적합)
		int oddSum=0;			//-- 홀수의 합을 담아낼 변수 선언(누적합)
		//check
		//-- 누적합을 담아낼 변수 초기화★

		// 연산 및 처리
		System.out.print("임의의 정수 5개 입력(공백 구분) : ");		//	"11	2 13 4 15"
		num1 = sc.nextInt();
		num2 = sc.nextInt();
		num3 = sc.nextInt();
		num4 = sc.nextInt();
		num5 = sc.nextInt();

		if (num1%2==0)		// num1 이 짝수일 때...
			//evenSum 을 num1 만큼 증가
			evenSum += num1;
		else				// num1 이 홀수일 때...
			//oddSum 을 num1 만큼 증가
			oddSum += num1;

		if (num2%2==0)		
			evenSum += num2;
		else				
			oddSum += num2;

		if (num3%2==0)		
			evenSum += num3;
		else				
			oddSum += num3;

		if (num4%4==0)		
			evenSum += num4;
		else				
			oddSum += num4;

		if (num5%2==0)		
			evenSum += num5;
		else				
			oddSum += num5;


		// 결과 출력
		System.out.printf("\n>> 짝수의 합은 %d 이고, 홀수의 합은 %d 이다.\n", evenSum, oddSum);
	}

}

// 실행 결과
/*
임의의 정수 5개 입력(공백 구분) : 2 4 6 5 7

>> 짝수의 합은 12 이고, 홀수의 합은 12 입니다.
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 5개 입력(공백 구분) : 11 2 13 4 15

>> 짝수의 합은 6 이고, 홀수의 합은 39 이다.
계속하려면 아무 키나 누르십시오 . . .
*/

※ 누적합 또는 누적곱을 담는 변수는 반드시 초기화가 필요하다.
    누적합의 초기화 값은 일반적으로 '0'을 사용하며,
    누적곱의 초기화 값은 일반적으로 '1'을 사용한다

---

• Test039 (과제)
  - if ~ else 문 실습

• 문제

// ○ 과제
// 사용자로부터 임의의 알파벳 한 문자를 입력받아 이를 판별하여
// 입력받은 알파벳이 모음일 경우에만 결과를 출력하는 프로그램을 구현한다.
// 단, 대소문자를 모두 적용할 수 있도록 처리한다.
// 또한, 알파벳 이외의 문자가 입력되었을 경우
// 입력 오류에 대한 내용을 사용자에게 안내해 줄 수 있도록 한다.

// 실행 예)
// 임의의 알파벳 한 문자 입력 : A // ← 대문자 모음
// >> 모음 OK~!!!
// 계속하려면 아무 키나 누르세요...

// 임의의 알파벳 한 문자 입력 : e // ← 소문자 모음
// >> 모음 OK~!!!
// 계속하려면 아무 키나 누르세요...

// 임의의 알파벳 한 문자 입력 : B // ← 대문자 자음
// >> 계속하려면 아무 키나 누르세요...

// 임의의 알파벳 한 문자 입력 : c // ← 소문자 자음
// >> 계속하려면 아무 키나 누르세요...

// 임의의 알파벳 한 문자 입력 : 1 // ← 알파벳 아님
// >> 입력 오류~!!!
// >> 계속하려면 아무 키나 누르세요...

• 풀이

/*
========로직 생각해보기
1. 임의로 받아온 문자가 알파벳인지 아닌지 확인
	→ 알파벳 이면 대문자인지 소문자인지 확인
	→ 알파벳이 아니면 입력 오류 안내

2. 알파벳 대문자 & 소문자 확인 
	→ 대문자일때, 자음인지 모음인지 확인 //A, E, I, O, U
	→ 소문자일때, 자음인지 모음인지 확인 //a, e, i, o, u

3. 자음의 경우 아무것도 출력하지 않기
   모음의 경우 모음 OK~!!! 출력
*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test039
{
	public static void main(String[] args) throws IOException	//readLine  사용하기 위해
	{
		// BufferedReader 메소드 인스턴스 생성
		BufferedReader br = new BufferedReader (new InputStreamReader(System.in));

		int ch;		// 임의로 받아온 문자를 담을 변수

		System.out.print("임의의 알파벳 한 문자 입력 : "); // 사용자에게 문자 입력 받기 위해 출력하는 구문

		ch = System.in.read();						// 사용자가 입력해준 변수를 ASCII 코드로 담아둠

		//1. 사용자가 입력한 변수가 알파벳인지 확인하기
		if ((ch>=65 && ch <=90) || (ch>=97 && ch<=122))
		{
			// 	→ 알파벳 이면 대문자인지 소문자인지 확인
			// 2. 알파벳 대문자 & 소문자 확인 
			if (ch>=65 && ch<=90)
			{
				// 알파벳이 대문자일때 	→  자음인지 모음인지 확인 //A, E, I, O, U

				if (ch == 65 || ch == 69 || ch == 73 || ch == 79 || ch == 85)		// 대문자 모음일 때
				{
					System.out.println(">> 모음 OK~!!!");		//>> 모음 OK~!!! 출력
				}
				else
				{
					//System.out.println();		// 대문자 자음일 때 (아무것도 출력하지 않음) _ 개행이기 때문에 결과 값 달라짐
					// 공백으로 두어도 출력이상은 없음
				}
			}
			else
			{
				//알파벳이 소문자일때 →  자음인지 모음인지 확인 //a, e, i, o, u
				if (ch == 97 || ch == 101 || ch == 105 || ch == 111 || ch == 117)	// 소문자 모음일 때
				{
					System.out.println(">> 모음 OK~!!!");		// >> 모음 OK~!!! 출력
				}
//				else							// if else 구문이 아닌 if 구문으로 출력해도 문제는 없음												 
//				{
//					//System.out.println();		// 소문자 자음일 때 (아무것도 출력하지 않음) _ 개행이기 때문에 결과 값 달라짐
//				}
			}
			
		}
		else //→ 알파벳이 아니면 입력 오류 안내
		{
			System.out.println(">> 입.력.오.류.입.니.다.!!!");
		}
	}
}

// 실행 결과

// 대문자 모음
/*
임의의 알파벳 한 문자 입력 : A
>> 모음 OK~!!!
계속하려면 아무 키나 누르십시오 . . .
*/

// 대문자 자음
/*
임의의 알파벳 한 문자 입력 : F
계속하려면 아무 키나 누르십시오 . .	.
*/

// 소문자 모음
/*
임의의 알파벳 한 문자 입력 : u
>> 모음 OK~!!!
계속하려면 아무 키나 누르십시오 . . .
*/

// 소문자 자음
/*
임의의 알파벳 한 문자 입력 : g
계속하려면 아무 키나 누르십시오 . . .
*/

//입력오류 값
/*
임의의 알파벳 한 문자 입력 : 에?
>> 입.력.오.류.입.니.다.!!!
계속하려면 아무 키나 누르십시오 . . .
*

---

• Test040 (과제)
  - if ~ else 문 실습

• 문제

// ○ 과제
// 사용자로부터 임의의 문자 하나를 입력받아
// 대문자이면 소문자로, 소문자이면 대문자로
// 알파벳이 아닌 기타 문자이면 입력 오류 처리하는 프로그램을 구현한다.

// 실행 예)
// 한 문자 입력 : A
// >> A → a
// 계속하려면 아무 키나 누르세요...

// 한 문자 입력 : b
// >> b → B
// 계속하려면 아무 키나 누르세요...

// 한 문자 입력 : 2
// >> 입력오류~!!!
// 계속하려면 아무 키나 누르세요...

• 풀이

/*==============로직
1. 입력 받아온 한 문자가 알파벳인가 ?
	→ 알파벳이다 → 2번
	→ 기타 문자 → 입력오류

2. 알파벳 대소문자 분류
	→ 대문자 → 소문자
	→ 소문자 → 대문자

	//대소문자 변환 방법 

	ASCII 코드값 이용!
	
	대문자 A == 65 소문자 a == 97 
	대문자 B == 66 소문자 b == 98
			:			:
	즉, 대문자 +=32 → 소문자 로 변환 가능

	소문자 a == 97 대문자 A == 65
	소문자 b == 98 대문자 B == 66
			:			:
	즉, 소문자 -=32 → 대문자 로 변환 가능

3. 출력

*/

import java.io.BufferedReader; // 입력
import java.io.InputStreamReader; //번역
import java.io.IOException; // 예외처리

public class Test040
{
	public static void main(String[] args) throws IOException //System.in.read();  사용하기 위해
	{
		//BufferedReader 메소드 인스턴스 생성	
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		char ch; // 사용자가 입력한 문자를 담을 변수
		char res;	// 대소문자 변환 결과 값을 담을 변수

		System.out.print("한 문자 입력 : "); // 사용자에게 문자 입력 받기 위해 출력하는 구문
		ch = (char)System.in.read();  // 사용자가 입력해준 변수를 ASCII 코드로 담아둠

		//1. 입력 받아온 한 문자가 알파벳인가 ?
		if ((ch>='A' && ch <='Z') || (ch>='a' && ch<='z'))
		{
			// 알파벳이다!→2. 알파벳 대소문자 분류
			if (ch>='A' && ch <='Z') // 대문자 일때
			{
				res = (char)(ch + 32);		//	즉, 대문자 +=32 → 소문자 로 변환 가능	// 32가 정수이므로 int → char로 강제 형변환 필요
				System.out.printf(">> %c → %c\n", ch, res);
			}
			else	//소문자 일때
			{
				res = (char)(ch - 32);		//	즉, 소문자 -=32 → 대문자 로 변환 가능 // 32가 정수이므로 int → char로 강제 형변환 필요
				System.out.printf(">> %c → %c\n", ch, res);
			}
		}
		else	//→ 기타 문자 → 입력오류
		{
			System.out.println(">> 입.력.오.류.입.니.다.!!!");
		}
	}
}

// 실행 결과

//기타 문자일때
/*
한 문자 입력 : 웩
>> 입.력.오.류.입.니.다.!!!
계속하려면 아무 키나 누르십시오 . . .
*/

//알파벳 대문자일때
/*
한 문자 입력 : A
>> A → a
계속하려면 아무 키나 누르십시오 . . .
*/

//알파벳 소문자일때
/*
한 문자 입력 : h
>> h → H
계속하려면 아무 키나 누르십시오 . . .
*/

---

실행 흐름의 컨트롤 (제어문)
- Switch 문

• Switch문 + break , continue

○ 다중 선택문이라 하며, switch 문 다음의 수식 값에 따라
	실행 순서를 여러 방향으로 분기할 때 사용하는 문장이다.

○ 형식 및 구조

	switch(수식)           // if와 유사한 형태이나, 수식의 결과가 true or false 가 아니다.
	{
		case1 상수1 : 문장1; [break;]		// []브라켓 안에는 생략이 가능해서 씌워 표기해둠
		case2 상수2 : 문장2; [break;]       // 키워드 case 나 default를 가리켜 『레이블』이라고 한다. 
			  :
		[defalt : 문장 n+1; [break;]]       // default 구문 자체가 생략이 가능하다.
	}
    
    switch(n)				// 이러한 형태도 가능하다!
	{
		case 1 : case 2 : case 3 :

		case 4 : case5
	}

	switch 문의 『수식』과 case 의『상수』는
	byte, short, int, long 형이어야 한다.
	//JDK 1.7 버전 이후로 아래 형태가 추가 됨!
	+ 문자 타입(char)
	+ 문자열(String)

	case 문 뒤에 『break;』가 없는 형태인 경우
	다음 case 문의 문장을 계속해서(이어서) 수행하게 된다. (→ switch 문의 기본 모델)
	『break;』가 존재할 경우
	해당 지점에서 수행을 멈춘 후 switch 문을 빠져나가게 된다. (→ switch 문의 일반 모델)

break ; 멈춘다 (+ 그리고 빠져나간다) 
continue ;  (뒷부분 무시하고...+) 계속한다

---

• Test041
  - switch 문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - switch 문 실습
=================================================*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test041
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String name;					// 이름
		int kor, eng, mat, tot;			// 국어, 영어, 수학, 총점
		//double avg;						// 평균
		int avg;
		//char grade;						// 등급
		char grade = 'F';

		System.out.print("이름 입력 : ");
		name = br.readLine();

		System.out.print("국어 점수 입력 : ");
		kor = Integer.parseInt(br.readLine());
		System.out.print("영어 점수 입력 : ");
		eng = Integer.parseInt(br.readLine());
		System.out.print("수학 점수 입력 : ");
		mat = Integer.parseInt(br.readLine());
		
		tot = kor + eng + mat;
		//avg = tot / 3.0;
		avg = tot / 3;
		/*               // if 문으로 작성시 구문
		if(avg>=90)
			grade = 'A';
		else if(avg>=80)
			grade = 'B';
		else if(avg>=70)
			grage = 'C';
		else if(avg>=60)
			grade = 'D';
		else
			grade = 'F';
		*/
		/*                // switch 문으로 작성시
		switch (avg)
		{
			case 100: grade='A'; break;
			case 99: grade='A'; break;
			//
			case 0:grade='F'; break;
		
		}
		*/
		/*               // switch 문으로 작성 + 10점 단위로 등급을 나눠 표현
		switch (avg/10)
		{
			case 10: grade='A'; break;
			case 9: grade='A'; break;
			case 8: grade='B'; break;
			case 7: grade='C'; break;
			case 6: grade='D'; break;
			case 5: grade='F'; break;
					:
			case 0: grade='F'; break;
		}
		*/
		/*               // switch 문으로 작성 + 10점 단위로 등급을 나눠 표현 + 50점대부터 F + default 값
		switch (avg/10)
		{
			case 10: grade='A'; break;
			case 9: grade='A'; break;
			case 8: grade='B'; break;
			case 7: grade='C'; break;
			case 6: grade='D'; break;
			case 5: grade='F'; break;
			default: grade='F'; break;
		}
		*/
		/*               // switch 문으로 작성 + 10점 단위로 등급을 나눠 표현 + default 값
		switch (avg/10)
		{
			case 10: grade='A'; break;
			case 9: grade='A'; break;
			case 8: grade='B'; break;
			case 7: grade='C'; break;
			case 6: grade='D'; break;
			default: grade='F'; break;
		}
		*/
               
		switch (avg/10) // switch 문으로 작성 + 10점 단위로 등급을 나눠 표현 + (default값 생략)
		{
			case 10: case 9: grade='A'; break;
			case 8: grade='B'; break;
			case 7: grade='C'; break;
			case 6: grade='D'; break;
		}
	
		// 결과 출력
		System.out.println();
		System.out.printf(">> 당신의 이름은 %s 입니다.\n", name);
		System.out.printf(">> 총점은 %d, 평균은 %d 입니다.\n", tot, avg);
		System.out.printf(">> 등급은 %c 입니다.\n", grade);

	}
}

// 실행 결과

/*
이름 입력 : 행성
국어 점수 입력 : 50
영어 점수 입력 : 80
수학 점수 입력 : 90

>> 당신의 이름은 행성 입니다.
>> 총점은 220, 평균은 73 입니다.
>> 등급은 C 입니다.
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test042
  - switch 문 실습 : 기본모델(break 미사용), 일반모델(break 사용)
  - 별문자 출력

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - switch 문 실습
=================================================*/

// 사용자로부터 1부터 3 까지의 정수 중 하나를 입력받아
// 입력받은 정수만큼의 별문자(★)가 출력되는 프로그램을 작성한다.
// 단, 두가지 방법으로 구현할 수 있도록 한다.

// ① switch 문의 일반모델(break사용)을 사용하여 구현한다.
// ② switch 문의 기본모델(break미사용)을 사용하되,
//		『break;』를 딱 한 번만 사용할 수 있도록 구현한다.

// 실행 예)
// 임의의 정수 입력(1~3) : 3
// ★★★
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력(1~3) : 1
// ★
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력(1~3) : 7
// 입력 오류~!!!
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test042
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n;

		System.out.print("임의의 정수 입력(1~3) : ");
		n = Integer.parseInt(br.readLine());
		
		/*
		//①
		switch (n)
		{
		case 1:System.out.println("★");break;
		case 2:System.out.println("★★");break;
		case 3:System.out.println("★★★");break;
		default:System.out.println("입력 오류~!!!"); //break;;
		}
		*/

		//②
		switch (n)
		{
		default:System.out.println("입력 오류~!!!");break;	// 위로 올려도 가능! // 순차적으로 내려가기 때문에
		case 3:System.out.print("★");
		case 2:System.out.print("★");
		case 1:System.out.print("★\n");
			//break;
		//default:System.out.println("입력 오류~!!!");
		}
	}
}
// 실행결과

/*
임의의 정수 입력(1~3) : 9999
입력 오류~!!!
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력(1~3) : 3
★★★
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력(1~3) : 2
★★
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력(1~3) : 1
★
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test043
  - switch 문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - switch 문 실습
=================================================*/

// 사용자로부터 임의의 두 정수와 연산자를 입력받아
// 해당 연산자의 연산 처리 결과를 출력하는 프로그램을 구한다.
// 단, switch 문을 활용하여 처리할 수 있도록 하며,
// 연산 결과는 편의상 정수 형태로 처리할 수 있도록 한다.

// 실행 예)
// 첫 번째 정수 : 3
// 두 번째 정수 : 17
// 연산자 입력[+ - * /] : -

// >> 3 - 17 = -14
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test043
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		/*
		int a, b, op; // 입력받은 두 정수 , 연산자
		int result;

		System.out.print("첫 번째 정수 : ");
		a = Integer.parseInt(br.readLine());
		System.out.print("두 번째 정수 : ");
		b = Integer.parseInt(br.readLine());
		System.out.print("연산자 입력[+ - * /] : ");
		op = System.in.read();							//연산자를 ASCII 코드로 받음~

		// '+' → op:43 , '-' → op:45, '*' → op:42, '/' → op:47

		// ----------------------------------------------------------------------------풀이 ①
		switch (op)
		{
			case 43: result = a+b; break;
			case 45: result = a-b; break;
			case 42: result = a*b; break;
			case 47: result = a/b; break;	
			default: return; //--return : 1. 값을 반환한다
							 //			  2. 메소드의 종료 → main() 메소드 종료 → 프로그램 종료
		}

		System.out.println();
		System.out.printf(">> %d %c %d = %d\n", a, op, b, result);
		*/
		/*
		// -----------------------------------------------------------------------------풀이②
		int a, b, result;
		//int op;
		char op;

		System.out.print("첫 번째 정수 : ");
		a = Integer.parseInt(br.readLine());
		System.out.print("두 번째 정수 : ");
		b = Integer.parseInt(br.readLine());
		System.out.print("연산자 입력[+ - * /] : ");
		op = (char)System.in.read();

		switch (op)
		{
			case '+': result = a + b; break;
			case '-': result = a - b; break;
			case '*': result = a * b; break;
			case '/': result = a / b; break;
			default: return;
		}

		System.out.println();
		System.out.printf(">> %d %c %d = %d\n", a, op, b, result);
		*/
		// -----------------------------------------------------------------------------풀이③ // 문자열로 받아보기! "+"/"-"/"*"/"/"
		int a, b, result;
		//int op;
		//char op;
		String op;

		System.out.print("첫 번째 정수 : ");
		a = Integer.parseInt(br.readLine());
		System.out.print("두 번째 정수 : ");
		b = Integer.parseInt(br.readLine());
		System.out.print("연산자 입력[+ - * /] : ");
		//op = (char)System.in.read();
		op = br.readLine();					// 문자열 형태로 "+" "-" "*" "/"

		switch (op)
		{
			case "+": result = a + b; break;
			case "-": result = a - b; break;
			case "*": result = a * b; break;
			case "/": result = a / b; break;
			default: return;
		}

		System.out.println();
		//System.out.printf(">> %d %c %d = %d\n", a, op, b, result);
		System.out.printf(">> %d %s %d = %d\n", a, op, b, result);

	}
}

// 실행 결과

/*
첫 번째 정수 : 5
두 번째 정수 : 120
연산자 입력[+ - * /] : +
>> 5 + 120 = 125
계속하려면 아무 키나 누르십시오 . . .
*/
/*
첫 번째 정수 : 3165
두 번째 정수 : 1231
연산자 입력[+ - * /] : -
>> 3165 - 1231 = 1934
계속하려면 아무 키나 누르십시오 . . .
*/
/*
첫 번째 정수 : 35
두 번째 정수 : 14
연산자 입력[+ - * /] : *
>> 35 * 14 = 490
계속하려면 아무 키나 누르십시오 . . .
*/
/*
첫 번째 정수 : 34
두 번째 정수 : 17
연산자 입력[+ - * /] : /
>> 34 / 17 = 2
계속하려면 아무 키나 누르십시오 . . .
*/

/*
첫 번째 정수 : 20
두 번째 정수 : 7
연산자 입력[+ - * /] : +

>> 20 + 7 = 27
계속하려면 아무 키나 누르십시오 . . .
*/

 

※ return; 
1. 값의 반환                                                                      //  메인 메소드 안에서는 값의 반환이 일어날 수 없다.
2. 메소드의 종료
→ 해당 메소드 (즉, 여기서는 main()메소드) 종료 → 프로그램 종료

※ 메인 메소드의 시작은 "프로그램 시작", 종료는 "프로그램 종료"를 의미.

// 개인적 감상

if~else 처럼 자주 활용할때는 익숙해지는 반면 switch 문은 내가 활용을 잘 안하는 편이라 조금 헷갈리는 부분도 있고 점점 더 잊고 사용하지 않는 것 같다.  좀 더, switch 문을 활용할 수 있는 방안을 찾아봐야겠다.