Control Flow Statements

소스 파일 내부의 statements은 일반적으로 위에서 아래로, 순서대로 실행된다. 그러나 제어 흐름 statements은 결정 만들기, 반복, 분기를 사용하여 실행 흐름을 분할함으로써 프로그램이 조건부로 특정 코드 블록을 실행할 수 있도록 한다.

Control Flow Statements	종류
조건문(conditional) statement	if-then, if-then-else, switch
반복(Loop) statement	for, while, do-while
분기(branch) statement	brake, continue, return

💬 "if-then" 이라는 용어는 if 조건문의 조건이 참(true)일 경우 실행될 코드 블륵을 실행한다는 의미다.
자바에서는 이구조를 중괄호 { } 를 사용하여 구현한다.

if (condition) {
    // condition이 참일 때 실행할 코드
    // ...
}

여기서 condition이 참일 경우, 중괄호 안의 코드가 실행된다.
then은 실제 코드에 나타나지 않지만, 설명할 때 if-then이라고 표현하여 조건이 참인 경우에 실행될 행동을 설명하는데 사용 된다.

 

📖 Conditional Statements(조건문)

1️⃣ if - then 조건문

if-then statement은 모든 제어 흐름 statements 중에서 가장 기본적인 statements다.
이 statement은 특정 테스트가 참으로 평가될 때만 프로그램이 특정 코드 섹션을 실행하도록 지시한다.

 

🔹 기본 구조

if (조건식) {
    // 조건식이 참일 때 실행되는 코드
}

 

🧾 예제

public class IfDemo {
    public static void main(String[] args) {
    	int age = 20;

    	if (age >= 20) {
    	    System.out.println("성인입니다.");
    	}
    }
}

age가 20 이상일 경우 "성인입니다." 문장을 출력한다
만약 age가 17, false로 평가되면 if statement의 끝으로 이동한다(아무것도 출력되지 않는다).

또한, if문에 statement가 하나만 포함되어 있는경우, 여는 괄호와 닫는 괄호( { } )는 선택적으로 생략할 수 있다.

public class IfDemo {
    public static void main(String[] args) {
    	int age = 20;

    	if (age >= 20) 
    	    System.out.println("성인입니다.");
 
    }
}

⚠️ 괄호를 생략할지 여부는 개인의 선택이지만, 괄호를 생략하면 코드가 더 취약해질 수 있다. 나중에 두 번째 statement가 추가되면 흔히 발생하는 실수로 새로 필요한 괄호를 까먹는 것이다. 컴파일러는 이러한 종류의 오류를 잡아낼 수 없으며, 잘못된 결과를 얻게 된다.

2️⃣ if - else / if - else if  조건문

if 문이 조건이 참일 때만 실행되는 것이라면, if-else 문은 "if" 절이 false로 평가될 때 실행할 대체 경로를 재공한다.
참일 때는 if문, 거짓일 때는 else문, 즉 두 두가 경우 중 하나를 선택해서 실행하는 조건문이다.
if-else if문은 여러 개의 조건 중에서 하나를 선택해서 실행하는 구조다.
처음으로 조건을 순차적으로 검사하고, 첫 번째로 참인 조건만 실행된다.

 

🔹 기본 구조

if-else문

if (조건식) {
    // 조건이 참일 때 실행
} else {
    // 조건이 거짓일 때 실행
}

 

if-else if문

if (조건1) {
    // 조건1이 참일 때 실행
} else if (조건2) {
    // 조건1은 거짓이고 조건2가 참일 때 실행
} else if (조건3) {
    // 위 조건이 모두 거짓이고 조건3이 참일 때 실행
} else {
    // 모든 조건이 거짓일 때 실행
    // 마지막 statement는 else문으로
}

 

🧾 예제1 (짝수 홀수 판정)

public class IfElseDemo {
    public static void main(String[] args) {
    	int number = 9;

    	if (number % 2 == 0) {
    	    System.out.println("짝수입니다."); // 나머지가 0 이면 출력
    	} else {
    	    System.out.println("홀수입니다."); // 나머지가 0 이 아니면 출력
    	}   	
    }
}

