Java - 제어문

제어문

* 프로그램은 기본적으로 위에서 아래로 순차적으로 실행된다.
* 다만, 순차적인 흐름을 바꾸고자 할 때는 "제어문"을 사용하여 제어한다.
* 종류
1. 조건문 : 선택적으로 실행하는 선택문(if, if-else, if-else if, switch)
2. 반복문 : 반복적으로 실행하는 실행문(while, do-while, for)
3. 분기문 : 그 이외의 흐름을 제어하는 구문(break, continue)

조건문

* 조건식을 통해 결과가 참, 거짓을 판별하여, 조건이 참일 경우 구문을 실행하낟.
* 조건식의 결과는 true, false라는 논리값만 나와야한다.
* 조건식에서는 비교연산자, 논리연산자를 주로 사용한다.

단독 if문

 * 조건을 단독적으로 한개만 제시할 경우
 * [표현법]
 * if(조건식){
 *  해당 조건식의 결과가 true일 경우에 실행할 코드	
 *  }
 *  => 조건식의 결과가 true일 경우, 중괄호 블럭 안에 있는 코드가 실행된다.
 *  => 조건식의 결과가 false일 경우, 중괄호 블럭 안의 코드를 무시하고 넘어간다.
 *  
 *  

--------------------------------------------------------------------------------------------------
package com.kh.chap01.condition;
import java.util.Scanner;

public class A_If {

