[java] 5. 제어문 (선택문, 반복문, 기타제어문)

1. 제어문(Control Statement)이란?

• 프로그램의 흐름을 바꾸어 주는 구문
• 제어문에 의해 프로그램의 흐름이 약간씩 변경됨
• 선택문 : if / switch
• 반복문 : for / while / do-while
• 기타제어문 : break문 / continue문 / return문

 

 

2. 선택문

• 명령을 선택 실행할 수 있도록 해주는 것
• 선택문을 만들 때는?
  • 포괄적인 형태라면? - if
  • 간단한 형태 라면? - switch
• 선택문의 변환 여부는?
  • [ switch -> if ] 가능
  • [ if -> switch ] 가능도 있고 불가능도 있음

 

1) if문

• 조건식에 의해 명령을 선택 실행하는 구문
• 반드시 조건식이 나와야함
• 조건식 : false or true를 발생하는 식 (관계연산자, 논리연산자 이용)
• {} 안에 작성된 명령이 하나인 경우 {} 기호 생략 가능

 
🐷if문은 언제사용?

• 입력과 검증할 때 많이 사용
• 다양한 형태의 명령을 선택 실행할 때 사용 (어떤 범위 안의 실행)

 
🐷 if문 형식

//조건식의 결과가 참(true)인 경우 {}안의 명령들을 실행 , 거짓(false)이면 명령 실행 안함
if (조건식) {
	명령;
	명령;
}

 
 
🐷 if- else문 형식

//조건식의 결과가 참(true)인 경우와 거짓(false)인 경우를 구분하여 {} 안에 작성 (선택실행)
if (조건식) {
	명령;
	명령;
	...
} else {
	명령;
	명령;
	...
}

 
 
🐷 if- else if - [else]문 형식

//조건식이 여러 개인 경우 명령을 구분하여 실행 - else 생략 가능
if (조건식) {
	명령;
	명령;
	...
} else if (조건식) {
	명령;
	명령;
	...
} [else {
	명령;
	명령;
}]

 
 
🐷 if문 예제
 

예제 1) 변수 값이 50이상인 경우에만 화면에 변수값 출력

//1.
int su = 90;
if(su>50) {
	System.out.println("su = "+ su);
}
//su = 90

//2.
int su = 40;
if(su>50) {
	System.out.println("su = "+ su);
}
//출력안됨

//3.
//{} 안에 명령이 하나이므로 {}기호 생략
int su =90;
if(su>50) System.out.println("su = "+ su);
//su = 90

 

 

예제 2) 변수값이 60이상인 경우 합격메세지를 출력

int score = 80;
if(score >= 60) {
	System.out.println("[결과] 점수가 60점 이상이므로 합격입니다.");
}
//[결과] 점수가 60점 이상이므로 합격입니다.

 

 

예제 3) 변수값이 60이상인 경우 합격메세지를 출력하고 60 미만인 경우 불합격 메세지를 출력

//int score=80;
int score=50;

//방법1.
if(score>=60) {
	System.out.println("[결과]점수가 60점 이상이므로 합격입니다.");
}

if(score<60) {
	System.out.println("[결과]점수가 60점 미만이므로 불합격입니다.");
}

//방법2.
//if - else문 이용
//=> 가독성이 좋음
//=> 조건식을 한번만 쓰면 되니 유지보수의 효율성도 높음
//=> if를 2번 쓰는 것보다 1번 쓰는 것이 더 효율적
if(score >= 60) {
	System.out.println("[결과] 점수가 60점 이상이므로 합격입니다.");
}
else {
	System.out.println("[결과] 점수가 60점 미만이므로 불합격입니다.");
}
//[결과] 점수가 60점 미만이므로 불합격입니다.

 

예제 4) 변수값을 홀수 또는 짝수로 구분하여 출력

//[배수를 표현할 때 쓰는 연산식]
//=> X % Y == 0  이 true라면 : x는 y의 배수이다.

int num = 9;   
if(num % 2 != 0) {
	System.out.println(num + " >> 홀수");
}
if(num % 2 == 0) {
	System.out.println(num + " >> 짝수");
}
//9 >> 홀수

int num = 10;
if(num % 2 != 0) {
	System.out.println(num + " >> 홀수");
}
else {
	System.out.println(num + " >> 짝수");
}
//10 >> 짝수

 

예제 5) 문자변수에 저장된 문자값을 영문자와 비영문자로 구분하여 출력

//if ( mun>='A' && mun <= 'Z' )
//=> 변수에 저장된 문자값이 'A' ~ 'Z'에 있나요? 와 같은 뜻

//사용자로부터 어떤 값을 입력받을 때 반드시 입력값이 유효한지 검증 필수이므로 
//데이터에 대한 검증할 때 if 제어문 많이 씀
//검증을 통해 유효한 값일 때만 계산과 출력을 해줌

//[범위를 표현할 때 쓰는 연산식]
//=> (x >= 작은값 && x <= 큰값) : x는 작은값 ~ 큰값 사이의 번위 안에 표현되는 값


char mun= 'O';//영문자 대문자 O임
//char mun= '0';      

// ()묶지 않아도  &&, || 중 &&부터 실행됨!!!!
if(mun>='A' && mun<='Z' || mun>='a' && mun<='z') {
	System.out.println("[결과]" + mun + " >>영문자");
} else {
	System.out.println("[결과]" + mun + " >>비영문자");
}
//[결과]O >>영문자
//[결과]0 >>비영문자

 

예제 6) 조건식 대신 boolean 변수값을 이용하여 명령 선택 실행 가능 - 부정소거법

//부정소거법
//=> 부정에 대한 명령을 실행하는 경우가 효율적일 경우 : ! 붙여서 프로그램 만들자!!!!!
//=> 입력과 검증할 때 많이 사용

//boolean 변수 - 상태를 저장해 선택 실행가능
//ex) 
//boolean 마우스누른상태 = true;
//if (마우스누른상태) { 명령; }

boolean sw = true;
if(sw) { //sw == true로 표현안해도 됨!
	System.out.println("현재 변수 값은 [참]입니다.");
} else {
	System.out.println("현재 변수 값은 [거짓]입니다.");
}
//현재 변수 값은 [참]입니다.

boolean sw = false;
if(!sw) { //true일때 실행해주세요~
	System.out.println("현재 변수 값은 [거짓]입니다.");
} else {
	System.out.println("현재 변수 값은 [참]입니다.");
}
//현재 변수 값은 [거짓]입니다.

 

예제 7) 변수값이 0 ~ 100 범위의 유효값인지 아닌지를 구분하여 출력 - 입력값의 유효성 검증

int jumsu = 85;
if(jumsu >= 0 && jumsu <= 100) {
	System.out.println("[결과] 0 ~ 100 범위의 정상적인 값이 입력 되었습니다.");
} else {
	System.out.println("[에러] 0 ~ 100 범위를 벗어난 비정상적인 값이 입력 되었습니다.");
}
//[결과] 0 ~ 100 범위의 정상적인 값이 입력 되었습니다.

 

예제 8) 변수값으로 등급을 구분하여 출력

//모든 조건이 다 거짓이라면 grade변수는 아무런 값도 저장되지 않아 출력되지 않으므로 주의
///컴파일러는 조건문이 맞는지 아닌지 판단 불가능하므로, 반드시 변수를 초기화해주어야 함
//컴파일러 = 번역o, 실행x
//제어문 안에서 사용하는 변수는 변수를 선언할 때 초기값을 저장해서 사용하는 것을 권장


int jumsu = 85; //[결과]85점 >>B학점입니다.
//int jumsu = 95; //[결과]95점 >>A학점입니다.
//int jumsu = 1000; //[에러] 0 ~ 100 범위를 벗어난 비정상적인 값이 입력 되었습니다.


