호쌤
호쌤 Just For Fun

[Java] 기본문법 활용하기

크리에이티브 커먼즈 라이선스 ITPAPER(호쌤,쭈쌤)에 의해 작성된 ≪[Java] 기본문법 활용하기≫은(는) 크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 4.0 국제 라이선스에 따라 이용할 수 있습니다.
이 라이선스의 범위 이외의 이용허락을 얻기 위해서는 leekh4232@gmail.com으로 문의하십시오.

[Java] 기본문법 활용하기

조건문, 반복문을 구성하는 블록 {} 안에 다른 문법 표현이 포함될 수 있습니다. 이러한 규칙으로 다양한 문법 중첩 패턴이 생기는데 이 중에서 자주 사용되는 패턴으로는 if-if, if-for, for-if, for-for가 있습니다.

#01. if-if 구조

특정 조건이 참으로 판단되어 블록안에 진입했을 때, 상세조건을 판별하는 구조.

1
2
3
4
5
6
7
8
9
10
11
12
13
if (/*조건*/) {
    if (/*조건*/) {
        ...
    } else {
        ...
    }
} else {
    if (/*조건*/) {
        ...
    } else {
        ...
    }
}

IfNesting.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class IfNesting {
    public static void main(String[] args) {
        int point = 78;

        if (point > 70 && point <= 80) {
            if (point > 77) {
                System.out.println("C+ 입니다.");
            } else if (point < 74) {
                System.out.println("C- 입니다.");
            } else {
                System.out.println("C0 입니다.");
            }
        }
    }
}
출력결과
1
C+ 입니다.

#02. if-for 구조

특정 조건이 참으로 판단되어 블록안에 진입했을 때, 반복을 수행하는 구조.

IfFor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class IfFor {
    public static void main(String[] args) {
        int k = 10;
        // int k = 3;

        if (k > 1 && k < 10) {
            for (int i=1; i<10; i++) {
                System.out.printf("%d x %d = %d\n", k, i, k*i);
            }
        } else {
            System.out.println("2~9 사이의 수식만 출력합니다.");
        }
    }
}
출력결과

k가 3인 경우

1
2
3
4
5
6
7
8
9
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27

k가 10인 경우

1
2~9 사이의 수식만 출력합니다.

#03. for-if 구조

반복문 안에서 매 반복 수행시마다 조건을 판별한다. 주로 반복문에 사용되는 조건값에 대한 조건 판별을 위해 사용된다.

ForIf.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ForIf {
    public static void main(String[] args) {
        int max = 10;
        int oddSum = 0;
        int evenSum = 0;

        for (int i=1; i<=max; i++) {
            if (i % 2 == 0) {
                System.out.printf("%d는 짝수\n", i);
                evenSum += i;
            } else {
                System.out.printf("%d는 홀수\n", i);
                oddSum += i;
            }
        }

        System.out.printf("1~%d까지 홀수들의 합: %d\n",max, oddSum);
        System.out.printf("1~%d까지 짝수들의 합: %d\n",max, evenSum);
    }
}
출력결과
1
2
3
4
5
6
7
8
9
10
11
12
1는 홀수
2는 짝수
3는 홀수
4는 짝수
5는 홀수
6는 짝수
7는 홀수
8는 짝수
9는 홀수
10는 짝수
1~10까지 홀수들의 합: 25
1~10까지 짝수들의 합: 30

CommonMultiple.java

어떤 수 i가 x로 나누어도 나머지가 0이고 y로 나누어도 나머지가 0일 때 이 수를 x와 y의 공배수라고 한다.

2부터 9사이의 두 개의 정수 x, y를 입력받아 1부터 100까지의 범위 안에서 x와 y의 공배수를 모두 출력하고 공배수의 총 합인 sum값을 구해 출력하시오.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;