	public void method1() {
		
		// 단독 if문
		// 사용자로부터 정수값을 입력받은 후,
		// "양수이다","0이다","음수이다"
		Scanner sc = new Scanner(System.in);
		System.out.print("정수 값 : ");
		int num = sc.nextInt();
		sc.nextLine();
		// 1. 양수일 경우
		if(num > 0) {
			System.out.println("양수이다.");
		}
		// 2. 0일 경우
		if(num == 0) {
			System.out.println("0이다.");
		}
		// 3. 음수일 경우
		if(num < 0) {
			System.out.println("음수이다.");
		}
	}
	public void method2() {
		
		// 단독if문 2
		// 사용자가 입력한 정수값이 짝수인지, 홀수인지를 판별해서
		// "짝수다", "홀수다"를 출력한다.
		Scanner sc = new Scanner(System.in);
		System.out.print("정수 값 : ");
		int num = sc.nextInt();
		sc.nextLine();
		if((num % 2 == 0)) {
			System.out.println("짝수다");
		}
		if((num % 2 == 1)){
			System.out.println("홀수다");
		}
	}
	//실습문제
	public void method3() {
		/* 사용자가 나이를 입력한 후, 
		 * 13세 이하면 "어린이입니다"
		 * 13세 초과 ~ 19세 이하면 "청소년입니다"
		 * 19세 초과 ~ "성인입니다"
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("나이 : ");
		int num = sc.nextInt();
		sc.nextLine();
//		1. 삼항연산자
//		(13세 이하)? 어린이 : (19세 이하)? 청소년 : 성인; 
//		String age1 = (num<=13)? "어린이입니다" : 
//			(num<=19)? "청소년입니다":"성인입니다";
//		System.out.printf("%s",age1);
//		System.out.println();
		
//		2. 단독 if문
		if(num <=13) { // 13세 이하 : 어린이
			System.out.println("어린이입니다");
		}
		if(num >=14 && num <=19) { //14세 ~ 19세 : 청소년
			System.out.println("청소년입니다");
		}
		if(num >= 20) { //20세 이상 : 성인
			System.out.println("성인입니다");
		}
	}
	public void method4() {
		// 사용자에게 입력받은 주민등록번호를 가지고
		// 남자,여자 인지 판별 후 "남자입니다","여자입니다" 출력
		
		// 1. 사용자에게 주민등록번호 입력받기
		Scanner sc = new Scanner(System.in);
		System.out.print("주민번호 입력(-포함): ");
		// 주민번호 : 생년월일6글자 + '-' + 성별1글자 + 6자리 숫자
		String personId = sc.nextLine();
		// 성별에 해당하는 인덱스 추출
		char gender = personId.charAt(7);
		// 문자로 된 Variable을 이용하여 일치 여부 판별
		if((gender=='1') || (gender=='3')) {
			System.out.println("남자입니다");
		}
		if((gender=='2') || (gender=='4')) {
			System.out.println("여자입니다.");
		}
		// 이외의 숫자를 입력한 경우
		if((gender != '1')&&(gender != '2')&&
				(gender != '3')&&(gender != '4')) {
			System.out.println("잘못된 주민번호 입니다.");
		}
		
	}
}
--------------------------------------------------------------------------------------------------

if-else문

 * 두개의 조건으로 경우의 수를 나눌 경우에 사용한다.
 * [표현법]
 * if(조건식){
 * 		조건이 참일 경우 실행할 코드
 * }else{
 * 		조건이 거짓일 경우 실행할 코드
 * }
 * => 조건식의 결과가 true인 경우, if블럭을 실행
 * => 조건식의 결과가 false인 경우, else블럭을 실행
 * => 둘 중 하나만 실행이 된다.
 *

--------------------------------------------------------------------------------------------------
package com.kh.chap01.condition;
import java.util.Scanner;

public class B_Else {
	
	public void method1() {
		// 사용자가 입력한 정수값이 짝수인지, 홀수인지를 판별해서
		// "짝수다", "홀수다"를 출력한다.
		Scanner sc = new Scanner(System.in);
		System.out.print("정수 값 : ");
		int num = sc.nextInt();
		sc.nextLine();
		if(num % 2 == 0) { // 짝수일 경우
			System.out.println("짝수다");
		}else {	// 짝수가 아닌 경우(홀수일 경우)
			System.out.println("홀수다");
		}
	}
	//중첩 if문 : if영역 안에 또 if문이 있을 경우
	//=> 삼항연산자의 경우와 같다.
	public void method2() {
		// 사용자가 입력한 양수값이 짝수인지, 홀수인지를 판별해서
		// "짝수다", "홀수다"를 출력한다.
		Scanner sc = new Scanner(System.in);
		System.out.print("양수 값 : ");
		int num = sc.nextInt();
		sc.nextLine();
		
		if(num > 0) { // 양수일 경우
			
			if(num %2==0) {// 짝수일 경우
				System.out.println("짝수다.");
			}else { // 홀수일 경우
				System.out.println("홀수다.");
			}
		}else { // 양수가 아닌 경우
			System.out.println("양수를 입력해야 한다.");
		}
	}
	public void method3() {
		// 사용자로부터 이름을 입력받아
		// 유효한 이름이라면 "본인입니다. 어서오세요."출력
		// 아니라면 "본인이 아닙니다. 돌아가주세요." 출력
		// => 문자열의 동등비교

		/* 
		 * 기본자료형은 동등 비교시, == 또는 != 을 가지고 비교가 가능하다.
		 * (boolean ,char, byte, short, int, long, float, double)
		 * 
		 * 참조자료형인 String은 동등 비교시, == 또는 !=을 가지고 비교가 되지 않는다.
		 * 왜? => 주소값이 비교대상으로 되기 때문이다.
		 * 기본자료형은 Stack영역에 값 및 주소값이 같이 저장되지만
		 * 참조자료형인 String은 Heap영역에 값을, Stack영역에 주소값을 저장하기때문이다.
		 * => 위에서는 0123 -> 홍길동 0123(sc.nextLine())
		 *          1234 -> 홍길동 1234(name == "홍길동")
		 * 
		 * 주소값을 비교하기 위해 equals()를 사용한다.
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("사용자의 이름 입력 : ");
		String name = sc.nextLine();
		
		if(name.equals("홍길동")) { //"홍길동".equals(name)도 가능
			
			System.out.println("본인입니다. 어서오세요");
		}else {
			
			System.out.println("본인이 아닙니다. 돌아가주세요");
		}
	}
--------------------------------------------------------------------------------------------------

if -else if문

 * 동일한 비교대상을 가지고, 여러 개의 조건을 제시해주고자 할 경우 사용한다.
 * 
 * [표현법]
 * if(조건식1) {
 * 		실행할 코드1;
 * }
 * else if(조건식2) {
 * 		실행할 코드2;
 * }
 * else if(조건식3) {
 * 		실행할 코드3;
 * }
 * else{
 * 		앞의 조건들이 모두 false경우, 실행할 코드4;
 * }

--------------------------------------------------------------------------------------------------
	public void method4() {
		// 양수, 0, 음수를 판별하는 코드를 작성한다.
		Scanner sc = new Scanner(System.in);
		System.out.print("정수 입력 : ");
		int num = sc.nextInt();
		sc.nextLine();
		
		if(num > 0 ) { // 양수일 경우
			System.out.println("양수입니다.");
		}else if(num == 0) { //  0일 경우
			System.out.println("0입니다.");
		}else { // 음수일 경우
			System.out.println("음수입니다.");
		}
	}
	public void method5() {
		/*
		 * 사용자로부터 키보드로 점수를 입력받는다.
		 * 90점 이상인 경우 : "A"등급
		 * 80점 이상 ~ 90점 미만 : "B"등급
		 * 70점 이상 ~ 80점 미만 : "C"등급
		 * 70점 미만 : "D"등급
		 * => "당신의 점수는 xx점이고, 등급은 X등급 입니다."
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("점수 입력 : ");
		int score = sc.nextInt();
		sc.nextLine();
		char grade = ' ';
		// char자료형의 값은 공백 한칸으로 초기화한다.
		
		// 먼저, 0~100사이인지를 체크
		// if(score < 0 || score > 100) {// 0 ~ 100사이가 아닐 경우
		// else{ // 0~100사이일 경우
		
		if(score>=0 && score<=100) {// 0~ 100사이일 경우
			if(score >= 90) {	// 90~100점
				grade = 'A';
				System.out.println(grade);
			}else if(score >= 80 ) { // 80~89점
				grade = 'B';
				System.out.println(grade);
			}else if(score >= 70 ) { // 70~79점
				grade = 'C';
				System.out.println(grade);
			}else { // 1~69점
				grade = 'D';
				System.out.println(grade);
			}
			// 점수와 등급을 출력하는 출력문을 작성
			System.out.printf("당신의 점수는 %d점이고, 등급은 %c입니다."
					,score,grade);
		}
		else {//0~100사이가 아닐경우
			System.out.println("잘못 입력했습니다.");
		}
		
	}
	public void method6() {
		/*
		 * 나이를 입력받아 어린이, 청소년, 성인을 출력하시오.
		 * 어린이(1~13), 청소년(14~19), 성인(20~)
		 */
		// Scanner class 및 입력문 
		Scanner sc = new Scanner(System.in);
		System.out.print("나이 입력 : ");
		// Variable 설정
		int age = sc.nextInt();
		sc.nextLine();
		String str = "";
		// if - else if 문
		if(age > 0) { // 양수로 입력한 경우
			if(age > 19) { // 20세 이상
				//System.out.println("성인입니다.");
				str = "성인";
			}else if(age >13) { // 14~19세
				//System.out.println("청소년입니다.");
				str = "청소년";
			}else { // 1~13세
				//System.out.println("어린이입니다.");
				str = "어린이";
			}
			// age와 str의 결과를 출력할 출력문을 작성.
			System.out.printf("당신의 나이는 %d세이며, \"%s\" 입니다.",age,str);
		}else { // 0, 음수로 입력한 경우
			System.out.println("잘못 입력하셨습니다.");
		}
	}
	
}
--------------------------------------------------------------------------------------------------