//방법1.
// 100~90:A , 89~80:B, 79~70:C, 69~60:D , 59~0:F
if(jumsu >= 0 && jumsu <= 100) {
	//변수값으로 등급을 구분하여 출력
	// 100~90:A , 89~80:B, 79~70:C, 69~60:D , 59~0:F
	String grade= ""; //등급을 저장하기 위한 변수 - 초기값 설정

	if(jumsu <= 100 && jumsu >= 90) {
		grade = "A";
	}
	if(jumsu <= 89 && jumsu >= 80) {
		grade = "B";
	}
	if(jumsu <= 79 && jumsu >= 70) {
		grade = "C";
	}
	if(jumsu <= 69 && jumsu >= 60) {
		grade = "D";
	}
	if(jumsu <= 59 && jumsu >= 0) {		
		grade = "F";
	}    
    System.out.println("[결과]" + jumsu+ "점 >>" +grade+ "학점입니다.");
} else {
    System.out.println("[에러] 0 ~ 100 범위를 벗어난 비정상적인 값이 입력 되었습니다.");
}
 //[결과]85점 >>B학점입니다.

//방법2.
//if - else if - [else]문
//조건이 맞다면 명령을 실행하고 바로 나갈 수 있음
//위의 IF문 5개는 조건을 5번 확인하므로 if - else if문이 더 효율적임
if(jumsu >= 0 && jumsu <= 100) {
	String grade= "";
	if(jumsu <= 100 && jumsu >= 90) {
	  grade = "A";
	} else if(jumsu <= 89 && jumsu >= 80) {
	  grade = "B";
	} else if(jumsu <= 79 && jumsu >= 70) {
	  grade = "C";
	} else if(jumsu <= 69 && jumsu >= 60) {
	  grade = "D";
	} else if(jumsu <= 59 && jumsu >= 0) {
	  grade = "F";
	}
	  System.out.println("[결과]" + jumsu+ "점 >>" +grade+ "학점입니다.");
} else {
	  System.out.println("[에러] 0 ~ 100 범위를 벗어난 비정상적인 값이 입력 되었습니다.");
}
 //[결과]85점 >>B학점입니다.

//방법3.
if(jumsu >= 0 && jumsu <= 100) {
	String grade= "";
	if(jumsu >= 90) {
		grade = "A";
	} else if(jumsu >= 80) {
		grade = "B";
	} else if(jumsu >= 70) {
		grade = "C";
	} else if(jumsu >= 60) {
		grade = "D";
	} else {//모든 조건식이 거짓인 경우 실행될 명령
		grade = "F";
	}
    	System.out.println("[결과]" + jumsu+ "점 >>" +grade+ "학점입니다.");
} else {
	System.out.println("[에러] 0 ~ 100 범위를 벗어난 비정상적인 값이 입력 되었습니다.");
}

//[결과]85점 >>B학점입니다.

 

예제 9) 변수에 저장된 문자값을 출력하세요.
(단, 변수에 저장된 문자값이 소문자인 경우 대문자로 변환하여 출력하세요.)

//🚩my answer
char mun='x';
if(mun>='a' && mun <='z') {
	mun = (char)(mun - 32);
}
System.out.println("mun = "+mun); //mun = X


// answer
// -= 이용하면 더 효율적
char mun='a';
if(mun>='a' && mun <='z') { //변수값이 소문자인 경우
	//형변환 일어나지 않으므로 강제형변환 할 필요 없음(유용)
	mun -=32; //변수값을 대문자로 변환
}
System.out.println("mun = "+mun);
//mun = X

 

예제10) 변수에 저장된 정수값이 4의 배수인지를 구분하여 출력하세요.

//🚩my answer
int num=345644;
if(num % 4 == 0) {
	System.out.println("4의 배수가 맞습니다.");
}else {
	System.out.println("4의 배수가 아닙니다.");
}
//4의 배수가 맞습니다.

//answer
int num=345644;
if(num % 4 == 0) {
	System.out.println("[결과]" +num+" >> 4의 배수가 맞습니다.");
}else {
	System.out.println("[결과]" +num+" >> 4의 배수가 아닙니다.");
}
//[결과]345644 >> 4의 배수가 맞습니다.

 

예제11) 올해가 평년인지 윤년을 구분하여 출력하세요. - 달력만들 때 사용

→ 년도를 4로 나누어 나머지가 0인 경우 윤년

→ 위 조건을 만족하는 년도 중 100으로 나누어 나머지가 0인 경우 평년

→ 위 조건을 만족하는 년도 중 400으로 나누어 나머지가 0인 경우 윤년

//🚩my answer
int year=2021;
if(year % 4 == 0) {
	if( year % 100 == 0) {
    	if(year % 400 == 0) {
		System.out.println("윤년입니다.");
		}
		System.out.println("평년입니다.");
	}
}else {
	System.out.println("평년입니다.");
	}
//평년입니다.

//answer
int year=2021;
   //윤년의 조건1                        //윤년의조건2  -> 둘 중 하나만 만족하면 윤년
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
	System.out.println("[결과]" + year + "년은 윤년입니다.");
} else {
	System.out.println("[결과]" + year + "년은 평년입니다.");
}
//[결과]2021년은 평년입니다.

 

예제12) 이름이 [홍길동]인 학생이 국어점수 89점, 영어점수 93점, 수학점수 95점을 받은 경우 총점과 평균, 학점을 계산하여 이름, 총점, 평균, 학점을 출력하세요.

→ 국어,영어,수학 점수 중 하나라도 0~100 범위가 아닌 경우 프로그램 강제 종료

→ System.exit(0) : 프로그램을 강제로 종료하는 메소드

→ 평균을 이용한 학점 계산 : 100~90:A, 89~80:B, 79~70:C, 69~60:D, 59~0:F

→ 평균은 소숫점 두자리까지만 출력하고 나머지는 절삭 처리 하세요.