조건식이 true인지 false인지 평가
이 예제의 조건식이 false로 else의 "홀수입니다" statement가 실행된다

 

🤔 왜 자바에서는 짝수, 홀수를 표현할때 위의 메서드를 사용할까?

자바는 일반적인 범용 프로그래밍 언어이고, 짝수나 홀수 같은 개념은 특정 숫자의 성질일 뿐이다.
그리고 자바에는 짝수, 홀수라는 단어를 직접 표현할 수 있는 키워드가 없기 때문에,
개발자가 직접 조건문으로 구현해야 하는 부분이다.

 

🧾 예제2 (if-else-if문)

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

        int testscore = 76;
        char grade; // grade -> 유니코드
         
        // if - else 조건문 
        // 조건식이 false 이기 때문에 if의 블록의 statement는 실행되지 않고,
        // else 블록안의 statement가 실행됨
        if (testscore >= 90) {
            grade = 'A';       
        }   
        else {
            grade = 'F';
        }
        // if로 로직을 구성할수있으면 else 안써도 된다
	
        System.out.println("Grade = " + grade); // Grade = F 출력
        
        if - else - if 조건문
        
        // else if의 조건문이 true일때 스테이트먼트가 실행
        // 여기의 조건문들이 전부다 false라면 마지막 else 블록안의 스테티트먼트가 실행됨
        if (testscore >= 90) {
            grade = 'A';
        } else if (testscore >= 80) {
            grade = 'B';
        } else if (testscore >= 70) { // 이 조건문이 true라 이 스테이트먼트 실행
            grade = 'C';
        } else if (testscore >= 60) {
            grade = 'D';
        } else {
            grade = 'F';
        }	               
        System.out.println("Grade = " + grade); // Grade = C 출력
    }
}

 

조건이 위에서 아래로 순차적으로 평가된다. 첫 번째로 true가 되는 조건만 실행되고, 나머지는 무시된다.
else는 없어도 되지만, 없는 경우 아무 조건도 만족하지 않으면 아무 일도 안 생긴다.

3️⃣  Switch 조건문

if 문과 if-else 문과 달리 switch 문은 여러 가능한 실행 경로를 가질 수 있다.
switch는 byte, short, char, int 기본[Privitive] 데이터 타입과 함께 작동된다.
또한 Enum(열거)타입, String 클래스, 그리고 특정 기본 타입을 감싸[wrapping]는 몇 가지 특별한 클래스
Character, Byte, Short, Integer(Number와 String에서 논의됨)와 함께 작동 된다.

switch statement의 본문은 switch 블록으로 알려져 있다. switch 블록의 statements은 하나 의상의 case 또는 default 레이블로 표시될 수 있다.
switch statement은 expressino을 평가한 다음 일치하는 case 레이블을 따르는 모든 statements을 실행한다.

🔹 기본 구조

switch (값) {
    case 값1:
        // 값이 값1일 때 실행
        break;
    case 값2:
        // 값이 값2일 때 실행
        break;
    ...
    default:
        // 어떤 case와도 일치하지 않을 때 실행
}

 

🧾 예제1

public class SwitchDemo {
    public static void main(String[] args) {
    int week = 3;
    String weekString;

    switch (week) {
           case 1: 
               weekString = "Monday"; 
               break;
           case 2:  
               weekString = "Tuesday";
               break;
           case 3:  
               weekString = "Wednesday"; 
               break;
           case 4:
               weekString = "Thursday";
               break;
           case 5:
               weekString = "Friday";
               break;
           case 6:
               weekString = "Saturday"; 
               break;
           case 7:
               weekString = "Sunday"; 
               break;
           default:
               weekString = "Invalid week";
               break;
        }
        System.out.println(weekString);   	
    }
}

이 경우, 표준 출력으로 "Wednesday"가 출력 됩니다.
만약 break가 없으면 다음 case로 넘어가서 계속 실행됨(이걸 fall-through라고 한다)

🧾 예제2 (break 없을경우, fall-throuth)