Switch문

 * 표현하고 싶은 경우의 수가 여러 개일 경우 사용 가능하다.
 * 단, ==(동등비교연산자)이 포함된 조건인 경우에만 사용이 가능하다.
 * 
 * switch문과 if문의 차이점
 * if(조건식) 	=> 조건식을 복잡하게 기술할 수 있다.(사용가능한 연산자의 가짓수가 많다)
 *				       조건식에서 숫자의 범위를 표현할 수 있다. 	
 * Switch(조건식x)=> 확실한 값의 조건만 가능하다.(동등 비교 수행)
 * 				
 * [표현법]
 * switch(동등 비교를 할 대상자){
 * case 값1 : 실행할코드1; // 만약 앞으로 동등비교를 할 대상자 == 값1이면
 * 					   // 실행할 코드 1을 실행한다.
 * 			  break;   // 실행할 코드 1을 실행하고, 중괄호 영역을 빠져나간다.
 * case 값2 : 실행할코드2; // 만약 앞으로 동등비교를 할 대상자 == 값2이면
 * 					   // 실행할 코드 2를 실행한다.
 *            break;   // 실행할 코드 2를 실행하고, 중괄호 영역을 빠져나간다.
 * ...
 * case 값n : 실행할코드n;
 *            break;
 *            
 * default : 실행할코드;  // case 값1에서 n번까지 동등비교를 수행하고
 *                     // 하나도 실행되지 않았을 때 실행된다(=else)
 *                     // break;를 쓰지 않는다.
 * }

--------------------------------------------------------------------------------------------------
package com.kh.chap01.condition;
import java.util.Scanner;

public class C_Switch {
	
	public void method1() {
		/*
		 * 1~3사이의 숫자를 입력받아
		 * 1인경우 : "빨간불입니다"
		 * 2인경우 : "파란불입니다"
		 * 3인경우 : "초록불입니다"
		 * 잘못입력한경우 : "잘못 입력하였습니다"
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("숫자 입력 : ");
		int num = sc.nextInt();
		sc.nextLine();
        
		/*
		if(num == 1) { // 빨간불
			System.out.println("빨간불입니다.");
		}else if(num == 2) { // 파란불
			System.out.println("파란불입니다.");
		}else if(num ==3) { // 초록불
			System.out.println("초록불입니다.");
		}else { // 잘못입력한 경우
			System.out.println("잘못입력하였습니다.");
		}
		*/
        
		String light = "";
		switch(num) {
		case 1 : // num == 1이면 실행한다.
			light = "빨간불"; 
			// System.out.println("빨간불입니다");
				break; // 실행결과가 true이면 중괄호 영역을 나온다.

		case 2 : // num == 2이면 실행한다.
			light = "파란불"; 
			// System.out.println("파란불입니다");
				break; // 실행결과가 true이면 중괄호 영역을 나온다.

		case 3 : // num == 3이면 실행한다.
			light = "초록불"; 
			// System.out.println("초록불입니다.");
				break; // 실행결과가 true이면 중괄호 영역을 나온다.
		
		default : // num이 1,2,3이 아닌 경우, default를 출력한다.
			System.out.println("잘못 입력하셨습니다."); 
			return; 
			// return문은 현재 실행중인 Method 자체를 빠져나간다는 뜻이다.
			// 그리고, 현재 실행중인 Method를 호출한 c.method1();으로 돌아간다.
			// 즉, num == 4일 경우, default의 "잘못입력하였습니다."를 실행하기로 하고
			// switch문을 나와서 c.method1();으로 돌아간다.
		}
		System.out.printf("%s입니다.",light);
	}
    
	public void method2() {
		// 사용자에게 구매할 과일명(사과, 바나나, 복숭아)를 입력받아
		// 각 과일의 가격을 출력(사과:1000원 / 바나나 : 2000원 / 복숭아 : 5000원)
		Scanner sc =new Scanner(System.in);
		System.out.println("-----Welcome 과일가게 -----");
		System.out.print("구매할 과일명 입력 : ");
		String fruit = sc.nextLine();
		int price = 0;
		
		// [주의할 점]
		// switch에서는 문자열도 동등비교(==)를 내부적으로 수행할 수 있다.(equals없이)
		switch(fruit) {
		case "사과" :			// if( fruit.equals("사과") ) {}
			price = 1000;
			break;
		
		case "바나나" : 		// else if( fruit.equals("바나나") ) {}
			price = 2000;
			break;
			
		case "복숭아" : 		// else if( fruit.equals("복숭아") ) {}
			price = 5000;
			break;
		
		default :		// else {}
			System.out.println("입력하신 과일은 존재하지 않습니다.");
			return;
			// return을 쓰면 바로 위의 "입력하신~"까지를 출력하고
			// Method2를 호출한 c.method2()로 돌아간다.
		}
		System.out.printf("%s의 가격은 %d원 입니다.",fruit,price);
	}
    
	public void method3(){
		// 주민번호를 입력받아 남자, 여자를 구별하시오.
		// => 주민번호를 문자열로 취급하여 받으시오.
		
		Scanner sc = new Scanner(System.in);
		System.out.print("주민번호 입력(-포함) : ");
		// Variable은 조건문 밖에서 선언한다.
		// 이유는 Variable이 해당 중괄호 안에서만 유효하게 되기 때문이다.
		String personId = sc.nextLine();
		char gender = personId.charAt(7);
		String result = "";
		
		switch(gender) {
		// '1' 또는 '3'일 경우 
		// 동일한 케이스를 한번에 묶어서 나열하고 그 사이에는 break를 쓰지 않는다.
		// case에 아무런 값, 코드, break를 적지 않으면 다음 case로 넘어간다.
		case '1' : 
			// result = "남자입니다";
			// break;
		case '3' :
			result = "남자입니다";
			break;
		
		// '2' 또는 '4'일 경우 
		case '2' : 
			// result = "여자입니다";
			// break;
		case '4' : 
			result = "여자입니다";
			break;
		
		default : 
			System.out.println("잘못 입력하셨습니다.");
			return;
		}
		System.out.println(result);
	}
    