//🚩my answer
String name = "홍길동";
int kor = 89, eng = 93, mat = 95;
int tot = kor + eng + mat;
double average = tot /3.0;
String point = "F";
if(!(0<=kor&&kor<=100) || !(0<=eng&&eng<=100) || !(0<=mat&&mat<=100)) {
	System.out.println("입력하신 점수가 0 이상 100 이하가 아닙니다.");
	System.exit(0);
}else {
	if(average >= 90.0) {
		point = "A";
	}else if (average >= 80.0) {
		point = "B";
	}else if (average >= 70.0) {
		point = "C";
	}else if (average >= 60.0) {
		point = "D";
	}else {
		point = "F";
	}
System.out.println("이름 = " + name);
System.out.println("총점 = " + tot);
System.out.println("평균 = " + (int)(average*100)/100.0);
System.out.println("학점 = " + point);
//이름 = 홍길동
//총점 = 293
//평균 = 92.33
//학점 = A


//answer 1. 계산, 출력하기 전에 유효성 검사하기 (입력값 검증)
String name = "홍길동";
int kor = 89, eng = 93, mat = 1000;
//계산, 출력하기 전에 유효성 검사하기 (입력값 검증)
if(kor<0 || kor>100 || eng<0|| eng>100 || mat<0 || mat>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 점수가 입력되었습니다.");
	System.exit(0);
}
int tot = kor + eng + mat;
double average = tot /3.0;
String grade = "";
switch ((int)average/10) {
case 10:
case 9: grade="A"; break;
case 8: grade="B"; break;
case 7: grade="C"; break;
case 6: grade="D"; break;
default: grade="F";
}
//[에러] 0 ~100 범위를 벗어난 비정상적인 점수가 입력되었습니다.


//answer 2. 좀 더 친절한 프로그램으로 만들어주기
//=> 명확하게 어떤 입력값이 잘못되었을지 알려주고 프로그램 종료하기
//=> 단점) 1개라도 입력값이 잘못되었으면, 뒤에 값은 확인하지 않고 바로 프로그램을 종료한다..ㅠ
//=> 3과목 다 비교한 뒤 프로그램을 종료시킬 수는 없을까? answer3 확인하기
String name = "홍길동";
int kor = 89, eng = 93, mat = 95;
if(kor<0 || kor>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 국어점수가 입력되었습니다.");
	System.exit(0);
if(eng<0 || eng>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 영어점수가 입력되었습니다.");
	System.exit(0);
}
if(mat<0 || mat>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 수학점수가 입력되었습니다.");
	System.exit(0);
}
int tot = kor + eng + mat;
double average = tot /3.0;
String grade = "";
switch ((int)average/10) {
case 10:
case 9: grade="A"; break;
case 8: grade="B"; break;
case 7: grade="C"; break;
case 6: grade="D"; break;
default: grade="F";
}
System.out.println("이름 = " + name);
System.out.println("총점 = " + tot);
System.out.println("평균 = " + (int)(average*100)/100.0);
System.out.println("학점 = " + grade);


//answer 3. 모든 오류 한꺼번에 알려준 뒤 프로그램 종료하기
//=> boolean valid 변수에 false를 저장
//=> 유효값이 아니라면, 사용자에게 [에러]메세지로 알려준 뒤 boolean valid 변수에 true 저장
//=> 만약에 vaild 변수값이 true 라면 검증실패니 프로그램을 종료시켜줄 수 있도록 System.exit(0); 작성
String name = "홍길동";
int kor = 89, eng = 93, mat = 95
//검증 결과를 저장하기 위한 변수 - false: 검증 성공, true: 검증 실패
boolean valid = false;
if(kor<0 || kor>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 국어점수가 입력되었습니다.");
    	//vaild에 true 저장
	valid = true;
}
if(eng<0 || eng>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 영어점수가 입력되었습니다.");
	valid = true;
}
if(mat<0 || mat>100) { //비정상적인 입력값인 경우
	System.out.println("[에러] 0 ~100 범위를 벗어난 비정상적인 수학점수가 입력되었습니다.");
	valid = true;
}
//만약에 vaild라는 변수값이 true라면 검증실패니 프로그램을 종료시켜주세요.
if(valid) { //입력값 검증이 실패된경우
	System.exit(0);
}
int tot = kor + eng + mat;
double average = tot /3.0;
String grade = "";
switch ((int)average/10) {
case 10:
case 9: grade="A"; break;
case 8: grade="B"; break;
case 7: grade="C"; break;
case 6: grade="D"; break;
default: grade="F";
}
System.out.println("이름 = " + name);
System.out.println("총점 = " + tot);
System.out.println("평균 = " + (int)(average*100)/100.0);
System.out.println("학점 = " + grade);

 
 

2) switch문 (switch-case문)

• 값을 비교하여 명령을 선택 실행하는 구문 - 실수값 비교 제외
• 비교대상 : 변수 or 연산식 o , 리터럴x
• 실수값 은 비교 불가능!!!!!!!!!! (정수값-byte,short,int,long, 문자값-char, 문자열-String 비교 가능)
• 값이 같은지만 비교할 수 있음
• switch는 무조건 같다만 가능!!!
• ex. 메뉴 프로그램 만들 때 사용하지만, switch문은 자바에서 거의 사용 안함

🐱 switch문의 형식

//switch의 값을 case에 작성된 비교값과 비교하였을 때 
//=> 비교값이 같은 경우면? 그 위치로부터 작성된 모든 명령을 실햄함
//=> 모든 비교값이 다른 경우면 ? default문에 작성된 명령 실행함 - default문은 생략 가능

//break문을 만나면 switch 구문 강제 종료
//[:(콜론)]  : 을 통해 값의 위치(position)를 표현해줌
//case의 값은 반드시 리터럴만 가능!!!!, 변수 사용 불가, 조건불가, 값(리터럴)만 사용가능
switch(비교대상){
	case 값1: 명령; 명령; ...  [break;]
	case 값2: 명령; 명령; ...  [break;]
	case 값3: 명령; 명령; ...  [break;]
  ...
	case 값8: 명령; 명령; ...  [break;]
	[default: 명령; 명령; ...]
}

 
 
🐱 switch문 예제
 

예제 1) 수성, 금성, 화성, 지구 예제

→ 정수값을 비교하여 switch문 실행

//1.
int choice = 1;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
case 3:
	System.out.println("화성으로 이동합니다.");
}
//수성으로 이동합니다.
//금성으로 이동합니다.
//화성으로 이동합니다.


//2.
int choice = 2;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
case 3:
	System.out.println("화성으로 이동합니다.");
}
//금성으로 이동합니다.
//화성으로 이동합니다.


//3.
int choice = 3;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
case 3:
	System.out.println("화성으로 이동합니다.");
}
//화성으로 이동합니다.


//4.
//switch의 값과 case의 값이 모두 다르면 명령 미실행
int choice = 4;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
case 3:
	System.out.println("화성으로 이동합니다.");
}
//


//5.
//switch의 값과 case의 값이 모두 다른 경우 default 위치의 명령 실행
int choice = 4;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
case 3:
	System.out.println("화성으로 이동합니다.");
default:
	System.out.println("지구로 이동합니다.");
}
//지구로 이동합니다.

 

 

예제 2) 수성, 금성, 화성, 지구 + break문 적용 예제

→ 정수값을 비교하여 switch문 실행

//1.
int choice = 1;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
    	break;
case 2:
	System.out.println("금성으로 이동합니다.");
    	break;
case 3:
	System.out.println("화성으로 이동합니다.");
    	break;
}
//수성으로 이동합니다.


//2.
int choice = 2;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
    	break;
case 2:
	System.out.println("금성으로 이동합니다.");
    	break;
case 3:
	System.out.println("화성으로 이동합니다.");
   	break;
}
//금성으로 이동합니다.


//3.
int choice = 1;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
case 2:
	System.out.println("금성으로 이동합니다.");
  	break;
case 3:
	System.out.println("화성으로 이동합니다.");
  	break;
}
//수성으로 이동합니다
//금성으로 이동합니다.


//4. case값 주의
//case의 값은 반드시 리터럴만 가능 - 변수 사용 불가, 조건불가, 값(리터럴)만 가능
//case의 값은 중복 선언하면 error 발생
int choice = 1;
switch(choice) {
case 1:
	System.out.println("수성으로 이동합니다.");
	//break;
//case 1: //error
case 2:
	System.out.println("금성으로 이동합니다.");
  	break;
//case num:  //error
	System.out.println("화성으로 이동합니다.");
  	break;
}

 

예제 3) 변수값이 0~100 범위의 유효값인지 아닌지를 구분하여 출력 - 입력값에 대한 유효성 검증

→ 연산식을 비교하여 switch문 실행

//1.
//if문 활용
int jumsu = 85;
if(jumsu>=0 && jumsu<=100) {
	System.out.println("[결과]0~100 범위의 정상적인 값이 입력 되었습니다.");
}else {
	System.out.println("[에러]0~100 범위을 벗어난 비정상적인 값이 입력 되었습니다.");
 }


//2.
//if문 속 switch문 작성
int jumsu = 85;
if(jumsu>=0 && jumsu<=100) {
	//변수값으로 등급을 구분하여 출력
	//100~90 : A, 89~80 : B, 79~70 : C, 69~60 : D, 59~0 : F
	String grade="";
	switch(jumsu) {
	case 100:
	case 99:
    	...
    	//언제다해?
	}
    	System.out.println("[결과]"+jumsu+"점 >> "+grade+"학점");
}else {
    System.out.println("[에러]0~100 범위을 벗어난 비정상적인 값이 입력 되었습니다.");
}


//3.
//점수를 10으로 나누기
//switch(조건식) 안에 연산식 넣기
int jumsu = 85;
if(jumsu>=0 && jumsu<=100) {
	//변수값으로 등급을 구분하여 출력
	//100~90 : A, 89~80 : B, 79~70 : C, 69~60 : D, 59~0 : F
	String grade="";	
	switch(jumsu / 10) { // [100/10 =10] ~ [99/10=9]
	case 10:
	case 9: grade = "A"; break;
	case 8: grade = "B"; break;
	case 7: grade = "C"; break;
	case 6: grade = "D"; break;
	default: grade = "F";
	}
	System.out.println("[결과]"+jumsu+"점 >> "+grade+"학점");
}else {
	System.out.println("[에러]0~100 범위을 벗어난 비정상적인 값이 입력 되었습니다.");
}
  //[결과]85점 >> B학점

 