public class CommonMultiple {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);

        System.out.print("x를 입력하세요: ");
        int x = reader.nextInt();

        System.out.print("y를 입력하세요: ");
        int y = reader.nextInt();

        // 합산 결과를 저장할 변수
        int sum = 0;

        // 1부터 100까지 반복 설정
        for (int i=1; i<=100; i++) {
            // x로 나누었을 때 나머지가 0이고 y로 나누었을 때 나머지가 0인 값 판별
            if (i % x == 0 && i % y == 0) {
                System.out.println(i);
                sum+=i;
            }
        }

        System.out.println("공배수의 총 합: " + sum);
    }
}
출력결과
1
2
3
4
5
6
7
8
9
x를 입력하세요: 3
y를 입력하세요: 5
15
30
45
60
75
90
공배수의 총 합: 315

LastNone.java

반복 수행 시 마지막 회차는 생략하도록 처리하는 방법

1
2
3
4
5
6
7
8
9
10
11
12
public class LastNone {
    public static void main(String[] args) {
        for (int i=0; i<10; i++) {
            // 조건값이 마지막이 아닌 경우만 실행하도록 if문을 구성
            // [공식1] 조건식이 "변수 < 최대값" 인 경우 -> 변수 + 1 < 최대값
            // [공식2] 조건식이 "변수 <= 최대값" 인 경우 -> 변수 < 최대값
            if (i + 1 < 10) {
                System.out.println("i=" + i);
            }
        }
    }
}

#04. For-For 구조

바깥의 반복문(부모)이 1회 수행할 때 마다 안쪽의 반복문(자식)이 매번 처음부터 새로 시작하는 이중 반복문구조.

두 반복문간의 조건값이 서로 달라야 한다.

ForFor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ForFor {
    public static void main(String[] args) {
        for (int i=0; i<3; i++) {
            System.out.println("i에 대한 반복 수행 시작 >> i=" + i);

            for (int j=0; j<5; j++) {
                System.out.printf("\ti=%d, j=%d\n", i, j);
            }

            System.out.println("i에 대한 반복 수행 종료 >> i=" + i);
        }
    }
}
출력결과
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
i에 대한 반복 수행 시작 >> i=0
    i=0, j=0
    i=0, j=1
    i=0, j=2
    i=0, j=3
    i=0, j=4
i에 대한 반복 수행 종료 >> i=0
i에 대한 반복 수행 시작 >> i=1
    i=1, j=0
    i=1, j=1
    i=1, j=2
    i=1, j=3
    i=1, j=4
i에 대한 반복 수행 종료 >> i=1
i에 대한 반복 수행 시작 >> i=2
    i=2, j=0
    i=2, j=1
    i=2, j=2
    i=2, j=3
    i=2, j=4
i에 대한 반복 수행 종료 >> i=2

Gugu.java

2단부터 9단까지의 모든 구구단 수식을 출력하세요.

마지막 9단을 제외한 모든 단은 종료시마다 구분선 (-------)을 출력하도록 구현하세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Gugu {
    public static void main(String[] args) {
        for (int i=2; i<10; i++) {
            for (int j=1; j<10; j++) {
                System.out.printf("%d x %d = %2d\n", i, j, i*j);
            }

            if (i + 1 < 10) {
                System.out.println("--------------");
            }
        }
    }
}
출력결과
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
2 x 1 =  2
2 x 2 =  4
2 x 3 =  6
2 x 4 =  8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
--------------
3 x 1 =  3
3 x 2 =  6
3 x 3 =  9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
--------------
4 x 1 =  4
4 x 2 =  8

... 생략 ...

8 x 7 = 56
8 x 8 = 64
8 x 9 = 72
--------------
9 x 1 =  9
9 x 2 = 18
9 x 3 = 27
9 x 4 = 36
9 x 5 = 45
9 x 6 = 54
9 x 7 = 63
9 x 8 = 72
9 x 9 = 81

이중 반복문에서 안쪽 반복문의 반복 범위를 동적으로 설정하기

자식 반복문의 조건식이 부모 반복문의 조건변수를 활용하여 구성되면 자식 반복문의 반복 범위에 변화를 줄 수 있다.