	public void method4() {
		// 사용자에게 1월~12월 사이의 일을 입력받아
		// 해당 월에 해당하는 계절을 출력
		// 봄(3~5), 여름(6~8월), 가을(9~11월), 겨울(12~2월)
		Scanner sc =new Scanner(System.in);
		System.out.print("월 입력 : ");
		
		int month = sc.nextInt();
		sc.nextLine();
		
		switch(month) {
		case 3:
		case 4:
		case 5:
			System.out.println("봄입니다.");
			break;
		case 6:
		case 7:
		case 8: 
			System.out.println("여름입니다.");
			break;
		case 9:
		case 10:
		case 11: 
			System.out.println("가을입니다.");
			break;
		case 12:
		case 1:
		case 2: 
			System.out.println("겨울입니다."); 
			break;
		default : 
			System.out.println("1~12사이의 숫자를 입력해주세요.");
			// return;
			// Method가 끝나는 영역 기준으로 return이 마지막 구문이기 때문에
			// return이 있으나 없으나 Method가 끝나니 생략해도 된다.
		}
	}
}
--------------------------------------------------------------------------------------------------

반복문

* 프로그램의 흐름을 제어하는 제어문 중 하나로, 어떤 실행구문을 반복적으로 실행한다.

for문

 * 코드를 반복시켜주는 구문 중 하나이다.
 * 단, 내가 반복할 횟수를 알고 있을 때 사용한다.
 * 괄호 안에 반복을 지정하는 부분이 (초기식;조건식;증감식)으로 이루어져 있다.
 * 
 * [표현법]
 * for(초기식;조건식;증감식){
 * 		반복시키고자 하는 코드;
 * }
 * => 소괄호 : 몇번 반복을 할지를 지정한다.
 * => 중괄호 : 무엇을 반복하여 출력할지를 지정한다.
 * 
 * 초기식 : 반복문이 실행될 때, "초기에 단 한번만 실행되는 구문"이다.
 *        (반복문 안에서 사용할 Variable을 선언 및 초기화한다.)
 * 조건식 : 반복문이 실행될 때, "해당 반복이 수행될 조건"을 지정한다.
 * 		  (초기식에서 지정한 Variable을 가지고 조건을 지정한다)
 * 		  => 조건식의 결과가 true : 반복을 진행한다. 
 *        => 조건식의 결과가 false : 반복을 종료 후 반복문을 빠져나온다.
 * 증감식 : 반복문을 제어하는 Variable값을 증감시킨다.
 * 		  (초기식에서 지정한 Variable을 가지고 증감을 한다)
 * 
 * [실행 순서]
 * 초기식  -> 조건식(true) ->코드 -> 증감식 
 *      -> 조건식(true) ->코드 -> 증감식 
 *      -> 조건식(true) ->코드 -> 증감식 
 *      ...
 *      -> 조건식 (false) ->코드를 실행하지 않고, 반복문 종료 후 빠져나옴.

package com.kh.chap02.loop;
import java.util.Scanner;

public class A_For {

	public void method1() {
		// for문을 사용하는 이유
		// 1. 반복적인 구문을 작성할 때, 실수를 줄이기 위해서
		// 2. 반복이 늘어나면 번거롭기 때문에
		
		// "안녕하세요"를 5번 연속으로 출력하기
		// System.out.println("안녕하세요");
		// System.out.println("안녕하세요");
		// System.out.println("안녕하세요");
		// System.out.println("안녕하세요");
		// System.out.println("안녕하세요");
		
		// 반복 횟수는 같아도 초기식, 조건식, 증감식이 다를 수 있다.
		// i=1 ; i<=5
		for(int i=1; i<=5; i++) {// 초기식 : Variable을 선언 후 초기화해줌.
								// 조건식 : 증감시킬 횟수를 지정해줌.
								// 증감식 : 증감연산자를 이용하여 지정해줌.
								// 		    후위증감연산자를 사용해준다.
			System.out.println("안녕하세요.");
			// i = 1(true) : "안녕하세요" => i=2
			// i = 2(true) : "안녕하세요" => i=3
			// i = 3(true) : "안녕하세요" => i=4
			// i = 4(true) : "안녕하세요" => i=5
			// i = 5(true) : "안녕하세요" => i=6
			// i = 6(false) => 반복문 종료
		}

		System.out.println();
		// i=1, i<6
		for(int i=1; i<6; i++) {
			System.out.println("반갑습니다.");
		}
		
		System.out.println();
		// 반복의 시작값이 1일 필요는 없다.
		// i값이 11에서부터 16보다 작을때 까지 1씩 증가할 동안 반복
		// i=11,12,13,14,15(true) / 16(false)
		for(int i=11; i<16; i++) {
			System.out.println("어서오세요");
		}
		
		System.out.println();
		// 증감식에서 증가할 값이 1일 필요는 없다.
		// i가 1부터 10까지 매번 2씩 증가할동안 반복
		// i=1,3,5,7,9(true) /11(false)
		for(int i=1;i<=10; i+=2) {
			System.out.println("저리가세요");
		}
		
		System.out.println();
		// 증감식에서 감소도 가능하다.
		// i가 10에서부터 6보다 크거나 같을때까지 감소할동안 반복
		// i = 10,9,8,7,6(true) / 5(false)
		for(int i=10; i>=6; i-=1) {
			System.out.println("하이");
		}
	}
    
	public void method2() {
		// 제일 단순하게 반복되는 횟수를 지정하는 표현법
		// 초기식; 조건식; 증감식
		// (int i=0; i<반복시키고자하는 횟수; i++)
		//System.out.println("고정된 문자열");
		int j = 0;
		for(int i=0; i<10; i++) {
			
			// 고정된 문자열말고 매번 달라지는 출력 결과를 보고싶다.
			// i : 0
			// i : 1
			// i : 2 ...
			//System.out.println("i : "+i);
			
			// 0번째 출력문
			// 1번째 출력문
			// 2번째 출력문 ...
			//System.out.println(i+"번째 출력문");
			
			// 1번째 출력문
			// 2번째 출력문
			// 3번째 출력문 ...
			// int j = i+1;
			// System.out.println(j+"번째 출력문");
			
			// 1번째 출력문
			// 2번째 출력문
			// 2번째 출력문
			// 3번째 출력문...
			// 특정 출력문만 반복하고 싶을때
			System.out.println((i+1)+"번째 출력문");
			if(i==1) {
				j=i+1;
				System.out.println(j+"번째 출력문");
			}else {
			}
		}
	}
	