예제 4) 하나,둘,셋 예제

→ 문자열(String)을 비교하여 switch문 실행 - jdk1.7에 추가

String kor = "둘";
String eng = "";

switch (kor) {
	case "하나": 
		eng = "One"; break;
	case "둘": 
		eng = "Two"; break;
	case "셋": 
		eng = "Three"; break;
}

System.out.println("[결과]" +kor+ "=" + eng);
//[결과]둘=Two

 
 
 

 
 

3. 반복문

• 조건을 이용해 명령을 반복 실행
• 프로그램의 흐름을 위로 다시 올릴 수 있는 유일한 제어문!
• 단일 스레드는 절대로 무한루프에 빠트리면 안돼!
• 다중 스레드는 일부러 무한루프에 빠트리기도 함

 

1) for문

• 명령에 대한 반복횟수가 정해져있는 경우 사용되는 반복문(Loop Statement)
• 문법상 횟수가 있는 경우에 더 효율적

 
🐺 for문 형식

//[초기식;]- 변수에 초기값을 저장하는 연산식
//[조건식;]- true or false를 만들어주는 식
//[증감식]- 변수값을 증가 또는 감소시키는 연산식
//반드시 [초기식;] [조건식;] [증감식]을 ;(세미콜론)으로 구분하기
//; 기호 반드시 2번 사용
for (초기식; 조건식; 증감식){
	명령; 명령; 명령; ...
}

//for문의 실행순서
//=> 초기식 → 조건식(참)  → {}안의 명령 실행 → 증감식 → 조건식(참) → {}안의 명령 실행 ... 의 반복
//=> 조건식(거짓)이면? 반복문 종료

 
 
🐺 향상된 for문 형식

//배열이나 컬렌션을 좀 더 쉽게 처리하기 위해 사용
//카운터 변수와 증감식 사용하지 않음
for ( 타입변수 : 배열 ){
	명령; 명령; 명령; ...
}

 
 
🐺for문을 잘 활용하려면?

• ⓐ 초기식, 조건식, 증감식 잘 쓰기
  • 만약 초기식, 조건식, 증감식 잘못 작성하면?
  • 반복이 한번도 안될 수 있음
  • 무한루프가 발생할 수 있음, terminate눌러서 강제 종료해야함 (뻘간색 네모 버튼)
• ⓑ 지역변수 i 활용 잘하기
  • i변수는 지역변수이므로 for문 내에서만 사용가능하다는 것 인지
  • 특히 알고리즘에서는 현재 i변수에 얼마가 저장되었고, 그것이 반복문에서 어떻게 사용되고있는지가 중요
  • 🍒 지역변수(Local Variable)란 ?
    { } 내부에 선언된 변수
    선언된 { } 내부에서만 사용 가능
    변수가 선언된 블럭이 종료되면 지역변수는 자동 소멸

// int i는 for문의 지역변수
for(int i=1; i<5; i++){
	//지역변수 i는 여기서만 사용 가능
}

• ⓒ 무한루프 발생의 가능성 알기
  • 조건식의 결과가 항상 참(true)인 경우 무한루프(무한반복)이 될 수 있으므로 주의!!!
  • 무한루프(무한반복)가 항상 나쁜 것은 아니나, 일반적인 프로그램을 만들 때 무한루프 만들어지지 않도록 주의해서 만들자 - 강제로 프로그램 종료 시켜야함
  • 일부러 무한루프 만드는 경우 ex. 네트워크 프로그램
• ⓓ 초기식, 증감식은 생략가능하다???
  • 초기식, 증감식은 ; 기호를 이용하여 나열 작성 가능함
  • 초기식, 조건식, 증감식 생략 가능하긴 함
  • 만약 조건식이 생략된 경우 무조건 참으로 처리됨 (ex. 무한루프 만들 때 조건식 작성 안함)

 
 
🐺 for문 예제

 

예제 1) "Java Programming"을 화면에 5번 출력

//1.
System.out.println("Java Programming");
System.out.println("Java Programming");
System.out.println("Java Programming");
System.out.println("Java Programming");
System.out.println("Java Programming");

//2.
for (int i = 1; i <= 5; i++) { //1,2,3,4,5
	System.out.println("Java Programming");
}

//3.
for (int i = 5; i >= 1; i--) { //5,4,3,2,1
	System.out.println("Java Programming");
}

//4.
for (int i = 2; i <= 10; i+=2) { //2,4,6,8,10
	System.out.println("Java Programming");
}

//Java Programming
//Java Programming
//Java Programming
//Java Programming
//Java Programming

 

예제 2) "1 2 3 4 5" 출력

for(int i = 1; i <=5; i++) {
	System.out.print(i+ "\t ");
}
//1 2 3 4 5

 

예제 3) "5 4 3 2 1" 출력

//1.
for(int i=1;i<=5; i++) {
	System.out.print((6-i) + "\t");
}
//5	4	3	2	1

//2.
for(int i=5;i>=1; i--) {
	System.out.print(i + "\t");
}
//5	4	3	2	1

 

예제 4) "2 4 6 8 10" 출력

//1.
for(int i=2; i<=10; i+=2) {
	System.out.print(i + "\t");
}

//2. 반복문 + 조건문 이용
for(int i=1; i<=10; i++) {
	if(i%2 == 0) {
		System.out.print(i + "\t");
	}
}
//2	4	6	8	10

 

예제 5) 1~100 범위의 정수들의 합계 계산

int tot =0;
//int tot =100;  //정수들의 합계를 저장할 초기값을 100으로 변경 ->  //1~100 범위의 정수들의 합계 = 5150

for(int i=1; i<=100; i++) {
	tot+=i;
}
System.out.println("1~100 범위의 정수들의 합계 = " + tot );
//1~100 범위의 정수들의 합계 = 5050

 

예제 6) 두 변수에 저장된 정수값 범위의 합계 계산

//1.
int begin=20, end=80;
int sum=0;
for (int i=begin; i<=end; i++) {
	sum += i; //sum = 20 + 21 + 22 + 23 + ... + 80
}
System.out.println(begin + "~" + end + " 정수들의 합계 = " +sum );
//20~80 정수들의 합계 = 3050


//2.
// 만약 두 변수에 저장된 정수값 범위가 바꼈다면?
//문제점) 합계 계산이 안됨
int begin=80, end=20;
int sum=0;
//for문의 조건식이 false이므로 {} 구간이 실행되지않음
for (int i = begin; i <= end; i++) {
	sum += i;
}
System.out.println(begin + "~" + end + "정수들의 합계 = " +sum );
//20~80정수들의 합계 = 0


//3.
//해결1) 시작값이 종료값보다 큰 경우 에러메세지 출력 후 프로그램 강제 종료
//=>System.exit(0);사용
int begin=80, end=20;
if(begin > end) {
	System.out.println("[에러] 시작값이 종료값보다 작아야 됩니다.");
	System.exit(0); //프로그램을 강제로 종료하는 메소드 호출
}
int sum = 0;
for (int i = begin; i <= end; i++) {
	sum += i;
}
System.out.println(begin + "~" + end + "정수들의 합계 = " +sum );
//[에러] 시작값이 종료값보다 작아야 됩니다.


//4.
//해결2) 시작값이 종료값보다 큰 경우 두 변수에 저장된 값을 서로 바꾸어 저장 후 계산
//=> 알고리즘(Algorithm) : 프로그램 작성 시 발생되는 문제를 해결하기 위한 명령의 모임(흐름)
//=> 치환알고리즘(Swap Algorithm) : 변수값을 서로 바꾸어 저장하는 알고리즘
int begin=80, end=20; 
if(begin>end) { //치환알고리즘
	int temp = begin;
	begin = end;
	end = temp;
}
int sum=0;
for (int i=begin; i<=end; i++) { //합계알고리즘
	sum += i;
}
System.out.println(begin + "~" + end + "범위의 정수들의 합계 = " +sum );
//20~80범위의 정수들의 합계 = 3050

 