import java.util.ArrayList;
import java.util.List;
public class SwitchFallThroughDemo {
    public static void main(String[] args) {
   		List<String> weekString = new ArrayList<>();
    	
    	int week = 3;
 
        switch (week) {
        case 1: 
   	        weekString.add("Monday")  ; 
        case 2:  
        	weekString.add("Tuesday");
        case 3:  
        	weekString.add("Wednesday"); 
        case 4:
        	weekString.add("Thursday"); 
        case 5:
        	weekString.add("Friday");  
        case 6:
        	weekString.add("Saturday"); 
        case 7:
        	weekString.add("Sunday");  
        default:
            break;
        }
        if (weekString.isEmpty()) {
            System.out.println("Invalid week number");
        } else {
            for (String weekName : weekString) {
                System.out.println(weekName);
            }	
        }
    }
}

출력시

Wednesday
Thursday
Friday
Saturday
Sunday

기술적으로는 마지막 break가 필요하지 않다. 이유는 실행 흐름이 switch statement을 벗어나기 때문이다.
코드를 수정하기 쉽고 우류 가능성을 줄이기 위해 break 사용을 권장한다.
default 섹션은 case 섹션 중 하나에서 명시적으로 처리되지 않은 모든 값을 처리한다.

✉️ break의 역할

• 각 case의 마지막에 braek를 넣는 이뉴는?
  → 해당 case가 실행된 뒤, switch 문을 빠져나가기 위해서!!!
• break를 안 넣으면?
  → 다음 case들도 줄줄이 실행됨 (원하지 않는 동작일 수 있음)

🧾 예제3 (하나의 statement에 여러 case 레이블을 가질 수 있는 방법)

public class SwitchDemo2 {
	public static void main(String[] args) {
        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1:  // 코드의 가독성을 위해 일렬로 작성
            case 3:
            case 5:
            case 7:
            case 8: 
            case 10:
            case 12:
                numDays = 31;
                break;
                
            case 4: 
            case 6:
            case 9:
            case 11:
                numDays = 30;
                break;
            
            case 2:
                if (((year % 4 == 0) && !(year % 100 == 0)) //이 AND는 False
                     || (year % 400 == 0)) // 결국 False Or True 여서 이 연산은 True
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = " + numDays);
    }
}

출력시

Number of Days = 29

 

🧾 예제4( Switch 문에서의 expression에서 String객체를 사용할 경우)

public class StringSwitchDemo {
	// week 파라미터에 "August" 의 리터럴을 참조하고 있는 스트링 클래스 객체의 인스턴스 참조값을
	// 아규먼트로 전달하고 있음.
	public static int getWeekNumber(String week) {
        int weekNumber = 0;

        // null : 아무것도 참조하고 있지 않다.
        // String nextWeek = null;       
        // 주의해서 보기!!
        if (week == null) {
            // 현재 getWeekNumber 메서드의
            // return statement가 if(week == null) "블럭"의 statement로 작성되있음.
            // 곧바로 getWeekNumber 메서드 호출자에게 리턴함!!!
            return weekNumber;
        }
        // toLowerCase는 String 클래스의 인스턴스 메서드!!
        // toLowerCase : week 참조 변수가 참조하고 있는 String 클래스 객체의 인스턴스 필드에[value]의 스트링을
        // 소문자 타입으로 리턴한다
        // "Wednesday" -->"wednesday"
        // week.value ---> 전부 소문자화
        String lowerCaseString = week.toLowerCase();
        							
        switch (week.toLowerCase()) {
            case "monday":
            	weekNumber = 1;
                break;
            case "tuesday":
            	weekNumber = 2;
                break;
            case "wednesday":
            	weekNumber = 3;
                break;
            case "thursday":
            	weekNumber = 4;
                break;
            case "friday":
            	weekNumber = 5;
                break;
            case "saturday":
            	weekNumber = 6;
                break;
            case "sunday":
            	weekNumber = 7;
                break;
            default: 
            	weekNumber = 0;
                break;
        }
        return weekNumber;
    }
    public static void main(String[] args) {
        String week = "Saturday";
        int returnedWeekNumber = StringSwitchDemo.getWeekNumber(week);

        if (returnedWeekNumber == 0) {
            System.out.println("Invalid week");
        } else {
            System.out.println(returnedWeekNumber);
        }
    }
}