	public void method3() {
		for(int i=0; i<10; i++) {
			// 1 2 3 4 5 6 7 8 9 10
			// System.out.print((i+1)+" ");
			System.out.printf("%d ",(i+1));
		}
	}
	
	public void method4() {
		// 1에서부터 10까지 모든 수를 더하는 것
		int sum = 0 ; // 0으로 초기화하는 이유 : 누적시 정확한 값을 얻기 위해서.
		for(int i=1; i<=10; i++) {
			sum = sum + i;
			// sum += i;
			// i=1 => sum= 0+1		 => i=2
			// i=2 => sum= 0+1+2	 => i=3
			// i=3 => sum= 0+1+2+3   => i=4
			// i=4 => sum= 0+1+2+3+4 => i=5
			// ...
			// i=10 => sum= 0+1+2+...+9+10 =55 =>i=11
			// i=11(false)
			
			// 1+2+3+.....+10+
			// System.out.print(i+"+");
			System.out.print(i);
			
			// i가 마지막 숫자가 되기 전까지는 "+"를 연이어서 출력
			// i가 마지막 숫자가 되는 순간 "="을 출력
			// => 선택적으로 결정(조건문)
			// 마지막 숫자 : 10
			if(i == 10) {
				System.out.print(" = ");
			}else {
				System.out.print(" + ");
			}
			// 1+2+3+...+10 =
		}
		System.out.println(sum);
		System.out.println("1에서 10까지의 합 : "+sum);
	}
    
	public void method5() {
		// 사용자로부터 양수 한개를 입력 받아
		// 1부터 그 숫자까지 누적합을 구하고자한다.
		Scanner sc = new Scanner(System.in);
		System.out.print("양수 값 : ");
		int num = sc.nextInt();
		sc.nextLine();
		// 1.양수인지 아닌지 판별
		if(num>0) { // num이 양수인 경우
			// 2. 누적합 구하기
			int sum = 0;
			for(int i=1; i<=num; i++) {
				System.out.print(i);
				// 3. 누적합을 수식으로 표현하기
				// 1+2+3+...=
				if(i==num) {
					System.out.print(" = ");
				}else {
					System.out.print(" + ");
				}
				
				sum = sum+i;
			}
		// 4.for문 밖에 결과 출력하기
		System.out.println(sum);
		System.out.println("누적합 : "+sum);
		
		}else{ // num이 양수가 아닐 경우
			System.out.println("잘못 입력하셨습니다.");
		}
	}

난수

	 * 매번 임의로 발생하는 랜덤값
	 * Math클래스
	 * 수학 계산과 관련된 모든 상수, method를 포함하고 있는 Class
	 * Java에서 이미 제공하고 있는 Class
	 * 
	 * [특징]
	 * 모든 Variable과 Method앞에 static이 붙어있다.
	 * => Method를 호출할 때, new를 이용하여 대변할 이름을 만들 필요가 없다.
	 *    바로 Class명.Method명();으로 호출해준다.
	 * random()
	 * 매번 다른 랜덤값을 리턴해준다.
	 * 0.0 ~ 0.999999 사이의 랜덤값을 발생한다.
	 * 0.0 <= 랜덤값  < 1.0
	 * 
	 * [표현법]
	 * 0.0 <= Math.random(); < 1.0
     * 0.0 ~ 0.999...
	 * 0.0 ~ 9.999...(*10)
	 * 1.0 ~ 10.999...(+1)
	 * 1 ~ 10 (강제형변환 : int)
	 * [공식화]
	 * (Math.random() * 랜덤값 개수)+시작수
	 * 11~20사이의 숫자 중 랜덤값
	 * (Math.random() * 10)+11