예제 7) for문 내 지역변수를 2개( i, j) 선언한 예시

for(int i=1, j=5; i<=3; i++, j--) {
	System.out.println("i = " +i+ ", j =" + j );
}
//i = 1, j =5
//i = 2, j =4
//i = 3, j =3

 

예제 8) 조건식이 생략되면 무조건 참(true)으로 처리 - 무한루프 발생할 수 있음

int i = 1; //for 구문에 상관없이 계속 존재

//1.
for(; i<=4; i++) { // for 구문의 초기식 생략
	System.out.println(i + "\t");
}
//1
//2
//3
//4

//2.
for(; i>=1; i--) { //위의 식에 의해 i = 5가 이미 저장되어서 5,4,3,2,1이 출력됨
	System.out.println(i + "\t");
}
//5
//4
//3
//2
//1

//3.
for(;;) { //조건식도 생략 - 조건식이 생략되면 무조건 참(true)으로 처리 - 무한루프 : 종료되지 않는 반복문
	System.out.println("무한 반복되어 실행되는 명령");
}
//무한루프로 인해 하단에 작성된 명령은 실행되지 못하는 명령이므로 에러발생
//System.out.println("============================="); //읽어들일 수 없는 코드 (=dead code)

//무한 반복되어 실행되는 명령
//무한 반복되어 실행되는 명령
//.. 무한반복되어 출력..

 

예제 9) 본인 이름을 화면에 7번 출력

//🚩my answer
for(int i = 1; i <= 7; i++) {
	System.out.print("홍길동 ");
}
System.out.println();
//홍길동 홍길동 홍길동 홍길동 홍길동 홍길동 홍길동

 

예제10) 1~10 범위의 정수 중 홀수를 화면에 출력

//🚩my answer
for(int i=1; i < 10; i+=2) {
	System.out.print(i+ "\t");
}
System.out.println();
//1	3	5	7	9

//answer
for(int i=1; i<=10; i++) {
	if(i % 2 != 0) {
		System.out.print(i+ "\t");
	}
}
//13579

 

예제11) 1~100 범위의 정수에서 3의 배수들의 합계와 5의 배수들의 합계를 계산하여 3의 배수의 합계에서 5의 배//수의 합계를 뺀 결과값을 출력

//🚩my answer
int sum1 = 0;
int sum2 = 0;
for(int i=1; i <= 100; i++) {
	if(i % 3 == 0) {
		sum1 += i;
	}
	if(i % 5 == 0) {
		sum2 += i;
	}
}
System.out.println("결과 = " + (sum1 - sum2));
//결과 = 633


//answer
int tot3=0, tot5=0;
for(int i=1; i<=100; i++) {
	if(i % 3 == 0) tot3+=i;
	if(i % 5 == 0) tot5+=i;
}
System.out.println("결과 = " + (tot3 - tot5));
//결과 = 633

 

예제12) 구구단 중 7단을 화면에 출력

//🚩my answer
for(int i = 1; i <= 9; i++) {
	System.out.println("7 * " + i + " = " + (i * 7));
}

//answer
int dan = 7;
for(int i = 1; i <= 9; i++) {
	System.out.println(dan + " * " + i + " = " + (i * dan));
}
//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

 

예제13) 5!의 결과값 출력 (5! = 5 * 4 * 3 * 2 * 1)

//🚩my answer
int result = 1;
for(int i=1; i<=5; i++) {
	result = result * i;
}
System.out.println("5! = " + result);
//5! = 120

//answer
int num = 5, fac = 1;
for(int i=num; i>=1; i--) {
	fac = fac * i;
}
System.out.println(num +"! = " + fac);
//5! = 120

 

예제14) 두 변수에 저장된 정수값 사이의 정수들을 화면에 출력
(단, 한 줄에 정수값이 7개씩 출력되도록 프로그램 작성)

/*
ex) 
36    27    38     39     40     41     42
43    44    45     46     47     48     49
50    51    52     53     54     55     56
57
*/


//🚩my answer
//다음 줄로 출력하는 법 모르겠음 - counting할 수 있는 변수들이 필요
/*
int begin=36, end=57;
for(int i = begin; i <= end; i++) {
	if(i/7.0 <= 6) {
		System.out.print(i + "\t");
		}
	}
//36	37	38	39	40	41	42
*/

//answer
//출력개수를 저장할 변수 지정 & System.err.println()이용
int begin=36, end=57;
int count = 0; //출력개수를 저장할 변수
for(int i = begin; i <= end; i++) {
		System.out.print(i + "\t");
		count++;
		if(count % 7 == 0) { //카운트가 7의 배수면 엔터를 해서 밑에 출력하자
			System.err.println();
		}
}
//36    27    38     39     40     41     42
//43    44    45     46     47     48     49
//50    51    52     53     54     55     56
//57

 
 
 
 
🐺 중첩 for문 예제

• 2차원 배열 처리할 때 많이 이용
• 행(int i)과 열(int j)을 처리하기 위한 반복문
• 데이터를 효율적으로 처리하는 알고리즘에서 가장 많이씀 (일반적으로 중첩for문으로 처리 많이 함)
• 특히, 행렬 처리에 많이 사용

예제 1) 3 x 4 = 12

int cnt = 0; //이동방법의 갯수를 저장하기 위한 변수
for(int i = 1; i <= 3; i++) { //A나라에서 섬으로 이동하는 방법 : 3가지 - 반복문
	for(int j = 1; j <= 4; j++){ // 섬에서 B나라로 이동하는 방법: 4가지 - 반복문
		cnt++;
	}
}
System.out.println("이동방법의 갯수 = " + cnt); //이동방법의 갯수 = 12

 
예제 2) ★★★★★★★출력 (1행 7열 데이타 처리)

for(int j=1; j<=7; j++) {
	System.out.print("★");
}
System.out.println();
//★★★★★★★

 
예제 3) ★★★★★★★ x 4 출력 (4행 7열 데이타 처리)

/*
★(열)★★★★★★ -> 1행
★★★★★★★ -> 2행
★★★★★★★ -> 3행
★★★★★★★ -> 4행
*/

for(int i=1; i<=4; i++) { //행을 반복처리하기 위한 반복문(row)
	for(int j=1; j<=7; j++) { //열을 반복처리하기 위한 반복문 (column)
		System.out.print("★");
	}
	System.out.println();
}
//★★★★★★★
//★★★★★★★
//★★★★★★★
//★★★★★★★

 
예제 4) 구구단출력

//step1.
for(int i=1; i<=9; i++) {    // i = 행 제어(행의갯수=9개라, i=1; i<=9;)
	for(int j=1; j<=8; j++) {
		System.out.print("*=\t");
	}
	System.out.println();
}
//                                 i로 처리
//  *=	*=	*=	*=	*=	*=	*=	*=	(1행) i=1일때 8번 반복
//  *=	*=	*=	*=	*=	*=	*=	*=	(2행) i=2일때 8번 반복
//  *=	*=	*=	*=	*=	*=	*=	*=	(3행)
//  *=	*=	*=	*=	*=	*=	*=	*=	(4행)
//  *=	*=	*=	*=	*=	*=	*=	*=	(5행)
//  *=	*=	*=	*=	*=	*=	*=	*=	(6행)
//  *=	*=	*=	*=	*=	*=	*=	*=	(7행)
//  *=	*=	*=	*=	*=	*=	*=	*=	(8행)
//  *=	*=	*=	*=	*=	*=	*=	*=  (9행) i=9일때 8번 반복


//step2.
for(int i=1; i<=9; i++) {
	for(int j=1; j<=8; j++) {
		System.out.print((j+1) + "*=\t"); //j = 열 제어(열의갯수=8이라, j=1; j<=8;)
	}
	System.out.println();
}
// (1열) (2열) (3열) (4열) (5열) (6열) (7열) (8열)
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=
//  2*=	 3*=   4*=	5*=   6*=   7*=   8*=  9*=