이 코드에서 출력된 결과는 6입니다.

swicth expression에서 사용된 String은 마치 String.equals 메소드를 사용하는 것처럼 각 case 레이블과 관련된
expression과 비교된다.
StringSwitchDemo 예제가 대소문자에 상관없이 모든 요일을 받아들일 수 있도록 week는
소문자로 변환된다(toLowerCase 메서드 사용), 그리고 모든 case 레이블과 관련된 문자열들도 소문자다.

 

📖 Loopint Statements(반복문)

1️⃣ While 반복문

while statement는 특정 조건이 참인 동안 블록의 statements를 계속해서 실행한다.

 

🔹 기본 구조

while (조건식) {
    // 반복 실행할 statement
}

 

⏯️ 동작 흐름

1. 조건식을 평가한다. 이 조건식은 반드시 boolean 값을 리턴해야 한다.
2. 조건식이 true면 블록 내부 코드 실행.
3. 실행이 끝나면 다시 조건식으로 돌아감.
4. 조건식이 false가 되면 반복 종료.

🧾 예제

public class WhileDemo {

	public static void main(String[] args){
        int loopingCount = 1; // for 구문에서 int i = 1;
       
        // while(expression)의 조건식이 true 이면
        // while 블럭의 Statement(s)들을 수행한다.
        // 언제까지? while(expression)의 조건식이 true이면 계속해서
        // while 블럭의 statement(s)들을 수행한다.
        while (loopingCount < 11)/* for 구문에서 i<11;*/ {
        	// true or false	
        	
        	System.out.println("Count is: " + loopingCount);
            
        	loopingCount++; // for 구문에서 i++
        }
        // while 조건식의 값이 false가 되면,
        // while 블럭의 next statement로 실행 순서가 이루어진다.
    }
}

 

⚠️ 무한 루프 주의 ⚠️

조건식이 항상 true라면 루프는 절대 종료되지 않는다.

while (true){
    // 여기에 코드 작성
}

 

✉️ While 반복문 사용하기 좋은 경우

반복 횟수를 모를 때	→ 입력값, 상태 변화 등 조건 중심 반복에 적합
조건을 먼저 평가해야 할 때	→ 조건이 거짓이면 한 번도 실행되지 않음

2️⃣ Do-While 반복문

do-while 반복문은 while 반복문의 차이점은 do-while 반복문은 루프의 상단이 아닌 하단에서 expression을 평가한다는 것이다.
따라서 do 블록 내의 statement들은 최소한 한 번은 실행된다.

❕ 핵심 특징 : 조건식과 상관 없이 최소 1번은 무조건 실행  ❕

 

🔹 기본 구조

do {
    // 반복 실행할 코드
} while (조건식);

 

⏯️ 동작 흐름

1. 코드를 먼저 실행한다
2. 그 다음 조건식을 평가한다.
3. 조건이 true면 다시 반복.
4. 조건이 false면 종료

🧾 예제

public class DoWhileDemo {
	public static void main(String[] args){
        int count = 11;

        do {      
            System.out.println("Count is: " + count);
            count++;
        } while (count < 11); // 첫번째 반복시에 while 조건식 값이 
                              // false 이더라도
                              // 한번은,,, do..while 블럭의 스테이트먼트가 수행됨
	}
}

출력시

Count is: 11

3️⃣ For 반복문

for statement은 값의 범위를 반복하여 반복 작업을 수행하는 간편한 방법을 제공한다.
프로그래머들은 특정 조건이 만족될 때까지 반복되는 방식 때문에 이를 "for 루프"라고 부른다

🟦 Legacy For 반복문

🔹 기본 구조

for (초기화조건식; 종료조건식; 증감조건식) {
    // 반복 실행할 코드
}
간단한 예제
for (int i = 0; i < 5; i++) {
    // 전통적으로 for 반복 구문 카운터 넘버 변수는 i를 사용한다
    System.out.println("i = " + i);
}

 