	public void method6() {
		// 1. random으로 난수 발생
		// 2. 난수의 범위를 조정
		int random = (int)(Math.random()*10)+1;
		System.out.println(random);
		
		// 3. for문 및 출력
		int sum = 0;
		// 1~10까지 랜덤값 발생
		for(int i=1; i<=random; i++) {
			//랜덤값의 누적합 계산
			sum+=i;
		}
		System.out.printf("1부터 %d까지의 총 합은 %d이다",random,sum);
	}
	public void method7() {
		// 1에서부터 10까지의 정수 중에서
		// 홀수만 출력하겠다.
		// for문 한개로 끝낸 버전 => 반복 5번(효율적)
		for(int i=1; i<= 10; i += 2) {
			System.out.print(i + " ");
			
		}
		System.out.println();
		// for문 + if문 => 반복 10번(비효율적)
		for(int i=1; i<=10; i++) {
			if(i%2==1) {
				System.out.print(i+" ");
			}
		}
	}
	public void method8() {
		// 구구단 2단
		for(int i=1; i<=9; i++) {
			System.out.printf("2 * %d = %d \n",i,(2*i));
		}
	}
	public void method9() {
		// 사용자로부터 단수를 입력받아
		// 해당 단수의 구구단을 출력
		System.out.println("====구구단 생성기====");
		Scanner sc = new Scanner(System.in);
		System.out.print("2~9 사이의 단수 입력 : ");
		int gugudan = sc.nextInt();
		sc.nextLine();
		
			if(gugudan>=2 && gugudan<=9) {
				for(int i=1; i<=9; i++) {
					System.out.printf("%d * %d = %d \n"
							,gugudan,i,(gugudan*i));
				}
			}else {
				System.out.println("단수를 잘못 입력하셨습니다.");
			}
	}
	public void method10() {
		// 2단부터 9단까지 모두 다 출력하기
		// 9단 먼저 찍고 확장
		// 규칙을 찾자!
		// 9라는 단수 부분이 2,3,4,5,6,7,8,9 => 2~9까지 1씩 증가
		// [에러메세지]
		// Duplicate local variable i
		// Variable이 중복되면 발생한다.
		for(int i=2; i<=9; i++) { // 8번
			System.out.println("-----"+i+"단-----");
			for(int j=1; j<=9; j++) { // 9번
				System.out.printf("%d * %d = %d \n",i,j,(i*j));
			}
		}
		// 총 반복횟수 : 72번
	}
	public void method11() {
		// 1 2 3 4 5
		// 1 2 3 4 5
		// 1 2 3 4 5
		
		// i = 0 : j = 1 2 3 4 5
		// i = 1 : j = 1 2 3 4 5
		// i = 2 : j = 1 2 3 4 5 
		for(int i=0; i<3; i++) {
			for(int j=1; j<=5; j++) {
				System.out.print(j+" ");
			}
			System.out.println();
		}
	}
	public void method12() {
		
		// *****
		// *****
		// *****
		// *****
		
		// 세로
		/*
		for(int i=0; i<4; i++) {
			// 가로
			for(int j=0; j<5; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		*/
		
		// 애초부터 반복을 20번 돌린다.
		for(int i=0; i<20; i++) {
			System.out.print("*");
			// 0 1 2 3 4
			// 5 6 7 8 9
			// 10 11 12 13 14
			// 15 16 17 18 19
			if((i+1)%5 == 0 ) {
				System.out.println();
			}
		}
	}
	public void method13() {
		// 1***
		// *2**
		// **3*
		// ***4
		
		for(int i=1; i<=4; i++) {
			for(int j=1; j<=4; j++) {
				if(i==j) {
					System.out.print(j);
				}else {
					System.out.print("*");
				}
			}
			System.out.println();
		}
	}
	// for문 안에 for문을 겹쳐 쓸 경우, "중첩 for문"이라고도 부른다.
	// if문 안에 if문을 겹쳐 쓸 경우, "중첩 if문"이라고도 부른다.
	public void method14() {
		
		/*
		 * 사용자로부터 문자를 입력받아
		 * 3자리에 있는 문자를 출력하시오.
		 * 문자 입력 : Hello
		 * 1번째 문자 : H
		 * 2번째 문자 : e
		 * 3번째 문자 : l
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("문자열 입력 : ");
		String str = sc.nextLine();
		/*
		 * char ch1 = str.charAt(0);
		 * char ch2 = str.charAt(1);
		 * char ch3 = str.charAt(2);
		 */
		for(int i=0; i<3; i++) {
			System.out.println((i+1)+"번째 문자 : " + str.charAt(i));
		}
		
	}
	public void method15() {
		/*
		 * 아무 문자열이나 입력하세요. : 
		 */
		
		// 문자열을 무한으로 반복하면서 매번 입력받기
		// 만약, 입력받은 문자열이 "exit"라는 문자열이라면 종료
		// [오류메세지]
		// break cannot be used outside of a loop or a switch
		// break문은 반복문이나 switch문 안에서만 쓰일 수 있다.
		Scanner sc = new Scanner(System.in);
		
		// i=0; true; i++ : 조건식을 생략하거나 true를 입력하면 무한반복이 일어난다.
		// i=0; i<2;  :증감식을 생략하면 무한반복이 일어난다.
		// i=0; i<2; i+=0 : 증감을 0씩 하면 무한반복이 일어난다.
		// ;; : 전부 생략해도 무한반복이 일어난다.
		for(int i=0; true; i++) {
			System.out.print("아무 문자열이나 입력받으세요 : ");
			String str = sc.nextLine();
			// switch(str) { case "exit" : ~ }
			if(str.equals("exit")) { 
				System.out.println("프로그램을 종료합니다.");
				// 종료시키는 구문
				// 나를 호출했던 구문으로 돌아감 (a.method15();)
				return;
				// break도 가능하다.
				// 다만, switch에서의 break와 반복문에서의 break는
				// 역할이 다르다.(분기문에서 배우게 될 예정)
			}else {
				System.out.println("입력된 문자열 : "+str);
			}
		}
	}
	public void method16() {
		/*
		 * 사용자로부터 2개의 정수 값을 입력받아,
		 * 그 사이에 숫자를 모두 출력하는 프로그램을 작성하라.
		 * 예시
		 * 정수1 입력 : 3 
		 * 정수2 입력 : 8
		 * 3 4 5 6 7 8
		 * 조건문과 for문을 이용하시오.
		 */
		Scanner sc = new Scanner(System.in);
		System.out.print("정수1 입력 : ");
		int num1 = sc.nextInt();
		System.out.print("정수2 입력 : ");
		int num2 = sc.nextInt();
		// 정수가 입력되지 않았을 때는
		// 1. Math.round() 또는 Math.ceiling()으로 반올림,반내림을 수행
		// 2. try{ }catch{ }를 통해서 오류에 대한 예외처리 하기.(나중에 배움)
		
		if(num1 < num2) {
			for(int i=num1; i<=num2; i++) {
				System.out.print(i+" ");
			}
		}else if(num1 > num2) {
			//for(int i=num2; i<=num1; i++){
			//System.out.println(i+" ");
		    //}
			for(int i=num1; i>=num2; i-- ) {
				System.out.print(i+" ");
			}
		}else {
			System.out.print("값이 동일합니다.");
		}
	}
}

while문

 * 반복문의 일종으로 조건식의 결과가 true일 경우에만 반복을 진행
 * 조건식의 결과가 false인 경우, 반복문을 빠져나옴.
 * 
 * [표현법]
 * [기본]
 * while(조건식 - true/false){
 * 		반복적으로 실행할 내용물;
 * }
 * 
 * [응용]
 * 초기식; : 반복에 필요한 변수를 선언 및 초기화(필수 아님)
 * while(조건식 - true/false){
 * 		반복적으로 실행할 내용물;
 * 		증감식;(필수 아님)  
 * }
 * 
 * [응용2]
 * while(true){
 * 		반복적으로 실행할 내용물;
 * }
 * => 무한반복이 일어남.

package com.kh.chap02.loop;
import java.util.Scanner;

public class B_while {