//step3.
for(int i=1; i<=9; i++) {
	for(int j=1; j<=8; j++) {
		System.out.print((j+1) + "*"+ i +"=\t"); //j = 열 제어
	}
	System.out.println();
}
//2*1=	 3*1=	4*1=	5*1=	6*1=	7*1=	8*1=	9*1=
//2*2=	 3*2=	4*2=	5*2=	6*2=	7*2=	8*2=	9*2=
//2*3=	 3*3=	4*3=	5*3=	6*3=	7*3=	8*3=	9*3=
//2*4=	 3*4=	4*4=	5*4=	6*4=	7*4=	8*4=	9*4=
//2*5=	 3*5=	4*5=	5*5=	6*5=	7*5=	8*5=	9*5=
//2*6=	 3*6=	4*6=	5*6=	6*6=	7*6=	8*6=	9*6=
//2*7=	 3*7=	4*7=	5*7=	6*7=	7*7=	8*7=	9*7=
//2*8=	 3*8=	4*8=	5*8=	6*8=	7*8=	8*8=	9*8=
//2*9=	 3*9=	4*9=	5*9=	6*9=	7*9=	8*9=	9*9=


//step4.
for(int i=1; i<=9; i++) {
	for(int j=2; j<=9; j++) {
		System.out.print(j + "*"+ i +"="+ (i*j) + "\t"); //j = 열을 제어  // i = 행을 제어
	}
	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
// 2*2=4	3*2=6	4*2=8	5*2=10	6*2=12	7*2=14	8*2=16	9*2=18
// 2*3=6	3*3=9	4*3=12	5*3=15	6*3=18	7*3=21	8*3=24	9*3=27
// 2*4=8	3*4=12	4*4=16	5*4=20	6*4=24	7*4=28	8*4=32	9*4=36
// 2*5=10	3*5=15	4*5=20	5*5=25	6*5=30	7*5=35	8*5=40	9*5=45
// 2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	7*6=42	8*6=48	9*6=54
// 2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	8*7=56	9*7=63
// 2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	9*8=72
// 2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

 
예제 5) 별모양 출력

★
★★
★★★
★★★★
★★★★★