IncreaseCondition.java

1부터 5까지의 범위를 갖는 반복문 안에 자식 반복문을 추가하고 자식 반복문이 부모 반복문의 반복 회차 만큼 실행되록 하기

1
2
3
4
5
6
7
8
9
10
11
12
13
public class IncreaseCondition {
    public static void main(String[] args) {
        for (int i=0; i<5; i++) {
            for (int j=0; j<i+1; j++) {
                System.out.printf("i=%d, j=%d\n", i, j);
            }

            if (i + 1 < 5) {
                System.out.println("------");
            }
        }
    }
}
출력결과
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
i=0, j=0
------
i=1, j=0
i=1, j=1
------
i=2, j=0
i=2, j=1
i=2, j=2
------
i=3, j=0
i=3, j=1
i=3, j=2
i=3, j=3
------
i=4, j=0
i=4, j=1
i=4, j=2
i=4, j=3
i=4, j=4

StarAsc.java

아래의 출력결과가 표시되로록 구현하시오.

변수는 반복문에 사용되는 i, j외에 사용할 수 없으며 출력문은 System.out.print()만을 사용해야 합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class StarAsc {
    public static void main(String[] args) {
        // 바깥의 반복은 행을 결정한다.
        for (int i=0; i<7; i++) {
            // 안쪽의 반복은 열을 결정한다.
            // -> i가 0일때 1회를 수행하기 위해서 j < 1
            // -> i가 1일때 2회를 수행하기 위해서 j < 2
            // -> i가 2일때 3회를 수행하기 위해서 j < 3
            // -> i가 3일때 4회를 수행하기 위해서 j < 4
            // -> i가 n일때 i+1회를 수행하기 위해서 j < i+1
            for (int j=0; j<i+1; j++) {
                System.out.print("*");
            }
            System.out.print("\n");
        }
    }
}
출력결과
1
2
3
4
5
6
7
*
**
***
****
*****
******
*******

StarDesc.java

StarAsc.java 예제에서 자식 반복문의 j값에 대한 조건식만 수정하여 반대의 결과가 표시되도록 소스코드를 수정하시오.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class StarDesc {
    public static void main(String[] args) {
        // 바깥의 반복은 행을 결정한다.
        for (int i=0; i<7; i++) {
            // 안쪽의 반복은 열을 결정한다.
            // -> i가 0일때 7회를 수행하기 위해서 j < 7
            // -> i가 1일때 6회를 수행하기 위해서 j < 6
            // -> i가 2일때 5회를 수행하기 위해서 j < 5
            // -> i가 3일때 4회를 수행하기 위해서 j < 4
            // -> i가 n일때 7-i회를 수행하기 위해서 j < 7-i
            for (int j=0; j<7-i; j++) {
                System.out.print("*");
            }
            System.out.print("\n");
        }
    }
}
출력결과
1
2
3
4
5
6
7
*******
******
*****
****
***
**
*

#05. 변수의 유효성 범위 (변수의 스코프)

1) 변수의 유효성 범위 확인

변수는 자신이 최초로 선언된 블록 {}보다 바깥 블록에서는 인식되지 못하고 자신이 선언된 블록보다 안쪽 블록에서는 식별 가능하다.

ValueRange1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ValueRange1 {
    public static void main(String[] args) {
        if (true) {
            int num = 100;

            for (int i=0; i<5; i++) {
                // 선언된 위치보다 하위 블록에서는 식별 가능
                num++;
            }
        }

        // 선언된 위치보다 바깥 블록이므로 에러
        System.out.println(num);
    }
}
출력결과

컴파일시에 아래와 같은 에러 발생함

1
2
3
4
5
6
ValueRange.java:13: error: cannot find symbol
        System.out.println(num);
                           ^
  symbol:   variable num
  location: class ValueRange
1 error

2) for문의 초기식에 대한 유효성 범위

for문의 초기식에서 선언한 변수도 for문에 속한것으로 보기 때문에 for문을 벗어나서는 인식되지 못한다.