	public void method1() {
		
		int i=0; // 초기식
		while(i<5) { //조건식
			System.out.println("안녕하세요");
			i++; // 증감식
		}
		System.out.println("i = "+i);
		// 이 시점에서 i는 5이다.
		
		System.out.println();
		while(i>=1) {
			System.out.println("i = "+--i); 
			//i--;
			
			/*
			 *System.out.println("i = "+(i--));
			 *5,4,3,2,1
			 *System.out.println("i = "+(--i));
			 *4,3,2,1,0
			*/
		}
		System.out.println("i = "+i);
		// 이 시점에서 i는 0이다.
	}
	public void method2() {
//		1에서부터 10까지의 총 합계
//		int sum = 0;
//		for(int i=1; i<=10; i++) {
//			sum += i;
//		}
//		System.out.println("총 합계 : "+sum);
		
		int i=1;
		int sum=0;
		while(i<=10) {
			sum += i;
			i++;
		}
		System.out.println("총 합계 : "+sum);
	}
	public void method3() {
//		1에서부터 랜덤값(1~100)까지의 총 합계
//		int random = (int)((Math.random()*100)+1);
//		int sum=0;
//		for(int i=1; i<=random; i++) {
//			sum = sum+i;
//		}
//		System.out.println("i : "+random);
//		System.out.println("랜덤 총합계 : "+sum);

		int i=1;
		int sum=0;
		int random = (int)((Math.random()*100)+1);
		while(i<=random) {
			sum = sum+i;
			i++;
		}
		System.out.println("i : "+i);
		System.out.println("랜덤 총합계 : "+sum);
	}
	public void method4() {
		/*
		 * 아무 문자열이나 입력하세요 : ~~
		 * 문자열을 무한반복하면서 매번 입력받기
		 * 입력받은 문자열이 exit라는 문자열이라면 종료
		 */
		Scanner sc = new Scanner(System.in);
		//for(;;) : 횟수가 있을 때, 쓰기 유리함.
		while(true) { //무한반복을 사용할 때 유리함.
			System.out.print("아무 문자열이나 입력하세요 : ");
			String str = sc.nextLine();
			System.out.println("입력 문자 : "+str);
				if(str.equals("exit")) {
					System.out.println("프로그램을 종료합니다.");
					return;
				}
		}
	}

do-while문

 * do로 우선 실행을 하고, while을 통해 조건을 제시한다.
 * 
 * [표현법]
 * 초기식;
 * do{
 * 	실행할 코드;
 * 	증감식;
 * }while(조건식);
 * 
 * 조건식이 true이면? 실행할 코드를 다시 실행.
 * 조건식이 false이면? 그래도 do문을 실행하고 빠져나온다.
 * 즉, while문은 조건 검사를 먼저 하고, true여야지만 실행.
 * do-while문은 일단 실행을 하고 나서, 조건 검사를 하여 true이면 돌아가서 실행
 * 최초의 while문이 false여도 최소 한번은 실행함.

	public void method5() {
		int i=0;
		do {
			System.out.println("하이"); // 내용물이 한번은 실행됨.
		}while(i==1);
	}
	public void method6() {
		// 1 2 3 4 5 
		// for문
		for(int i=1; i<=5; i++) {
			System.out.print(i + " ");
		}
	
		// while문
		int i=1;
		while(i<=5) {
			System.out.print(i+" ");
			i++;
		}
        
		//do-while문
		int j=1;
		do {
			System.out.print(j + " ");
			j++;
		}while(j<=5); // j가 6이면 do문을 벗어나서 실행이 종료됨.
	}
}

break문

 * break문을 만나는 순간
 * "현재 내 위치로부터 가장 가까운 반복문 한 겹"을
 * 빠져나가게끔 해주는 구문
 * 즉, 해당 break문이 속해 있는 반복문 한 겹을 빠져나감.
 * 
 * [표현법]
 * break;
 * 
 * [주의할점]
 * 분기문에서의 break와 switch문에서의 break는 다른 개념임.
 * switch에서의 break문은 단순히 해당 switch영역을 빠져나가는 용도일 뿐.
 * 반복문에서의 break문은 break문의 위치에서 한겹을 빠져나가는 것임.
 *
 * [return과 break의 차이점]
 * break의 경우, 해당 while문을 한겹 빠져나가 무한반복문을 빠져나가고 다음 코드로 진행함.
 * return의 경우, a.method1();로 다시 가기 때문에
 * 무한반복의 while문을 벗어나지 못하여 반복문 다음의 코드를 진행하지 못함.
 *
 * [오류메세지]
 * Unreachable code

package com.kh.chap03.branch;
import java.util.Scanner;

public class A_Break {

	public void method1() {
		// 매번 반복적으로 새로이 발생되는 랜덤값(1~100)출력
		// 단, 랜덤값이 홀수일 경우에는 반복문을 빠져나가게끔.
		int i=0;
		int random=0;
		while(true) {
			random = (int)((Math.random()*100)+1);
			if(random%2==1) { // 홀수 판별
				// return;	
				// 이 구문이 실행된 시점으로 본다면, 이미 반복을 통해 판별을 끝냈을 것.
				// 즉, 홀수가 나오면 프로그램이 종료되기에, 결과는 짝수만 나옴.
				break;
				// 마찬가지로 홀수가 나오면 프로그램이 종료되기에, 결과는 짝수만 나옴.
			}
			System.out.println("랜덤 : "+random); // 홀수 이외의 값을 출력
		}
		// while문의 반복이 끝났을 시점.
		System.out.println("끝났습니다."); // return일시, 도달하지 못함.
	}
	public void method2() {
		/*
		 * 아무 문자열이나 입력하세요. : 
		 */
		// 문자열을 무한으로 반복하면서 매번 입력받기
		// 그 문자열의 길이를 출력하고
		// 만약, 입력받은 문자열이 "exit"라는 문자열이라면 종료
		
		Scanner sc = new Scanner(System.in);

		while(true) {
			System.out.print("아무 문자열이나 입력하세요 : ");
			String str = sc.nextLine();
			if(str.equals("exit")) { // 문자열이 exit인 경우
				// return;
				break;
			}else {	// 문자열이 exit가 아닌 경우
				// 문자열.length()
				// .length()의 결과는 정수형으로 나옴.
				System.out.println("\""+str+"\"" + " 의 길이 : "+str.length());
			}
		}
		// return시, Unreachable Code
		// break가 없을시, Unreachable Code
		// break시, while문을 빠져나와 아래의 코드를 출력.
		
		System.out.println("프로그램을 종료합니다.");
	}
	public void method3() {
		
		// 매번 반복적으로 사용자에게 양수를 입력받아
		// 1 ~ 입력값까지 출력
		// 정상적으로 양수를 입력했을 경우, 결과를 출력 후 무한반복을 빠져나옴.
		// 아닐 경우, 다시 입력하라는 문구를 출력.
		Scanner sc = new Scanner(System.in);
		while(true) {
			System.out.print("양수 입력 : ");
			int num = sc.nextInt();
			if(num>0) { // 양수일 경우
				for(int i=1; i<=num; i++) {
					System.out.print(i+" ");
				}
				break; // while문을 빠져나감.
			}else { // 양수가 아닐 경우
				System.out.println("다시 입력해주세요.");
			}
			System.out.println();
		}
	}
}