//(행) i = 1 , (열)★ = 1
//    i = 2 , ★ = 2
//    i = 3 , ★ = 3
//    i = 4 , ★ = 4
//    i = 5 , ★ = 5
for(int i = 1; i <= 5; i++) {
	for(int j = 1; j <= i; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 

★★★★★

★★★★

★★★

★★

★

//문제2. 별모양 출력 - 행의 개수 5개 유지
//방법1.
//(행)i = 1 , (열)★ = 5
//   i = 2 , ★ = 4
//   i = 3 , ★ = 3
//   i = 4 , ★ = 2
//   i = 5 , ★ = 1
//i 의 길이는 행의 갯수인 총 5만 유지하면됨, i=1; i<=5; 
for(int i=1; i<=5; i++) {
	for(int j = 1; j <= (6-i); j++) {
		System.out.print("★");
	}
	System.out.println();
}
//방법2.
//i = 5 , ★ = 5
//i = 4 , ★ = 4
//i = 3 , ★ = 3
//i = 2 , ★ = 2
//i = 1 , ★ = 1
// i 의 길이는 행의 갯수인 총 5만 유지하면됨, i=5; i>=1;
for(int i=5; i>=1; i--) {
	for(int j = 1; j <= i; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 
 

★★★★★

★★★★

★★★

★★

★

//🚩my answer
//i=1일때 j=5번 반복 , i=2일때 j=4번 반복
for(int i=1; i<=5; i++) {
	for(int j=1; j<=6-i; j++) {
		System.out.print("★");
	}
	System.out.println();
}
for(int i=1; i<=5; i++) {
	for(int j=5; j>=i; j--) {
		System.out.print("★");
	}
	System.out.println();
}
//answer
for(int i=1; i<=5; i++) {
	for(int j=1; j<=6-i; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 

☆☆☆☆★
☆☆☆★★
☆☆★★★
☆★★★★

★★★★★

//방법1.
//   j         j
//☆ = 4    ★ = 1    -> 4 + 1 = 5  즉,   (5-i) + i = 5
//☆ = 3    ★ = 2
//☆ = 2    ★ = 3
//☆ = 1    ★ = 4
//☆ = 0    ★ = 5
for(int i=1; i<=5; i++) {
	for(int j = 1; j <= 5-i; j++) {
		System.out.print("☆");
	}
	for(int j = 1; j <= i; j++) {
		System.out.print("★");
	}
	System.out.println();
}
//방법2.
//선택적 출력(if문)
//=> 반복문을 하면서 선택적으로 넌 검은별이야, 넌 흰별이야 선택적으로 출력할 수 있음
//=> 선택문 = if문 이용하기
//=> 규칙을 찾아 언어로 표현해주기!
//=> ex. ( i + j ) < 6 -> "☆" 출력

//1 2 3 4 5  >> j
//☆☆☆☆★
//☆☆☆★★
//☆☆★★★
//☆★★★★
//★★★★★

//행 & 열 로 문제 해결 (i,j)
//(1,1)(1,2)(1,3)(1,4)(1,5)
//(2,1)(2,2)(2,3)(2,4)(2,5)
//(3,1)(3,2)(3,3)(3,4)(3,5)
//(4,1)(4,2)(4,3)(4,4)(4,5)
//(5,1)(5,2)(5,3)(5,4)(5,5)
//로 데이터 바라보기
for(int i = 1; i <= 5; i++) {
	for (int j = 1; j<= 5; j++) {
		if(i + j < 6) {
			System.out.print("☆");
		} else {
			System.out.print("★");
		}
	}
	System.out.println();
}

 

★★★★★

☆★★★★

☆☆★★★

☆☆☆★★

☆☆☆☆★

//🚩my answer
// i는 행의 수만큼 반복할 것이다.
// 즉, i는 12345까지 꼭 카운트해야한다. -> i가 1 카운트하는 동안 -> ☆(j)의 갯수0, ★(k)의 갯수5
// j와 k의 흐름과 i와의 관계를 보면
//i=1일때, j=0번반복 k=5번반복 즉, i-j=1, k+i=6 이므로 j=i-1, k=6-i로 표현 가능하다
//i=2일때, j=1번반복 k=4번반복 즉, i-j=1, k+i=6 이므로 j=i-1, k=6-i로 표현 가능하다
//i=3일때, j=2번반복 k=3번반복 즉, i-j=1, k+i=6 이므로 j=i-1, k=6-i로 표현 가능하다
//i=4일때, j=3번반복 k=2번반복 즉, i-j=1, k+i=6 이므로 j=i-1, k=6-i로 표현 가능하다
//i=5일때, j=4번반복 k=1번반복 즉, i-j=1, k+i=6 이므로 j=i-1, k=6-i로 표현 가능하다
for(int i=1; i<=5; i++) {
	for(int j=1; j<=i-1; j++) {
		System.out.print("☆");
	}
	for(int k=1; k<=6-i; k++) {
		System.out.print("★");
	}
	System.out.println();
}

//answer
//행 & 열 로 문제 해결 (i,j)
//(1,1)(1,2)(1,3)(1,4)(1,5)
//(2,1)(2,2)(2,3)(2,4)(2,5)
//(3,1)(3,2)(3,3)(3,4)(3,5)
//(4,1)(4,2)(4,3)(4,4)(4,5)
//(5,1)(5,2)(5,3)(5,4)(5,5)
//로 데이터 바라보기
for(int i=1; i<=5; i++) {
	for(int j=1; j<=5; j++) {
		if(i>j) {
			System.out.print("☆");
		} else {
			System.out.print("★");
		}
	}
	System.out.println();
}

 

            ★

         ★★

      ★★★

   ★★★★

★★★★★

for(int i = 1; i <= 5; i++) {
	for(int j = 1; j <= 5-i; j++) {
    					//공백문자열length() = 2
		System.out.print("  ");
	}
	for(int j = 1; j <= i; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 

★
★★★
★★★★★
★★★★★★★
★★★★★★★★★

//🚩my answer
// 예제 2번과 동일하게 i & j의 관계를 가지고 문제해결
//1(i) + 0 = 1(j)
//2(i) + 1 = 3(j)
//3(i) + 2 = 5(j)
//4(i) + 3 = 7(j)
//5(i) + 4 = 9(j)
//i + (i-1) =  2i-1 = j
for(int i = 1; i <=5; i++) {
	for(int j = 1; j<= (2*i-1); j++) {
		System.out.print("★");
	}
	System.out.println();
}


//answer
//i 와 j의 관계, 2차방적식으로 해결 (나와똑같음)
for(int i=1; i<=5; i++) {
	for(int j=1; j<=i*2-1; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 

                               ★

                        ★★★

                 ★★★★★
          ★★★★★★★
   ★★★★★★★★★

for(int i=1; i<=5; i++) {
	for(int j=1; j<=5-i; j++) {
		System.out.print("  ");
	}
	for(int j=1; j<=i*2-1; j++) {
		System.out.print("★");
	}
	System.out.println();
}

 

★☆☆☆★

☆★☆★☆

☆☆★☆☆

☆★☆★☆

★☆☆☆★

//🚩my answer
//행 & 열 로 문제 해결 (i,j)
//(1,1)(1,2)(1,3)(1,4)(1,5) -> 한 줄 돌 때마다 선택해 별 출력(if)이용
//(2,1)(2,2)(2,3)(2,4)(2,5)
//(3,1)(3,2)(3,3)(3,4)(3,5)
//(4,1)(4,2)(4,3)(4,4)(4,5)
//(5,1)(5,2)(5,3)(5,4)(5,5)
//로 데이터 바라보기

for(int i = 1; i <= 5; i++) {
	for (int j = 1; j<= 5; j++) {

		if(i==j || i+j==6) {
			System.out.print("★");
		}else {
			System.out.print("☆");
		}

	}
	System.out.println();
}

 
 

2) while문

• 명령에 대한 반복 횟수가 불확실한 경우 사용되는 반복문
• 문법상 횟수가 없는 경우에 더 효율적

🐸 while문 형식

while(조건식){ //조건식이 false가 될 때까지 반복해
	명령;
	명령;
	...
}

//조건식의 결과가 참인 경우 블럭 안의 명령을 반복 실행하고 거짓인 경우 반복문 종료
//조건식 생략 불가능
//조건식의 결과가 처음부터 거짓인 경우 반복문 종료
//=> 블럭 안의 명령을 0번 이상 반복 실행
//=> 즉, 한번도 실행안될수도 있음

 
 
🐸 do - while문 형식 (=변형된 while문, 향상된 while문)

do {명령; 명령; ...} while(조건식);

//반드시 마무리에 ;(세미콜론) 찍어주기
//조건이 명령을 실행하기 전에 나옴
//조건식의 결과가 처음부터 거짓인 경우에도 명령 실행
//=> 블럭 안의 명령을  1번 이상 반복 실행
//=> 즉, 한번은 무조건 실행

 
 
 
🐸 반복의 횟수가 정해져 있을때 사용한 while문 예제

예제 1) "Java Programming"을 화면에 5번 출력

//while은 초기식과 증감식이 ()안에 있는 것은 아님
//초기식 따로, 증감식 따로
//조건식은 while문 안에
//그래서 for문보다 효율적이지 못함
int i = 1;
while(i <= 5) {
	System.out.println("Java Programming");
	i++;
}
//Java Programming
//Java Programming
//Java Programming
//Java Programming
//Java Programming

 
예제 2) 1 ~ 100범위의 정수들의 합계를 계산하여 출력

//do while 문 이용해보자
//반복횟수가 정해져 있기 때문에 while보다 for 사용하는 것이 더 효율적
int j = 1, tot = 0;
do 
{
	tot += j;
	j++;
} 
while(j <= 100);

System.out.println("1 ~ 100 범위의 정수들의 합계  = " + tot);
//1 ~ 100 범위의 정수들의 합계  = 5050

 
🐸 반복의 횟수가 정해지지 않을때 경우 while문 예제

예제 1) A4용지를 반으로 계속 접어 펼쳤을 경우 사각형 모양의 갯수가 500개 이상이 만들어지려면 몇번 접어야 되는지 계산하여 출력

//몇번접어야하는지 명확하지 않음 (접는횟수 불명확)
//500 미만이면 계속접고, 미만이면 멈추면 됨! - while문 사용하는 것이 효율적

int cnt = 0, gae = 1; //cnt: 접는 횟수, gae: 사각형 모양의 갯수
//조건: 사각형 모양의 갯수가 500개 미만일때
while(gae<500) { //A4용지를 반으로 접는 행위를 반복 처리 할 때마다 접는개수와 사각형의 수 변경되어야함
	cnt++;  //접는 횟수는 1씩 증가
	gae*=2; //사각형 모양의 갯수는 앞의 갯수에 2배씩 증가
}
System.out.println(cnt +"번 접으면 " +gae+"개의 사각형이 만들어집니다.");
//9번 접으면 512개의 사각형이 만들어집니다.

 
예제 2) 1 ~ X 범위의 정수들의 합계가 300 이상이 만들어지려면 X가 얼마인지 계산하여 출력

//주어진조건) 300이상이되려면 
//즉, 300 미만이면 계속 누적, 300 이상이면 누적하지 않고 나가기
//X가 불명확 (몇번까지 더하는지 모름 = while문 쓰기)
//while문 쓰는 것이 효과적

//문제점
int x = 1, sum = 0; //x : 1씩 증가되는 정수값 저장, sum : 누적결가(합계) 저장
while(sum < 300) {
	sum += x;
	x++;
}
System.out.println("1 ~ "+x+"범위의 정수들의 합계 = " + sum);
//24로 나와야 하는데 25로 나온이유: 마지막에 sum에 누적 후 x값이 1 더하고 나갔기 때문(불필요하게 x 한번 더 더함)
//1 ~ 25범위의 정수들의 합계 = 300


// 명령의 순서로 인해 결가가 다르게 나올 수도 있음
// 프로그램을 만들고 나서 프로그램이 제대로 싷행되는지 반드시 검사를 꼭 해주어야함
// 실제 코드에 이상이 없어도 결과가 이상하게 나올 수 있음

// 내가 만든 프로그램이 잘 나오는지 검사

//알파 테스트 : 개발자들이 테스트
//베타 테스트 : 개발자 외의 사람들이 테스트


//해결법
int x = 0, sum = 0; //x : 1씩 증가되는 정수값 저장, sum : 누적결가(합계) 저장
while(sum < 300) {
	x++;
	sum += x;
}
System.out.println("1 ~ "+x+"범위의 정수들의 합계 = " + sum);
//1 ~ 24범위의 정수들의 합계 = 300

 

 
 

4. 기타제어문

1) break문 = the end

• switch 구문(선택문) 또는 반복문을 강제로 종료하기 위해 사용하는 제어문
• if문은 아님 , 가장 많이 사용하는 것은 반복문
• break문은 반복문 안에서 if문과 함께 쓰임!!!!
• break문을 만나면 해당 break문이 쓰인 반복문에서만 벗어난다!

 
💟break문의 예제

 

예제 1 ) 반복문 + break문 사용

for(int i =1; i <=5; i++) {
	if(i == 3) {
		break;  //if 구문의 조건이 참인 경우 break 명령으로 반복문 종료
	}
	System.out.print(i + "\t");
}
//1	  2

 

예제 2 ) 그냥 반복문

for(int i = 1; i <= 5; i++) {
	for (int j = 1; j <=5; j++) {
		System.out.println("i ="+ i + ","+ "j ="+ j);
	}
}
//i =1,j =1
//i =1,j =2
//i =1,j =3
//i =1,j =4
//i =1,j =5
//i =2,j =1
//i =2,j =2
//i =2,j =3
//i =2,j =4
//i =2,j =5
//i =3,j =1
//i =3,j =2
//i =3,j =3
//i =3,j =4
//i =3,j =5
//i =4,j =1
//i =4,j =2
//i =4,j =3
//i =4,j =4
//i =4,j =5
//i =5,j =1
//i =5,j =2
//i =5,j =3
//i =5,j =4
//i =5,j =5

 

예제 3) 반복문 + break문 사용 (break명령이 포함된 반복문만 종료)

//break명령이 작성된 반복문만 종료하는것
//break 만났다고 모든 반복문을 끝내는 것은 아님!!!!
//그런데 모든 반복문을 끝내고 싶을수도 있지 않나????? 다른 언어는 goto 라는 명령문이 있음
//자바는 반복문을 구분하기 위한 라벨명을 지정할 수 있음 
//예제 1-3)으로 가자

for(int i = 1; i <= 5; i++) {
	for (int j = 1; j <=5; j++) {
		if(j==3) break;
		System.out.println("i ="+ i + ","+ "j ="+ j);
	}
}
//i =1,j =1
//i =1,j =2
//i =2,j =1
//i =2,j =2
//i =3,j =1
//i =3,j =2
//i =4,j =1
//i =4,j =2
//i =5,j =1
//i =5,j =2

 

예제 4) 반복문 + break문 + 라벨명 사용 (내가 원하는 시점에 반복문 모두 종료)