⏯️ 동작 흐름

1. 초기화 조건식(int i = 0) 제일 먼저 단 한번 실행된다
2. 조건식(i < 5)이 true면
3. statement를 실행
4. 증감 익스프레션(i++)이 실행
5. 위의 2, 3, 4번을 반복한다. 반복하다가 
6. 조건식이 false(i가 5가 되면)가 되면 for문이 종료된다.

 

❕ Legacy For 반복문 사용시 중요 포인트 ❕

• 초기화(initializtion) expression → 루프를 초기화한다. 이는 루프기 시작될 때 딱 한번 실행된다.
• 종료(termination) expression → 이 조건식이 treu면 반복, false면 종료한다.
• 증감(increment) expression → 루프의 각 반복이 끝날 때마다 호출된다. 

🧾 예제

public class ForDemo {
	public static void main(String[] args){
    
        // for(반복 조건식)
        // - 초기화 (Init 반복 횟수 카운트 변수) expression
        // - 종료 (Termination 반복) expression --> for도 이부분이 true면 반복, false면 종료
        // - 증감 (Increment 횟수 카운트 변수) expression
        for(int i=1; i<4; i++){ // int i의 라이프 사이클은 for 구문가 같이한다.
            System.out.println("Count is: " + i);
        }
    }
}

출력시

Count is: 1
Count is: 2
Count is: 3

 

⚠️ 무한 루프 주의 ⚠️

// 무한 루프
for ( ; ; ) {
    // 여기에 코드 작성
}

 

🟦 향상된 For 반복문(for-each 문)

for 반복문은 또한 컬렉션과 배열을 반복하기 위해 설계된 다른 형태를 가지고 있다.
이형태는 향상된 for 반복문이라고 하며, 루프를 더 간결하고 읽기 쉽게 만들 수 있다.

 

🔹 기본 구조

for (자료형 변수명 : 배열 or 컬렉션) { // 배열 or 컬렉션 부분에 위치하는 것은? 
                                     // Iterable 인터페이스를 구현한 구현체만 올 수 있다	 
    // 요소에 대해 반복 실행할 코드
}

 

🧾 예제1 : 배열 순회

public class EnhancedForDemo {	
    public static void main(String[] args){    	 	
        int[] numbers = {1,2,3,4,5,6,7};
         
        // 자바 컴파일러가 배열에 대한 for-each 문을 내부적으로 
        // for (int i = 0; i < arr.length; i++) 형태로 변환
        for (int item : numbers) {
            System.out.println("Count is: " + item);
        }     
        // numbers에 위치하는 것?은 Iterable 인터페이스를 구현한
        // 구체(클래스)만 올 수 있다.
        EnhancedForDemo.exampleForEachIterable();
    }
}

출력시

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7

 

🧾 예제2 : 리스트(List) 순회

public class EnhancedForDemo {	
    public static void exampleForEachIterable() {	

       List<String> futureWeek = 
                new ArrayList<String>();

        futureWeek.add("Monday");    
        futureWeek.add("Tuesday");    
        futureWeek.add("Wednesday");     
        futureWeek.add("Thursday");
        futureWeek.add("Friday");
        futureWeek.add("Saturday");
        futureWeek.add("Sunday");

        for (String string : futureWeek) {
            System.out.println(string);
        }
    }
}

출력시

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

 

❗ 예외: 수정이 필요한 경우는 일반 for 사용

int[] arr = {1, 2, 3};

for (int i = 0; i < arr.length; i++) {
    arr[i] *= 2; // 수정 가능
}

향상된 for 문은 읽기 전용 처리에 적합 하다

 

📖 Branching(분기) Statements

1️⃣ break 조건문

break statement 에는 두 가지 형태가 있다 : 라벨이 있는 형태와 라벨이 없는 형태
이전 swith 조건문에 대해 논의할 때 라벨이 없는 형태를 보았다.
또한 라벨이 없는 break 조건문을 사용하여 for, while 또는 do-while 루프를 종료할 수 있다.

 