continue문

 * 반복문 안에서 사용하는 구문
 * continue를 만나게 되면, 그 뒤에 어떤 구문이 있더라도 실행하지 않고
 * 가장 가까운 반복문으로 올라감.

package com.kh.chap03.branch;
import java.util.Scanner;

public class B_Continue {

	public void method1() {
		// 1에서부터 10까지 숫자 중 홀수만 출력
		// 1 3 5 7 9
		// 1. 증감식을 2씩 증가하여 출력
		for(int i=1; i<=10; i+=2) {	// 5회 반복
			System.out.print(i+" ");
		}
		System.out.println();
		// 2. 조건문에 %을 사용하여 출력
		for(int i=1; i<=10; i++) {	// 10회 반복
			if(i%2==1) {
				System.out.print(i+" ");
			}
		}
		System.out.println();
		// 3. 반복문 안에서 continue 이용
		for(int i=1; i<=10; i++) {
			
			// i가 짝수일 경우를 판별해냄
			if(i%2==0) {
				continue;	// 짝수이면, continue를 통해 다시 반복문으로 돌아감
			}
			// i가 홀수일 경우, 출력
			System.out.print(i+" ");
		}
	}
    
	public void method2() {
		// 1부터 100까지의 총 합계
		// 단, 6의 배수는 빼고 계산
		int sum=0;
		for(int i=1; i<=100 ; i++) {
			if(i%6==0) { // 6의 배수를 판별
				continue;	// 해당 증감을 수행하지 않고, 다음 i++로 이동.
							// i=5 => i=6(continue, 수행x) => i=7
			}
			sum=sum+i;
			System.out.println(i+" ");
		}
		System.out.print("6의 배수를 제외한 1~100의 합 : "+sum);
	}
    
	/*
	 * continue가 for문 안에 있을 경우 => 증감식으로 이동한다.
	 * continue가 while문 안에 있을 경우 => 조건식으로 이동한다.
	 */
	public void method3() {
		// 2단 ~ 9단 까지 출력하긴 하되
		// 4의 배수단만 건너뛰고 출력하시오.
		for(int i=2; i<=9; i++) { // 바깥쪽 for문 : 단수
			System.out.println("====="+i+"단 =====");
//			1. 4단,8단을 건너뛰기
//			if(i==4 || i==8) {
//				continue;	// i가 4인경우, 이를 실행하지 않고 i++로 이동.
//							// 4단은 출력되지 않고 5단으로 넘어감.
//			}
//			2. 4의 배수를 건너뛰기
			for(int j=1; j<=9; j++) { // 안쪽 for문 : 곱하기 1~9
				 if(i%4==0){
				 		continue;
				 }
				System.out.printf("%d * %d = %d \n",i,j,(i*j));
			}
		}
		System.out.println("구구단 종료");
	}
    
	// 반복문 실습문제 12번 - 계산기 만들기 + exit입력시 빠져나가기
	public void method4() {
		/*
		 * 정수 2개와 연산자를 입력받아
		 * 단, 나눗셈 몫(나머지)일 경우, 0으로 나누려고 할때
		 * "다시 입력해주세요"
		 * 없는 연산자의 경우
		 * "없는 연산자입니다. 다시 입력해주세요"
		 * exit를 입력시
		 * "프로그램을 종료합니다"를 출력 후 빠져나감.
		 * 
		 */
		Scanner sc =new Scanner(System.in);
		while(true) {
			System.out.print("연산자(+,-,*,/,%) : "  );
			String operator = sc.nextLine();

			
			// exit입력 시 탈출
			if(operator.equals("exit")) {
				System.out.println("프로그램을 종료합니다.");
				break;
			}
			// 숫자를 입력받기 전에 "없는 연산자~" 문구를 미리 띄울 수 있음!
			if(operator.equals("+")||
			   operator.equals("-")||
			   operator.equals("*")||
			   operator.equals("/")||
			   operator.equals("%")){ // 일치하는 연산자인지 확인함.
				
				System.out.print("정수1 입력 : ");
				int num1 = sc.nextInt();
				sc.nextLine();
				System.out.print("정수2 입력 : ");
				int num2 = sc.nextInt();
				sc.nextLine();
				
				switch(operator) {
				case "+" : System.out.println(num1 + " + " +num2 + " = " + (num1+num2));break;
				case "-" : System.out.println(num1 + " - " +num2 + " = " + (num1-num2));break;
				case "*" : System.out.println(num1 + " * " +num2 + " = " + (num1*num2));break;
				case "/" : 
					if(num2==0) {
						System.out.println("0으로 나눌 수 없습니다. 다시 입력하세요.");
						continue;	// 가장 가까운 반복문인 while문으로 돌아감.(올라감)
					}else {
						System.out.println(num1 + "/" +num2 + " = " + (num1/num2));
						break;	// while문을 빠져나감.(내려감)
					}
				case "%" : 
					if(num2==0) {
						System.out.println("0으로 나눌 수 없습니다. 다시 입력하세요.");
						continue;
					}else {
						System.out.println(num1 + "%" +num2 + " = " + (num1%num2));
						break;
					}
				}
			}else { // 일치하지 않는 연산자.
				System.out.println("없는 연산자입니다. 다시 입력해주세요.");
			}	
		}
	}
}