//형식) 라벨명 : 반복문 작성
//다른 언어에는 없는 자바만의 문법(+ c#)
//반복문에서 반복문을 구분하기 위한 식별자(라벨명) 선언 가능
loop:
for(int i = 1; i <= 5; i++) {
	for (int j = 1; j <=5; j++) {
		if(j==3) break loop;   //break 라벨명 : 라벨명으로 표현된 반복문 종료
		System.out.println("i ="+ i + ","+ "j ="+ j);
	}
}
//i =1,j =1
//i =1,j =2

 
 

2) countine문 = reset

• 반복문에서 명령을 처음부터 다시 실행하기 위한 반복문
• 반복문 안에서만 작성 가능 , 선택문에는 작성 안돼!
• continue 명령 아래에 작성된 명령을 실행하지 않고 처음부터 다시 실행! , 한마디로 명령을 스킵
• 반복문을 종료하는 것이 아닌, 처음부터 다시 시작하는 것

 
💟countine문의 예제

 

예제 1) 반복문 + countine문 사용

for(int i = 1; i <= 5; i++) {
		if(i==3) continue;
		System.out.print(i + "\t" );
	}
//1	2	4	5

 

예제 2 ) 반복문 + countine문 사용

for(int i = 1; i <= 5; i++) {
	//다시 reset
	for (int j = 1; j <=5; j++) {
    	if(j==3) continue; // int j = 3 일때는 건너뛰기
    	System.out.println("i ="+ i + ","+ "j ="+ j);
	}
}
//i =1,j =1
//i =1,j =2  //j = 3 일때는 건너뛰기
//i =1,j =4
//i =1,j =5
//i =2,j =1
//i =2,j =2 //j = 3 일때는 건너뛰기
//i =2,j =4
//i =2,j =5
//i =3,j =1
//i =3,j =2 //j = 3 일때는 건너뛰기
//i =3,j =4
//i =3,j =5
//i =4,j =1
//i =4,j =2 //j = 3 일때는 건너뛰기
//i =4,j =4
//i =4,j =5
//i =5,j =1
//i =5,j =2 //j = 3 일때는 건너뛰기
//i =5,j =4
//i =5,j =5

 

예제 3 ) 반복문 + countine문 + 라벨명 사용

//라벨링 + continue 함께 사용하면? -> 라벨링 + break문 사용하는 것이 나음
//라벨링 + continue문은 결과적으로 break문와 동일하지만, 내부적으로 처리되는 흐름은 다름

loop:	//다시 reset
		for(int i = 1; i <= 5; i++) {
			for (int j = 1; j <=5; j++) {
				if(j==3) continue loop;
				System.out.println("i ="+ i + ","+ "j ="+ j);
			}
		}


//i =1,j =1
//i =1,j =2
//i =2,j =1
//i =2,j =2
//i =3,j =1
//i =3,j =2
//i =4,j =1
//i =4,j =2
//i =5,j =1
//i =5,j =2

 
 

3) return문

basic > LocalVariableApp.java

3-1) 지역변수(Local Variable)

• {} 내부에 선언된 변수
• 선언된 {} 내부에서만 사용 가능
• 변수가 선언된 블럭이 종료되면 지역변수는 자동 소멸됨

for (int i = 1; i <= 5; i++) {
	System.out.println("Java Programming");
}
int i; //error아님!!


//🍒자바에서 변수란..?
//=> 자바는 전역변수(global variable)라는 개념이 없음

//클래스의 구역
public class LocalVaribleApp {
	//Field(멤버변수): 클래스 안에 선언된 변수
	//=> 일반적으로 지역변수는 메서드 안에 선언된 변수
	int num1; //LocalVaribleApp 클래스 안에 있으니, 지역변수라고 볼 수도 있음

  //메인메서드의 구역
	public static void main(String[] args) {
    //=> 지역변수(Local Variable) : 블럭 {} 내부에 선언된 변수
    //=> 선언된 {} 내부에서만 사용 가능
    //=> 변수가 선언된 블럭이 종료되면 지역변수는 자동 소멸됨 - 변수의 소멸성
  	//지역변수
		int num1;
	}
}

 

3-2) 지역변수의 사용 예제

 

예제1 ) int num1 =100; 은 메인 메서드 끝날때까지 사용가능하다.

public class LocalVaribleApp {
	public static void main(String[] args) {

		int num1 =100; //메인 메서드 끝날때까지 사용가능

		//임의블럭
		{
			System.out.println("----------------임의블럭 내부--------------------");
			System.out.println("num1 =" + num1);
		}

		System.out.println("----------------임의블럭 외부--------------------");
		System.out.println("num1 =" + num1);
	}
}

//----------------임의블럭 내부--------------------
//num1 =100
//----------------임의블럭 외부--------------------
//num1 =100

 

예제2 ) {int num2 = 200;} 블럭 내에서만 사용 가능하다.

public class LocalVaribleApp {
	public static void main(String[] args) {

		int num1 =100; //메인 메서드 끝날때까지 사용가능

		//임의블럭
		{
			int num2 = 200;
			System.out.println("----------------임의블럭 내부--------------------");
			System.out.println("num1 =" + num1);
			System.out.println("num2 =" + num2);
		}//블럭이 종료되면 num2 자동소멸

		System.out.println("----------------임의블럭 외부--------------------");
		System.out.println("num1 =" + num1);

		//임의블럭 종료시 num2 변수가 자동 소멸되므로 사용 불가능
		System.out.println("num2 =" + num2); //error
	}
}
//----------------임의블럭 내부--------------------
//num1 =100
//num2 =200
//----------------임의블럭 외부--------------------
//num1 =100
//error

 

예제3 ) int num1 = 100; 은 메인 메서드가 끝날때까지 사용가능하므로 중복 선언이 안된다.

public class LocalVaribleApp {
	public static void main(String[] args) {

		int num1 =100; //메인 메서드 끝날때까지 사용가능

		//임의블럭
		{
			int num2 = 200;
			System.out.println("----------------임의블럭 내부--------------------");
			System.out.println("num1 =" + num1);
			System.out.println("num2 =" + num2);
		}//블럭이 종료되면 num2 자동소멸

		System.out.println("----------------임의블럭 외부--------------------");
		System.out.println("num1 =" + num1);

		//임의블럭 종료시 num2 변수가 자동 소멸되므로 사용 불가능
		System.out.println("num2 =" + num2); //error
	}
}
//----------------임의블럭 내부--------------------
//num1 =100
//num2 =200
//----------------임의블럭 외부--------------------
//num1 =100
//error