🔹 기본 구조

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

 

⏯️ 동작 흐름

1. i == 5 일 때 반복문을 완전히 빠져나옴
2. 0 ~ 4 만 출력됨

🧾 예제1 (Label 없는 break문)

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

        int[] arrayOfInts = 
            { 32, 87, 3, 589,
              12, 1076, 2000,
              8, 622, 127 };      
        int searchfor = 12;

        int i;
        boolean foundIt = false;

        for (i = 0; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break;
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

출력시

Found 12 at index 4

이 프로그램은 배열에서 숫자 12를 찾아낸다. break 조건문의 해당 값을 찾았을 때 for루프를 종료한다.
그 후 제어 흐름은 for 루프 다음의 조건문으로 이동한다

라벨이 없는 break 조건문은 안쪽의 switch, for, while 또는 do-while 조건문을 종료하지만, 라벨이 있는 break 문은
외부 조건문을 종료한다. 
※ 자바에서 "가장 안쪽의 (innermost)"라는 표현은 중첩된 제어문(nested statements) 구조에서 현재 break가 위치한 가장 가까운 블록을 의미합니다.

for (int i = 0; i < 3; i++) {           // 바깥 for 루프
    for (int j = 0; j < 3; j++) {       // ★ 가장 안쪽의 루프
        if (someCondition)
            break;                      // 이 break는 j 루프만 종료 (즉, 안쪽 루프)
    }
}

 

🧾 예제2 (Label 있는 break문)

다음 프로그램, BreakWithLabelDemo는 이전 프로그램과 유사하지만, 2차원 배열에서 값을 겁색하기 위해 중첩된 for 루프를 사용한다. 값을 찾으면 라벨이 있는 break 조건문이 외부 for( i = 0; i < arrayOfInts.length; i++) 루프를 종료한다
(라벨이 "search"로 지정됨)

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

		// 이차원 배열
        int[][] arrayOfInts = { 
            { 32, 87, 3, 589 },
            { 12, 1076, 2000, 8 },
            { 622, 127, 77, 955 }
        };
        // arrayOfInts[][]
        // 1st [] : row(행) 인덱스
        // 2nd [] : column(열) 인덱스
        // arrayOfInts[1][3] = 8
        // arrayOfInts[0][0] = 32
        
        int searchfor = 12;

        int i;
        int j = 0;
        boolean foundIt = false;

    search: // <--Label (밞음은 레이블이지만 라벨이라 쓴다)
        for (i = 0; i < arrayOfInts.length; i++) {
        	
        	for (j = 0; j < arrayOfInts[i].length; j++) {

            	int elementValue = arrayOfInts[i][j];
            	System.out.println(elementValue);
            	
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search;
                    
                }
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at " + i + ", " + j);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

출력시

32
87
3
589
12
Found 12 at 1, 0

break statement은 라벨이 지정된 statement를 종료; 제어 흐름을 라벨로 이동시키는 것이 아니다.
제어 흐름은 라벨이 지정된 (종료된) statement 바로 다음의 statement로 이동한다

 

2️⃣ Continue 조건문

continue 조건문은 반복문(for, while)에서 특정 조건을 만족할 때, 해당 반복을 건너뛰고 다음 반복을 진행할 때 사용한다.

 

🔹 기본 구조

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue; // i가 3일 때 아래 코드를 건너뛰고 다음 반복으로 넘어감
    }
    System.out.println(i);
}

 

while문에서도 사용 가능

int i = 0;
while (i < 5) {
    i++;
    if (i == 3) {
        continue;
    }
    System.out.println(i);
}

출력 결과는 위와 동일할게 3을 건너뜀.

⚠️ 주의할 점 ⚠️
while 문에서는 coutinue 전에 루프 변수를 증가시키는 조건식을 작성하지 않으면 무한루프에 빠질 수 있다.
continue는 루프 바디 안의 나머지 코드를 무시하고 조건 검사 부분으로 돌아감

 

🧾 예제1 (Label 없는 Coutinue 조건식)