ValueRange2.java

1
2
3
4
5
6
7
8
9
10
11
12
public class ValueRange2 {
    public static void main(String[] args) {
        int num = 100;

        for (int i=0; i<5; i++) {
            // 선언된 위치보다 하위 블록에서는 식별 가능
            num++;
        }

        System.out.println(i);   // <-- 에러
    }
}
출력결과

컴파일시에 아래와 같은 에러 발생함

1
2
3
4
5
6
ValueRange2.java:12: error: cannot find symbol
        System.out.println(i);   // <-- 에러
                           ^
  symbol:   variable i
  location: class ValueRange2
1 error

3) 서로 다른 블록간의 변수 중복 선언

선언된 위치를 기준으로 바깥 블록에서는 그 변수를 인식하지 못하기 때문에 서로 다른 블록간에는 중복 선언이 가능하다.

ValueRange3.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ValueRange3 {
    public static void main(String[] args) {
        int target = 100;

        if (target == 100) {
            // 아래에서 선언된 num은 if 블록 밖에서는 인식되지 않는다.
            int num = target + 100;
            System.out.println(num);
        } else {
            // 아래에서 선언된 num은 else 블록 밖에서는 인식되지 않는다.
            int num = target - 100;
            System.out.println(num);
        }
    }
}
출력결과
1
200

#06. 반복문의 흐름제어

1) 무한루프

반복문의 조건식 설정상의 오류로 반복문이 종료되지 않고 영원히 실행되는 상태.

반복문이 실행되는 동안은 순간적으로 CPU의 점유율이 100%까지 올라가기 때문에 다른 프로그램들이 컴퓨터의 하드웨어 자원을 사용하지 못하게 되어 전체적으로 컴퓨터의 성능 저하가 발생한다.

그러므로 무한루프에 빠지지 않도록 주의해야 한다.

InfiniteLoop1.java

1
2
3
4
5
6
7
8
9
public class  InfiniteLoop1 {
    public static void main(String[] args) {
        int num = 1;
        while (true) {
            System.out.println("Hello World >> " + num);
            num++;
        }
    }
}
출력결과

Sublime에서는 Tools > Cancel Build 메뉴를 사용하여 실행중인 자바프로그램을 종료해야 한다. 단순히 Esc만 누를 경우 자바프로그램이 종료되지 않은 상태로 출력창만 닫힌다.

1
2
3
4
5
6
... 생략 ...
Hello World >> 87966
Hello World >> 87967
Hello World >> 87968
Hello World >> 87969
... 생략 ...

InfiniteLoop2.java

1씩 증가해서 언젠가는 10을 초과해야 하는 i값이 1씩 감소하여 점점 10보다 더 작아지기 때문에 무한루프에 빠지게 된다.

1
2
3
4
5
6
7
public class  InfiniteLoop2 {
    public static void main(String[] args) {
        for (int i=0; i<10; i--) {
            System.out.println("i=" + i);
        }
    }
}
출력결과
1
2
3
4
5
... 생략 ...
i=-102396
i=-102397
i=-102398
... 생략 ...

2) break

반복문(while, for)안에서 반복문을 강제로 중단시키는 기능을 한다.

반복을 몇 번 수행해야 할지 가늠할 수 없을 때 의도적으로 무한루프를 수행시키기도 하는데 이 경우 특정 조건이 충족되면 반복을 중단하도록 설정할 수 있다.

Break.java

두 배씩 증가하는 값이 500보다 커지기 위해서는 총 몇 번 곱해야 하는지 카운트하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Break {
    public static void main(String[] args) {
        int times = 1;  // 2배씩 커지는 값을 저장할 변수
        int count = 0;  // 반복 횟수를 저장할 변수
        while (true) {
            count++;    // 반복을 수행한 횟수를 1증가 시킨다.
            times *= 2; // 2배 증가
            System.out.println(times);

            if (times > 500) {
                break;  // 강제종료
            }
        }
        System.out.println("총 " + count + "회 수행했습니다.");
    }
}