public class ContinueDemo {

    public static void main(String[] args) {

        String searchMe = "peter piper picked a " + 
                              "peck of pickled peppers";
        
        // searchMe = "peter piper picked a peck of pickled peppers";
                     //여기서 공백 문자도 문자 (space된 부분) 
        // length 메서드는
        // 위 문자열에 포함되어 있는 문자 개수를 리턴함.
        int max = searchMe.length();
        int numPs = 0;

        for (int i = 0; i < max; i++) {
            // 'p' 문자에만 관심이 있습니다.
            // charAt ()
            if (searchMe.charAt(i) != 'p')
                continue; // if 블럭 다음에 스테이트먼트를 실행하지 않고
                          // for 구문의 i++과 i < max;를 수행함.
                          // : for 구문의 증감 expressoin을 수행하고 
                          //   그 다음 종료 expression을 수행한다. 
            			
            // 'p' 문자 처리
            numPs++;
        }
        System.out.println("Found " + numPs + " p's in the string.");
    }
}

출력시

Found 9 p's in the string.

 

continue statement 효과를 좀 더 명확히 보기 위해, continue를 제거하고 다시 컴파일해 보면

Found 35 p's in the string.

9대신 35개의 p를 찾았다고 잘못된 결과가 나온다

 

🧾 예제2 (Label이 있는 Continue 조건문)

라벨이 있는 continue 조건문은 주어진 라벨로 표시된 외부 루프의 현재 반복을 건너뛴다.

public class ContinueWithLabelDemo {

	public static void main(String[] args) {

        String searchMe = "Look for a substring in me";
        String substring = "sub";
        boolean foundIt = false;

        int max = searchMe.length() - 
                  substring.length();

    test: // label 문구는 잘 사용하지 않는다
        for (int i = 0; i <= max; i++) {
            int n = substring.length();
            int j = i;
            int k = 0;
            while (n-- != 0) {
                if (searchMe.charAt(j++) != substring.charAt(k++)) {
                    continue test;
                }
            }
            foundIt = true;
            break test;
        }
        System.out.println(foundIt ? "Found it" : "Didn't find it");
    }
}

출력시

Found it

 

다른 예제

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

    outerLoop: 
        for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++) {
            if (j == 2) {
                continue outerLoop; // 바깥 루프(i)를 다음으로 건너뜀
            }
        System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

출력시

i = 1, j = 1
i = 2, j = 1
i = 3, j = 1

j == 2일 때 continue outerLoop가 실행되어 바깥 루프의 다음 반복으로 넘어간다.
j = 2, 3은 출력되지 않음

 

❌ 라벨 없는 continue로는 이렇게 안됨

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

    for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            continue; // 내부 루프(j)만 건너뜀
        }
    System.out.println("i = " + i + ", j = " + j);
            }
        }
    } 
}

출력시

i = 1, j = 1
i = 1, j = 3
i = 2, j = 1
i = 2, j = 3
i = 3, j = 1
i = 3, j = 3

 

3️⃣ Return 조건문

return 조건문은 현재 메서드에서 빠져나가고, 제어 흐름은 메서드가 호출된 곳으로 돌아간다.
return 조건문에는 값을 반환하는 형태와 값을 반환하지 않는 형태가 있다.
조건에 따라 다른 값을 반환하거나, 메서드 실행을 조기 종료할 때 매우 유용하다.

 

🔹 기본 구조

public int getDiscount(int age) {
    if (age < 18) {
        return 20; // 조건을 만족하면 조기 리턴
    }
    return 10; // 나머지 경우
}

 

🧾 예제1 (조건식에 따라 값 반환)

public class ReturnDemo {	
    public String checkGrade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F"; // 모든 조건에 해당되지 않으면 F
    }
}

 

🧾 예제2 (조기 종료 패턴)

public class ReturnDemo {	
    public void printName(String name) {
        if (name == null || name.isEmpty()) {
            System.out.println("이름이 없습니다.");
            return; // 조기 종료
    }
    System.out.println("이름: " + name);			
    }
}