3) continue

반복문 안에서 현재 회차를 중단하고 다음 회차로 넘어가게 한다.

  • while문: 조건식으로 강제 이동한다.
  • for문: 증감식으로 강제 이동한다.

Continue1.java

홀수만 출력하는 프로그램

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Continue1 {
    public static void main(String[] args) {
        int num = 0;

        while (num < 10) {
            num++;
            if (num % 2 == 0) {
                continue;   // 짝수인 경우 조건식으로 강제 이동
            }
            System.out.println(num);
        }
    }
}
출력결과
1
2
3
4
5
1
3
5
7
9

사실 아래와 같이 코딩하는 것이 더 간결하기 때문에 잘 사용되지 않는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Continue1 {
    public static void main(String[] args) {
        int num = 0;

        while (num < 10) {
            num++;
            if (num % 2 != 0) {
                // 홀수만 출력
                System.out.println(num);
            }
        }
    }
}

Continue2.java

0부터 10 미만의 수 중에서 홀수의 합을 구하는 과정을 출력하는 프로그램

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Continue2 {
    public static void main(String[] args) {
        int sum = 0;

        for (int i=0; i<10; i++) {
            if (i % 2 == 0) {
                continue;   // for문의 증감식인 `i++`로 이동한다.
            }
            sum += i;
            System.out.println(sum);
        }
    }
}
출력결과
1
2
3
4
5
1
4
9
16
25

사실 아래와 같이 코딩하는 것이 더 간결하기 때문에 잘 사용되지 않는다.

1
2
3
4
5
6
7
8
9
10
11
12
public class Continue2 {
    public static void main(String[] args) {
        int sum = 0;

        for (int i=0; i<10; i++) {
            if (i % 2 != 0) {
                sum += i;
                System.out.println(sum);
            }
        }
    }
}

4) 반복의 변화량 조절

거의 대부분의 경우 조건값이 1씩 증가하거나 1씩 감소하도록 설정하지만 필요하다면 변화량을 조절하여 2씩 증가하거나 10씩 증가하는 등 다양하게 설정할 수 있다.

Step1.java

while문을 써서 0부터 100 미만까지의 수 중에서 10의 배수만 합산하는 프로그램

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Step1 {
    public static void main(String[] args) {
        int sum = 0;            // 총 합을 저장할 변수
        int i = 0;              // 초기식

        while (i < 100) {       // 조건식
            sum += i;
            System.out.printf("i=%d, sum=%d\n", i, sum);

            i += 10;            // 증감식 (10씩 증가)
        }
    }
}
출력결과
1
2
3
4
5
6
7
8
9
10
i=0, sum=0
i=10, sum=10
i=20, sum=30
i=30, sum=60
i=40, sum=100
i=50, sum=150
i=60, sum=210
i=70, sum=280
i=80, sum=360
i=90, sum=450

Step2.java

0부터 10미만 수 중에서 짝수만 골라서 합산하는 프로그램

짝수만 판단하기 위해 증감식이 2씩 증가한다.

1
2
3
4
5
6
7
8
9
10
public class Step2 {
    public static void main(String[] args) {
        int sum = 0;            // 총 합을 저장할 변수

        for (int i=0; i<10; i+=2) {
            sum += i;
            System.out.printf("i=%d, sum=%d\n", i, sum);
        }
    }
}
출력결과
1
2
3
4
5
i=0, sum=0
i=2, sum=2
i=4, sum=6
i=6, sum=12
i=8, sum=20

크리에이티브 커먼즈 라이선스 ITPAPER(호쌤,쭈쌤)에 의해 작성된 ≪[Java] 기본문법 활용하기≫은(는) 크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 4.0 국제 라이선스에 따라 이용할 수 있습니다.
이 라이선스의 범위 이외의 이용허락을 얻기 위해서는 leekh4232@gmail.com으로 문의하십시오.

comments powered by Disqus