Theme. Calendar class

 

들어가기에 앞서, 현재 글을 적고 있는 시점의 날짜 (2022/12/26) 를 구해보자.

 

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
package test;
 
import java.util.Calendar;
 
public class Practice {
 
    public static void main(String[] args) {
        
     // Calendar class: 일정관리, 회원관리, 인사관리
        
     // Calendar class 객체 생성하는 방법
            // Calendar cal = new GregorianCalendar();
            // Calendar cal = Calendar.getInstance();  -> 이 방법을 주로 사용한다.
        
        Calendar cal = Calendar.getInstance();
        
        //오늘 날짜 취득 (getter)
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH) + 1// get(Calendar.MONTH)의 결과가 0(1월) ~ 11(12월)이므로 +1 해주도록 한다.
        int day = cal.get(Calendar.DATE);
        
        System.out.println(year + "/" + month + "/" + day);
        
    }
    
}
 
cs

Calendar class 객체를 생성하는 방법은 주로 getInstance()를 사용하고, 

get(Calendar.MONTH)의 결과는 0 ~ 11이므로 결과에 + 1을 하여 몇 월인지 쉽게 이해하도록 하는 것을 기억하자.

 

이번엔, 현재가 아닌 특정 시점의 날짜를 세팅해보자.

2023년 3월 26일을 세팅해보도록 한다. 

이 역시 MONTH를 세팅할 때, 주의해라. 결과 값 2가 3월이다.

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
package test;
 
import java.util.Calendar;
 
public class Practice {
 
    public static void main(String[] args) {
        
     // 날짜를 직접 세팅 (setter)
        
    Calendar cal = Calendar.getInstance();
    // 2023년 3월 26일로 세팅해보자.
    cal.set(Calendar.YEAR, 2023); //2023년
    cal.set(Calendar.MONTH, 2); // 2(3월)!!
    cal.set(Calendar.DATE, 26); //26일
    
    int year = cal.get(Calendar.YEAR);
    int month = cal.get(Calendar.MONTH) + 1;
    int day = cal.get(Calendar.DATE);
    
    System.out.println(year + "/" + month + "/" + day);
    
        
    }
    
}
 
cs

 

날짜를 세팅하게 되면 이후 코드들은 현재 날짜가 아닌 세팅된 날짜를 기준으로 실행되게 된다.

 

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
package test;
 
import java.util.Calendar;
 
public class Practice {
 
    public static void main(String[] args) {
    
    Calendar cal = Calendar.getInstance();    
    
    // 오전/오후
    String ampm = cal.get(Calendar.AM_PM) == 0 ? "오전":"오후";  // 삼항연산자 이용    
    System.out.println(ampm);
        
    // 현재 요일
    int weekday = cal.get(Calendar.DAY_OF_WEEK); // 1(일요일) ~ 7(토요일)
    System.out.println(weekday);
    
    // 달의 마지막 날
    int lastday = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
    System.out.println(lastday);
    
    
    }
    
}
 
cs

 

지난 2022년 11월 달력을 만들어보자.

 

달력을 만들기 위해, 2022년 11월 1일과 말일의 앞뒤 부분에 존재하는 빈칸들을 표현하기 위한 코드를 작성해보도록 한다.

 

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package test;
 
import java.util.Calendar;
 
public class Practice {
 
    public static void main(String[] args) {
    
    Calendar cal = Calendar.getInstance();    
    
    //2022년 11월 달력 만들기
    
    //2022년 11월 1일로 세팅
    cal.set(Calendar.YEAR, 2022); //2022년
    cal.set(Calendar.MONTH, 11 - 1); //11월
    cal.set(Calendar.DATE, 1); //1일
    
    int year = cal.get(Calendar.YEAR);
    int month = cal.get(Calendar.MONTH) + 1;
    
    //11월의 말일은?
    int lastdate = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
    
    //11월 1일의 요일은?
    int startday = cal.get(Calendar.DAY_OF_WEEK);
    
    //달력 표현
    System.out.println("< " + year + "년 " + month + "월 >");
    System.out.println("=========================================================");
    
    String week_day = "일월화수목금토";
    for (int i = 0; i < week_day.length(); i++) {
        char c = week_day.charAt(i);
        System.out.print(c + "\t");
    }
    
    System.out.println();
    System.out.println("=========================================================");
    
    //11월 달력의 위쪽 빈칸
    for (int i = 0; i < startday - 1; i++) {
        System.out.print("*" + "\t");
    }
    
    //11월 1일부터 말일까지 채우기
    int date = 1;
    
    for (int i = 0; i < lastdate; i++) {
        System.out.print(date + "\t");
        if((date + startday -1) % 7 == 0 ) { // startday(화요일이므로 3) - 1 == 2
            System.out.println();             // (startday - 1)을 통해 빈칸(*)을 채워주고 
                                             // 7로 나눠서 나누어 떨어지는 토요일마다 줄 바꿈
        }
        
        date++;
    }
    
    //12월 달력의 아래쪽 빈칸
    //(startday - 1)로 빈칸을 고려하여 더해주고 이를 7로 나눈 나머지 만큼 마지막 주에 날짜가 채워지므로
    // 빈칸은 (7 - 나눈 나머지)개
    for (int j = 0; j < ( 7 - (startday - 1 + lastdate) % 7 ); j++) {
        System.out.print("*" + "\t");     
    }
    System.out.println();
    System.out.println("=========================================================");
    
 
    }
    
}
 
cs

< console >

 

 

비교를 위해 2022년 11월 달력 사진을 첨부한다. (출처: 네이버 달력)

 

'Java' 카테고리의 다른 글

생성자(constructor)  (0) 2022.12.30
파일(File)  (0) 2022.12.27
정렬(Sorting) - 오름차순, 내림차순  (0) 2022.12.26
예외(Exception) 처리  (0) 2022.12.26
함수 사용  (4) 2022.12.26

정렬 방법 중에서 오름차순과 내림차순에 대해서 알아보자.

 

int[] num = { 3, 6, 4, 8, 1} 를 오름차순으로 정렬

1. num[0] 값과 나머지 num[1] ~ num[4]의 값을 한 쌍씩 비교한다.

2. 이때, num[0] > num[i] (i = 1,2,3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 6, 4, 8, 3 }이 된다.

3. num[1] 값과 나머지 num[2] ~ num[4]의 값을 한 쌍씩 비교한다.

4. 이때, num[1] > num[i] (i = 2,3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 4, 6, 8, 3 } -> { 1, 3, 6, 8, 4 }가 된다.

5. num[2] 값과 나머지 num[3] , num[4]의 값을 한 쌍씩 비교한다.

6. 이때, num[2] > num[i] (i = 3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 3, 4, 8, 6 }이 된다.

7. num[3] 값과 num[4]의 값을 비교한다. 그 결과 최종적으로 배열 num이 { 1, 3, 4, 6, 8 }이 되었다.

 

내림차순의 경우는 부등호 방향을 반대로 하여 비교한다.

 

이제 직접 코드를 작성하여 결과를 비교해보자.

 

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
package test;
 
import java.util.Arrays;
 
public class Practice {
 
    public static void main(String[] args) {
        
        int[] num = {3,6,4,8,1};
        int temp;
        //오름차순
        for (int i = 0; i < num.length - 1; i++) {
            for(int j = i + 1; j < num.length; j++) {
                if(num[i] > num[j]) {
                    temp = num[i];   //swap
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        
        System.out.print(Arrays.toString(num));
        
    }
    
 
}
 
cs

결과는 { 1, 3, 4, 6, 8 }이다.

 

같은 논리로 내림차순 정렬을 해보면,

 

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
package test;
 
import java.util.Arrays;
 
public class Practice {
 
    public static void main(String[] args) {
        
        int[] num = {3,6,4,8,1};
        int temp;
        //내림차순
        for (int i = 0; i < num.length - 1; i++) {
            for(int j = i + 1; j < num.length; j++) {
                if(num[i] < num[j]) {
                    temp = num[i];   //swap
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        
        System.out.print(Arrays.toString(num));
        
    }
    
 
}
 
cs

결과는 { 8, 6, 4, 3, 1 }이다.

 

 

'Java' 카테고리의 다른 글

파일(File)  (0) 2022.12.27
날짜와 시간(Calendar class)  (2) 2022.12.26
예외(Exception) 처리  (0) 2022.12.26
함수 사용  (4) 2022.12.26
break, continue  (0) 2022.12.23

예외(exception)의 종류는 매우 다양하다.

 

예를 들어,

 

1. 숫자(number)를 입력해야 하는데 문자열(String)이 입력되었을 때

 

2. 배열(array)의 index 범위를 벗어났을 때

 

3. 사용하려는 class가 존재하지 않을 때

 

4. 접근하려는 위치에 file이 없을 때

 

등이 있다.

 

예외가 발생할 가능성이 있는 코드들을 적는다고 한다면, 어떤 형식으로 적어야 할까?

2가지 경우로 나눠서 그 형식에 대해 살펴보자.

 

1. 예외가 발생할 가능성이 있는 코드를 다른 코드들 안에 적을 때,

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    try {
 
        exception이 발생할 가능성이 있는 코드
         
    } catch(예외클래스1 e) {        //예외가 발생했을 때!
        메시지 출력
    } catch(예외클래스2 e) {                    
        메시지 출력
    } catch(예외클래스3 e) {                    
        메시지 출력
    } finally {
        무조건 실행 (예외가 발생하든 안하든)
        //(복구 코드) - undo / rollback
    }
cs

 

2. 예외가 발생할 가능성이 있는 코드를 함수 안에 적을 때, 

 

1
2
3
static void func() throws 예외클래스 {
        exception이 발생할 가능성이 있는 함수
    }
cs

 

간단한 코드를 통해 예시를 들어보면,

 

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
package test;
 
public class Practice {
 
    public static void main(String[] args) {
    
        int[] array = { 1,2,3 };
        
        try {
            
            for (int i = 0; i < 4; i++) {         //array.length가 3인데, 인덱스 하나가 범위 초과
                System.out.println(array[i]);
            }
            
        } catch (ArrayIndexOutOfBoundsException e) {
            //메시지 출력 방식은 여러 가지가 있다.     //결과       
            System.out.println("배열 범위 초과");   // 배열 범위 초과 
            e.printStackTrace();                 
            System.out.println(e.getMessage());      //Index 3 out of bounds for length 3
        }
 
    }
 
}
 
cs

< console >

 

위 코드를 이어서 작성해보자.("finally"의 효과를 살펴보자)

 

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
39
package test;
 
public class Practice {
 
    public static void main(String[] args) {
    
        int[] array = { 1,2,3 };
        
        System.out.println("start ---");
        
        try {
            
            for (int i = 0; i < 4; i++) {         //array.length가 3인데, 인덱스 하나가 범위 초과
                System.out.println(array[i]);
            }
            
            System.out.println("process ---");   // for문에 exception이 존재해서 실행되지 않음
            
        } catch (ArrayIndexOutOfBoundsException e) {
            //메시지 출력 방식은 여러 가지가 있다.         //결과    
            System.out.println("배열 범위 초과");   // 배열 범위 초과 
            //e.printStackTrace();                 
            //System.out.println(e.getMessage());     //    Index 3 out of bounds for length 3
        
            return//프로그램이 끝남 -> 아래 "end ---"는 실행되지 않음
        
        } catch (Exception e) {    //다른 exc eption들의 경우
            e.printStackTrace(); 
        } finally {
            System.out.println("finally ---"); //return;에도 불구하고 반드시 실행됨
        }
        
        System.out.println("end ---"); //return;에 의해 실행되지 않음
        
 
    }
 
}
 
cs

 

이제 예외가 발생할 가능성이 있는 코드를 함수 안에 작성해보자.(func() 호출 부분은 생략)

 

1
2
3
4
5
6
7
8
static void func() throws IndexOutOfBoundsException {
        int[] num = { 1,2,3 };
        
        for (int i = 0; i < 4; i++) {
            System.out.println(num[i]);
        }
        
    }
cs

Exception의 종류별로 코드를 작성해보면 다음과 같다.

 

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
39
40
41
42
43
44
45
46
47
48
49
//Exception 정리
        
        //NullPointerException - 데이터가 생성되어 있지 않음
        
        String str = null// String인 str이 비어 있다.
        
        try {
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("str이 null입니다.");
        }
    
        //ArrayIndexOutOfBoundsException - 배열의 범위를 초과
        
        int[] arr = {1,2,3};
        
        try {
            arr[3= 4;
        } catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("배열 범위 초과");
        }
        
        //FileNotFoundException - 파일을 찾을 수 없음
        File f = new File("d:\\xxxxx");
        FileInputStream is;
        
        try {
            is = new FileInputStream(f);
        } catch (FileNotFoundException e) {
            System.out.println("파일을 찾을 수 없습니다.");
        }
        
        //StringIndexOutOfBoundsException - 글자가 존재하는 범위 밖임
        String str1 = "java";
        
        try {
        str1.charAt(4);
        } catch(StringIndexOutOfBoundsException e) {
            System.out.println("문자가 존재하지 않는 공간입니다.");
        }
        
        
        //NumberFormatException - 숫자가 들어와야 하는 자리에 문자가 들어옴
        
        try {
        int i = Integer.parseInt("12a3"); //숫자형의 문자열("123"과 같은)이 들어와야 하는데, 문자가 껴있음
        } catch (NumberFormatException e) {
            System.out.println("숫자가 아닌 글자가 있습니다.");
        }
cs

 

그런데, 각각의 exception의 종류와 관계없이 모두 "Exception"을 통해 예외를 나타내 줄 수 있다. 

즉, 정확하게 분류해서 코드를 작성하지 않아도 동일한 결과를 도출할 수 있다. 아래를 보자.

 

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
39
40
41
42
43
44
45
46
47
48
49
//Exception 정리
        
        //NullPointerException - 데이터가 생성되어 있지 않음
        
        String str = null// String인 str이 비어 있다.
        
        try {
            System.out.println(str.length());
        } catch (Exception e) {
            System.out.println("str이 null입니다.");
        }
    
        //ArrayIndexOutOfBoundsException - 배열의 범위를 초과
        
        int[] arr = {1,2,3};
        
        try {
            arr[3= 4;
        } catch(Exception e) {
            System.out.println("배열 범위 초과");
        }
        
        //FileNotFoundException - 파일을 찾을 수 없음
        File f = new File("d:\\xxxxx");
        FileInputStream is;
        
        try {
            is = new FileInputStream(f);
        } catch (Exception e) {
            System.out.println("파일을 찾을 수 없습니다.");
        }
        
        //StringIndexOutOfBoundsException - 글자가 존재하는 범위 밖임
        String str1 = "java";
        
        try {
        str1.charAt(4);
        } catch(Exception e) {
            System.out.println("문자가 존재하지 않는 공간입니다.");
        }
        
        
        //NumberFormatException - 숫자가 들어와야 하는 자리에 문자가 들어옴
        
        try {
        int i = Integer.parseInt("12a3"); //숫자형의 문자열("123"과 같은)이 들어와야 하는데, 문자가 껴있음
        } catch (Exception e) {
            System.out.println("숫자가 아닌 글자가 있습니다.");
        }
cs

 

위 두 가지 방식의 코드의 실행 결과는 다음과 같다.

< console >

끝으로, while문을 이용하여 예외에 해당하지 않는 입력을 할 때까지 입력을 반복하게 하는 코드를 작성해보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Scanner sc = new Scanner(System.in);
        
    
        int number = 0;
        while(true) {
            
        System.out.print("숫자를 입력하세요 >>");
        String strNum = sc.next();
        
        try {
            number = Integer.parseInt(strNum);
        } catch(Exception e) {
            System.out.println("숫자가 아닌 글자가 존재합니다.");    
            continue;
        }
        break;
        }
cs

< console >

숫자형으로 된 문자열을 입력해야 break되는 모습

'Java' 카테고리의 다른 글

날짜와 시간(Calendar class)  (2) 2022.12.26
정렬(Sorting) - 오름차순, 내림차순  (0) 2022.12.26
함수 사용  (4) 2022.12.26
break, continue  (0) 2022.12.23
반복문 - for, while, do - while  (2) 2022.12.22

Theme. 함수 호출 및 정의

 

함수를 사용하기 위한 기본적인 형식은 다음과 같다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    // 함수의 사용 방법
        
    // 함수를 호출    
        
    }
    
    //함수를 정의
    
    //형식
    /*
    static return값의 자료형 함수명(parameter의 자료형, parameter명) {
        
        처리할 코드
        
        return 값;
    }
    */
    
}
cs

 

간단하게 함수를 만들어보면,

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    functionOne(123);    //functionOne이라는 함수를 호출.
                        //이때 123은 argument이다.
    }
    
    //함수 정의
    //함수 호출시 아래 처리 코드로 넘어가게 된다.
    static void functionOne(int n) {                   //return값이 없는 경우 "void"라고 적음
        System.out.println("호출한 수는 " + n + "입니다.");
    }
}
cs

 

위는  return값이 없어서 "void"라고 적었고, 실행 결과는 "호출한 수는 123입니다."이다. 

즉, 함수에 들어가는 값은 있는데, 나오는 값이 없는 경우라고 말할 수 있다. 

그렇다면 함수를 4가지로 나눈다면, 다음과 같이 나눌 수 있을 것이다.

 

1. 들어가는 값도 없고 나오는 값도 없는 함수

 

2. 들어가는 값은 있고 나오는 값은 없는 함수 (바로 위의 사례)

 

3. 들어가는 값은 없고 나오는 값은 있는 함수

 

4. 들어가는 값도 있고 나오는 값도 있는 함수 (가장 일반적인 함수의 사례)

 

간단하게 1번과 3번의 함수를 만들어보면, 

 

1번 함수(들어가는 값도 없고 나오는 값도 없는 함수)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    function();    //function이라는 함수를 호출.
                    
    }
    
    //함수 정의
    static void function() {                   
        System.out.println("Merry X-mas");
    }
}
cs

 

결과는 "Merry X-mas" 

 

3번 함수(들어가는 값은 없고 나오는 값은 있는 함수)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package test;
 
import java.util.Arrays;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    //들어가는 값은 없고, 나오는 값은 정수로 된 배열 형태의 "arr"
    int[] arr = function();    //function이라는 함수를 호출. 
    System.out.println(Arrays.toString(arr));                
    }
    
    //함수 정의
    static int[] function() {                   
        int[] arr = {100,200,300};
        
        return arr;
    }
}
cs

 

이제 가장 일반적인 함수의 형태를 만들어 보자.

 

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
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    //함수 functionOne, functionTwo 순서로 호출되고 결과가 나온다.
        
    int num = functionOne(7); 
    System.out.println(num);
    
    
    int n = functionTwo('e',"hello");
    System.out.println(n);
    
    }
    
    //함수 정의
    //함수 functionOne에 대한 정의
    static int functionOne(int n) {
        int r;        
        r = n * 2;
        return r;
    }
    //함수 functionTwo에 대한 정의
    static int functionTwo(char c, String s) {
        int r = s.indexOf(c + "");  // String인 s에서 char c가 몇번째에 있는지 찾는다.
        return r;                        // c + ""를 통해 자료형을 String으로 만들었다.
    }
    
    
}
cs

 

Theme. 함수 호출 방법

 

함수 호출 방법은 크게 2가지가 있다.

 

1. Call by value(값에 의한 호출)

2. Call by reference(참조에 의한 호출) - address

 

두 가지 방법의 가장 큰 차이점은 원래의 값이 보존되는가이다. 

즉, 값에 의한 호출의 경우 원래의 값을 복사하여 처리하는 것으로 원래의 값이 보존되지만,

참조에 의한 호출의 경우 원래의 값을 복사하지 않기 때문에 값이 보존되지 않는다.

기본적인 매개변수의 경우 call by value의 방법에 해당하나, 배열과 클래스의 경우 call by reference의 방법에 해당한다.

 

둘의 차이를 확인해보자.

 

1. Call by value(값에 의한 호출)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    
    int num = 3;
    funcOne(3);
    System.out.println("num = " + num);
    }
    
    //함수 정의
    
    static void funcOne(int n) {
        n = n * 2;
        System.out.println("n = " + n);
    }
}
cs

 

결과는 n = 6, num = 3이 나온다.

즉, 3이라는 value가 함수를 통해 6이라는 결과(n = 6)로 처리되었지만, 그 원래의 값은 변하지 않고 3(num = 3)이 나온 것을 확인할 수  있다.

 

2. Call by reference(참조에 의한 호출)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
    //함수 호출
    
    int[] array = new int[1];
    array[0= 3;
    funcTwo(array);
    System.out.println("array[0] = " + array[0]);
    }
    
    //함수 정의
    
    static void funcTwo(int[] arr) {
        arr[0= arr[0* 2;
        System.out.println("arr[0] = " + arr[0]);
    }
}
cs

 

 

결과는 arr[0] = 6, array[0] = 6이 나온다.

즉, 배열 자체가 함수에 할당되어 원래의 값이 6으로 변한 것을 확인할 수 있다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'Java' 카테고리의 다른 글

정렬(Sorting) - 오름차순, 내림차순  (0) 2022.12.26
예외(Exception) 처리  (0) 2022.12.26
break, continue  (0) 2022.12.23
반복문 - for, while, do - while  (2) 2022.12.22
조건문 - if, switch  (0) 2022.12.22

Theme. break문

반복문에서 break문은 자신이 포함된 가장 가까운 반복문을 벗어난다. 

아래 코드를 살펴보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        for(int i = 0; i < 10; i++) {
            System.out.println("for loop " + i);
            
            if(i == 5) {
                System.out.println("i == 5입니다.");
                break// for문을 벗어난다.
            }
        }
        
    }
}
cs

 

for문을 통해 i가 0부터 4까지 출력이 되다가,

i = 5일 때, if문의 조건식이 참이 되어 "i == 5입니다."라는 문장이 출력된다.

그 후, break문을 통해 for문을 벗어나게 된다.

< console >

break문을 활용한 코드를 살펴보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        
        int[] number = {13,45,27,-36,78};  // number 배열 생성
        // number 배열에서 음수가 나오기 전까지만 출력해보자!
        for ( int i = 0; i < number.length; i++) {
                                    // 첫 번째 ~ 세 번째 요소는 양수이므로 그대로 출력된다.
            if(number[i] < 0) {        // 네 번째 요소인 -36은 음수이므로 if문의 조건식이 참이 된다.        
                break;                // if의 조건식이 참이므로 break문을 통해 for문을 벗어난다.
            }
            System.out.println("number[" + i + "] = " + number[i]);
        }    
    }
}
cs

 

아래 코드는 반복문에서 break문은 자신이 포함된 가장 가까운 반복문을 벗어난다는 성질에 대해 이해할 수 있는 코드이다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        for(int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
            
            for (int j = 0; j < 8; j++) {
                System.out.println("\tj = " + j);
                
                if(i == 5 && j == 4) { //i가 5일 때, j는 0부터 4까지만 출력된다.
                    break;        // break문은 내부 for문만을 탈출한다. 
                }                  // 따라서, i가 6일 때도 계속 loop 돌아간다.
            }
        }                        
        
    }
}
cs

 

< console >

i = 5일 때, j는 0부터 4까지만 출력되나, 이후 다시 모두 출력되는 모습

 

위의 코드에서 발생한 문제를 해결하고자 적절하게 break문을 사용하는 방법에 대해 알아보자.

 

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
39
40
41
42
43
44
45
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        // break문을 설정하는 방법
        
        // 1. loop문 수에 맞춰서 break를 설정한다.
        boolean b = false;  // 초기화(임의로 값 넣어놓음)
        
        for(int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
            
            for (int j = 0; j < 8; j++) {
                System.out.println("\tj = " + j);
                
                if(i == 5 && j == 4) {
                    b = true;
                }
                if(b == true) {
                    break;       // 내부의 for문을 벗어남
                }
            }
            if(b == true) {
                break;              // 외부의 for문을 벗어남
            }
        }
        
        System.out.println();
        
        // 2. 지정된 break 사용
        loopout: for(int i = 0; i < 10; i++) {       //임의로 for문에 loopout이라고 지정
            System.out.println("i = " + i);
            
            for (int j = 0; j < 8; j++) {
                System.out.println("\tj = " + j);
                
                if(i == 5 && j == 4) {
                    break loopout;     // 지정된 loopout이라는 for문(외부)을 벗어남
                }                        // 외부 for문을 벗어난 것은 전체 for문을 벗어난 것!
            }
        }                
        
    }
}
cs

 

< console >

올바르게 break문을 사용한 결과

 

 

Theme. continue문

continue문은 반복문 내에서만 사용될 수 있으며, 반복이 진행되는 도중에 continue문을 만나면 반복문의 끝으로 이동하여 다음 반복으로 넘어간다. for문의 경우 증감식으로 이동하며, while문의 경우 조건식으로 이동한다.

즉, continue는 "skip(생략)"의 느낌을 통해 이해할 수 있다.

 

먼저, for문에서의 continue문을 살펴보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        for(int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
            
            System.out.println("for 처리1");
            
            if(i > 5) {
                continue;      // i가 6부터는 처리2가 안되고 처리1만 됨
            }
            
            System.out.println("for 처리2"); // continue문에 의해 생략되는 부분
        }
    }
}
cs

i가 0부터 5일 때까지는 처리1, 처리2가 출력되지만, i가 6일 때부터는 continue문에 의해 처리 2는 생략되고, 처리1만 출력된다.

 

< console >

for문에서 continue문을 사용한 코드들을 더 살펴보자.

 

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
package test;
 
import java.util.Scanner;
 
public class MainClass {
    public static void main(String[] args) {
    
        // 배열 중 양수만 출력하는 코드
        int[] array = {2,-6,3,-4,5}; 
        
        for(int i = 0; i < array.length; i++) {
            
            if(array[i] <= 0 ) {
                continue;    // if의 조건식이 참이면, 아래 처리를 하지 않고, for문의 증감식으로 이동
            }
            
            System.out.println("array[" + i + "] = " + array[i]);
        }
        
        
        Scanner sc = new Scanner(System.in);
        
        int number;
        
        for(int i = 1; i < 4; i++) {
            System.out.print("number " + i + "번째 = ");
            number = sc.nextInt();
            
            if(number <= 0) {
                continue;
            }
            System.out.println("number: " + number);  //continue문에 의해 생략될 수 있는 문장
        }    
                    
    }
}
cs

 

이제 while문에서의 continue문을 살펴보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package test;
 
import java.util.Scanner;
 
public class MainClass {
    public static void main(String[] args) {
    
        int number;
        Scanner sc = new Scanner(System.in);
        int w = 0;
        while(w < 3) {
            System.out.print("number " + (w+1+ "번째 = ");
            number = sc.nextInt();
            
            if(number <= 0) {
                continue;    //continue되면 아래 처리, 증감식 다 생략하고 조건식 부분으로 이동
            }                 //w가 증가가 안되므로 양수를 입력하지 않으면 계속 반복해서 입력해야 함
                                // 즉, 양수를 입력해야 w가 증가하면서 넘어간다.
            System.out.println("number: " + number);
            w++;
        }
                    
    }
}
cs

 

w가 증가할 때마다 number를 입력받는데, 그 number가 0보다 작거나 같으면, continue문 아래의 처리해야할 문장, 증감식이 생략되게 된다. 그래서 아래 결과와 같이 -1을 넣으면 출력은 되지 않고, 반복해서 입력만 할 수 있는 결과만 출력되는 것이다.

 

< console >

 

while문을 이용하여 양수의 숫자 5개를 입력받고, 이를 배열에 저장해 출력하는 코드를 작성해보자.

 

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
package test;
 
import java.util.Arrays;
import java.util.Scanner;
 
public class MainClass {
    public static void main(String[] args) {
    
        Scanner sc = new Scanner(System.in);
        // 입력 받을 배열 준비
        int[] numArr = new int[5];
        // loop로 입력
        int w = 0;
        while(w < numArr.length) {
 
            System.out.print((w+1+ "번째 수 = ");
            int num = sc.nextInt();
        //  제어(continue)
            if(num <= 0) {
                System.out.println("양수를 입력해 주십시오.");
                continue;
            }    
            
            numArr[w] = num;
            w++;
        }
        //배열 출력
        System.out.println(Arrays.toString(numArr));                        
                    
    }
}
cs

 

< console >

 

 

 

 

 

 

 

 

 

 

 

 

 

'Java' 카테고리의 다른 글

예외(Exception) 처리  (0) 2022.12.26
함수 사용  (4) 2022.12.26
반복문 - for, while, do - while  (2) 2022.12.22
조건문 - if, switch  (0) 2022.12.22
형변환  (0) 2022.12.21

Theme. for문

 

먼저, 기본적인 for문 하나를 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int i;
        
        for(i = 0; i < 5 ; i++) {   // (초기화; 조건식; 증감식)
            System.out.println("for loop i = " + i); //수행될 문장
        }
        
        System.out.println("i = " + i); // for문을 빠져나왔을 때, i 값
                
    }
}
 
 
cs

설명하자면,

변수 i에 0을 저장한다음, 매 반복마다 i의 값을 1씩 증가시킨다.

i값이 5가 되면 더이상 5보다 작지 않기 때문에 i < 5가 거짓이 되어 반복을 마친다. 

즉 i값이 0부터 4까지 1씩 증가하니까 모두 5번 반복하는 것이 된다. 

그 결과는 다음과 같다.

< Console >

이제 for문의 형식에 대해 살펴보자

 

1
2
3
    for (초기화; 조건식; 증감식) {
        조건식이 참일 때 수행될 문장을 적는다.
    }
cs

사용될 변수를 초기화할 때, 둘 이상의 변수가 필요하다면 "i = 0, j = 1"과 같이 콤마 ","를 사용한다.

증감식의 경우 "i++", "i--" 을 주로 사용하나, "i = i + 2"처럼 필요에 따라 작성할 수도 있다.

 

for문을 사용하여 코드를 작성해보자.

 

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int i;
        
        for(i = 0; i < 5 ; i++) {   // (초기화; 조건식; 증감식)
            System.out.println("for loop i = " + i); //수행될 문장
        }
        System.out.println("i = " + i); // for문을 빠져나왔을 때, i 값
                
        for(i = 1; i <= 10 ; i++) {
            System.out.println("for loop i = " + i);
        }
        System.out.println("i = " + i);
        
        for (i = 0; i < 10; i = i + 2) {
            System.out.println("for loop i = " + i);
        }
        System.out.println("i = " + i);
        
        for (i = 10; i > 0; i--) {
            System.out.println("for loop i = " + i);
        }
        
        /*
        무한 loop를 조심하자
        for (i = 0;  ; i++) {
            System.out.println("for loop i = " + i);
        }
        */
        
        // for문 안에서만 사용할 수 있는 변수 선언 및 사용
        for(int j = 0; j < 10; j++) {
            System.out.println("for loop j = " + j);
        }
        
        // 2중 for
        //  n = 0 1 2 3 4 일 때, 각각!! k = 0 1 2 실행 
        for (int n = 0; n < 5; n++) {           // n = 0 1 2 3 4
            System.out.println("for n = " + n);
            
            for(int k = 0; k < 3; k++) {        // k = 0 1 2
                System.out.println("\tfor k = " + k);
            }
        }
        
        // for + if + array
        
        int[] array = {24568};
        
        for(i = 0; i < array.length ; i++) {
            System.out.println(array[i]);
        }
        
        for(i = 0; i < array.length; i++) {
            if(array[i] == 6) {
                System.out.println("6을 찾았습니다.");
            }
        }
        
        for(i = 0; i < array.length; i++) {
            if(array[i] % 2 == 1) {     //홀수 표현
                System.out.println("홀수가 있다 " + array[i] + "입니다");
            }
        }
        
        for(i = 0; i < array.length; i++) {
            if(array[i] % 2 == 0) {      //짝수 표현
                System.out.println("짝수가 있다 " + array[i] + "입니다");
            }
        }
        
    }
}
 
 
cs

Theme. while문

while문은 조건식이 참(true)인 동안, 즉 조건식이 거짓이 될 때까지 블럭 { }내의 문장을 반복한다. 

 

먼저 기본적인 while문을 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int w;
        w = 0;   // 초기화
        while(w < 5) {      // 조건식
            System.out.println("while loop " + w);   // 처리
            w++// 증감식
        }
        
    }
}
 
 
cs

결과는 다음과 같다.

< Console >

 

형식을 보면 다음과 같다.

 

1
2
3
4
5
    초기화
While (조건식) {
            조건식의 연산결과가 참(true)인 동안, 반복될 문장들을 적는다.
            증감식
    }
 
cs
 
 

for문에 비해 while문은 구조가 간단하다.

for문과 while문을 비교해보자. (같은 결과가 나오도록 하는 코드를 비교)

 

Theme. 이중 for문과 이중 while문

 

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
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        // 이중 for문 vs 이중 while문
        // 이중 for문
        
        for(int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
            for(int j = 0; j < 3; j++) {
                System.out.println("\tj = " + j);
            }
        }
        
        // 이중 while문
        
        int w1, w2;
        w1 = 0;
        while(w1 < 5) {
                System.out.println("w1 = "+ w1);
                w2 = 0;
                while(w2 < 3) {
                    System.out.println("\tw2 = "+ w2);
                    w2++;
                }
                w1++;    
        }
                
        
    }
}
 
 
cs

while문 코드를 작성해보자(배열을 이용한)

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
39
40
41
42
43
44
45
46
47
48
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        // array + while 
        
        int[] arr = { 1,2,3,4,5,6,7,8,9,10};
        
        int a;
        a = 0;
        while(a < arr.length) {
            System.out.println(arr[a]);
            a++;
        }
        
        a = 0;
        while(a < arr.length) {
            
            if(arr[a] == 5) {
                System.out.println("5을 찾았습니다.");
            }
            a++;    
        }
        
        a = 0;
        while(a < arr.length) {
            if (arr[a] % 2 == 1) {
                System.out.print(arr[a]);
            }
            a++;
        }
        
        System.out.println();
        
        a = 0;
        while(a < arr.length) {
            if (arr[a] % 2 == 0) {
                System.out.print(arr[a]);
            }
            a++;
        }                
                
        
    }
}
 
 
cs

 

Theme. do - while문

 

do-while문은 기본적인 구조가 while문과 같지만, 조건식과 블럭 { }의 순서를 바꿔놓은 것이다.

그래서 while문과 반대로 블럭 { }을 먼저 수행한 후에 조건식을 평가한다.

while문은 조건식의 결과에 따라 블럭 { }이 한번도 수행되지 않을 수 있지만,

do-while문은 최소한 한번은 수행될 것을 보장한다.

 

형식부터 살펴보자

 

1
2
3
4
5
6
    초기화
    do {
        조건식의 연산결과가 참일 때 수행될 문장들을 적는다.
        증감식
    } while (조건식);
 
cs

간단한 코드를 작성해보면,

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int w;
        w = 0;
        do {
            System.out.println("do while = " + w);
            w++;
        } while(w < 5);  
                
    }
}
 
 
cs

 

끝.

'Java' 카테고리의 다른 글

함수 사용  (4) 2022.12.26
break, continue  (0) 2022.12.23
조건문 - if, switch  (0) 2022.12.22
형변환  (0) 2022.12.21
화면에서 입력받기 - Scanner  (0) 2022.12.20

Theme.  if문

 

 먼저, 아래 코드를 보자.

1
2
3
4
5
6
7
8
9
10
11
12
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int number = 7;
        if (number > 0 ) {
            System.out.println("number는 0보다 큽니다.");
        }
    }
}
 
cs

결과는, "number는 0보다 큽니다."이다.

이제 형식을 알아보자.

1
2
3
4
5
6
if (조건식) {
 
    조건식이 참(true)일 때 수행될 문장들을 적는다. 
 
}
 
cs

가장 기본적인 조건문답게, '조건식', '괄호{ }', '조건식이 참(true)일 때 수행될 문장'으로 구성되어 있다.

'조건식이 참(true)일 때 수행될 문장'이라는 말을 통해 조건식이 거짓(false)일 때는 문장이 수행되지 않음을 알 수 있다. 

 

조건식

 조건식을 세울 때, 일반적으로 비교연산자와 논리연산자로 구성된다.

 잠시, 비교연산자와 논리연산자를 포함한 연산자에 대해 간단히 알아보자.

cf.  연산자의 종류

1)  산술 연산자

 사칙 연산자:  +, -, *, /

 %: 피연산자를 연산자로 나누고 난 나머지 값( 몫은 /을 통해서 구함)

 

2) 비교 연산자

 대소비교 연산자: < > <= >=

 등가비교 연사자: ==(같다) !=(같지 않다)

 

3) 논리 연산자

 && (AND 결합) , || (OR 결합), !(true와 false를 바꿈)

 

(자세한 설명은 다른 글에!!)

 

if문을 사용하여 간단한 코드들을 작성해보자.

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
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int number = 7;
        
        if (number > 0 ) {
            System.out.println("number는 0보다 큽니다."); // true
        }
        
        if (number == 7) { 
            System.out.println("number는 7입니다."); // true
        }
        
        if (number < 6 ) {
            System.out.println("number는 6보다 작습니다."); // false
        }
        
        if (number > 0 && number <= 10) {
            System.out.println("number는 0보다 크고 10보다 작거나 같습니다."); // true
        }
        
        if (number > 0 || number <= 10) {
            System.out.println("number는 0보다 크거나 10보다 작거나 같습니다."); // true
        }
        
        //    true            false
        if (number > 0 || number <= 5) {
            System.out.println("number는 0보다 크거나 5보다 작거나 같습니다."); // true
        }
        
    }
}
 
 
cs

< Console >

조건식이 참(true)인 경우에만 출력된 모습

추가적으로 코드를 작성해보면,

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
39
40
41
42
43
44
45
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        boolean b = true;
        
        if(b == true) {
            System.out.println("b == true 입니다.");
        }
        
        if(b) {
            System.out.println("b == true 입니다.");
        }    
                
        b = false;
        
        if(b == false) {
            System.out.println("b == false 입니다.");
        }    
        
        if(!b) {
            System.out.println("b == false 입니다.");
        }
        
        // 조건문에서 조건에 문자열 비교가 있다면 주의해라. //
        
        String str1 = "worl";
        str1 = str1 + "d"
        System.out.println("str1 = " + str1); 
        // 이 식으로 world를 만들고 아래 조건문 돌리면 안돌아감
        if (str1 == "world") {
            System.out.println("str1 은 world 입니다."); 
        }
        
        // 따라서, 문자열 비교하는 조건문 쓸 때는 equals를 이용해라!
        
        if (str1.equals("world"== true) {
            System.out.println("str1(equals 쓴) 은 world 입니다.");
        }
                
    }
}
 
 
cs

Theme. if - else문

 

먼저, 아래의 코드를 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        int count = 8;
        
        if (count < 6) {
            System.out.println("count는 6보다 작습니다."); // 조건식이 true일 때
        }
        
        else {
            System.out.println("count는 6보다 크거나 같습니다."); // 조건식이 false일 때
        }
        
    }
}
 
 
cs

결과는, "count는 6보다 크거나 같습니다." 이다.

 

이제 형식을 알아보자.

1) 

1
2
3
4
5
6
7
8
9
10
if (조건식) {
    조건식이 참(true)일 때 수행될 문장들을 적는다. 
}
else (조건식) {
    조건식이 거짓(false)일 때 수행될 문장들을 적는다.
}
cs

2)

1
2
3
4
5
6
7
8
9
10
if (조건식) {
    조건식이 참(true)일 때 수행될 문장들을 적는다. 
} else (조건식) {
    조건식이 거짓(false)일 때 수행될 문장들을 적는다.
}
cs

if문과의 차이점은 'else블럭'을 추가함으로써 조건식이 거짓(false)일 때 수행될 문장을 적을 수 있다는 것

1) 2) 형식 모두 동일한 결과를 가져온다

 

if - else문을 통한 코드를 작성해보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        char c = 'A';
        
        if(c == 'a') {
            System.out.println("c는 'a'입니다.");
        }
        else {
            System.out.println("c는 'a'가 아닙니다.");
        }
        
    }
}
cs

결과는 "c는 'a'가 아닙니다." 이다.

 

cf.  if - else문과  삼항 연산자

위의 결과와 동일한 코드를 삼항 연산자를 이용하여 작성해보면 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        char c = 'A';
        
        String str = (c == 'a') ? "c는 'a'입니다." : "c는 'a'가 아닙니다.";
        System.out.println(str);
                
    }
}
cs

 

Theme. if - else if문 

 

if - else문은 조건식이 참(true) 또는 거짓(false)인 경우 두 가지중 하나가 수행되는 구조인데,

이는 처리하고 싶은 경우가 셋 이상인 경우에는 적용할 수 없는 단점이 있다.

이때, 여러 개의 조건식을 적을 수 있는 'if - else if'문을 사용하면 된다.

 

형식에 대해 알아보자

1
2
3
4
5
6
7
8
9
10
if (조건식1) {
    조건식1이 참일 때 수행될 문장들을 적는다.
else if (조건식2) {                        // 조건식 1이 거짓일 때 조건식 2의 else if 문으로!
    조건식2이 참일 때 수행될 문장들을 적는다.
else if (조건식3) {
    조건식3이 참일 때 수행될 문장들을 적는다.
else {                                    // 마지막엔 보통 else 블럭으로 끝나는데, 생략도 가능하다.
    어떠한 조건식도 만족하지 않을 때 수행될 문장들을 적는다.
}
 
cs

 

이제 if - else if문을 이용하여 코드를 작성해보자.

Q. 점수를 입력하도록 하고, 점수가 속한 범위에 따라 학점을 출력하는 코드를 작성해보자.

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
package test;
 
import java.util.Scanner;
 
public class MainClass {
    public static void main(String[] args) {
    
        Scanner sc = new Scanner(System.in);
        int score;
        System.out.print("score = ");
        score = sc.nextInt();
        
        if (score >= 90) {
            System.out.println("A 학점입니다.");
        } else if (score >= 80) {
            System.out.println("B 학점입니다.");
        } else if (score >= 70) {
            System.out.println("C 학점입니다.");
        } else {
            System.out.println("재시험입니다.");
        }
                
    }
}
 
 
cs

75점을 입력했을 때, 결과는 아래와 같다.

55점을 입력했을 때, 결과는

재시험 같은 거 볼 일 없게 열심히 하자....

 

Theme. Switch문

 

if문과 달리 switch문은 하나의 조건식으로 많은 경우의 수를 처리할 수 있고, 표현도 간결하여 알아보기 쉽다.

즉, 처리할 경우의 수가 많은 경우 switch문의 장점이 부각될 수 있다.

 

switch문은 조건식을 먼저 계산한 다음, 그 결과와 일치하는 case문으로 이동한다. 이동한 case문 아래에 있는 문장들을 수행하며, break문을 만나면 전체 switch문을 빠져나가게 된다.

 

이제 형식을 알아보자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
switch( 조건식 ) {
        case 값1:        
            조건식의 결과가 값1과 같을 경우 수행될 문장들
            break;
        case 값2:        
            조건식의 결과가 값2과 같을 경우 수행될 문장들
            break;         // switch문을 벗어난다.
 
        //...
    
        default:        
            조건식의 결과와 일치하는 case문이 없을 때 수행될 문장들
 
}
 
cs

switch문의 제약조건

 1) switch문의 조건식 결과는 정수 또는 문자열이어야 한다.

 2) case문의 값은 정수 상수만 가능하며, 중복되지 않아야 한다.

 

switch문을 이용한 코드를 작성해보자.

 
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
39
40
41
42
43
44
45
46
47
48
        int choice;
        
        choice = 2;
        
        switch ( choice ) {
            case 1:
                System.out.println("처리1 입니다.");
                break;
            case 2:
                System.out.println("처리2 입니다.");
                break;                                
            case 3:
                System.out.println("처리3 입니다.");
                break;
            case 4:
                System.out.println("처리4 입니다.");
                break;
                
            default:
                System.out.println("1 ~ 3이 아닙니다.");
        }
        
        // break;를 생략하게 되면, 어떻게 될까?
        
        /*
         switch ( choice ) {
            case 1:
                System.out.println("처리1 입니다.");
                break;
            case 2:
                System.out.println("처리2 입니다.");
                break;                                
            case 3:
                System.out.println("처리3 입니다.");
                break;
            
            default:
                System.out.println("1 ~ 3이 아닙니다.");
        }
         case 1, case 3의 break; 코드를 생략해도 결과는 올바르게 나온 것처럼 보인다. 하지만, 
         case 2의 break; 코드를 생략하게 되면, 일단 처리2 입니다는 실행이 되고, 
         그 다음부터 처리해야 하는 것들은 break을 발견할 때까지 처리가 되어 버린다.
         즉, console 결과가
         처리2 입니다.
         처리3 입니다.
         이렇게 나온다.
         당연히 break;을 case마다 써야 하고, 처리가 되는 case 부분에서의 break;을 안쓰게 되면
         그 다음 case들이 break;을 만날 때까지 다 처리가 되어 버린다.
cs

결과는 "처리2 입니다." 가 나온다.

 

 

끝.

'Java' 카테고리의 다른 글

break, continue  (0) 2022.12.23
반복문 - for, while, do - while  (2) 2022.12.22
형변환  (0) 2022.12.21
화면에서 입력받기 - Scanner  (0) 2022.12.20
Data Type, n진법  (0) 2022.12.20
형변환(캐스팅, casting)이란?
변수 또는 상수의 타입을 다른 타입으로 변환하는 것

1. 형변환을 왜 하는가?

 - 연산을 수행하기 위해서 타입을 일치시켜야 하기 때문이다.

 

2. 형변환 방법

 - (타입)피연산자

 - 괄호( )는 '캐스트 연산자' 또는 '형변환 연산자'라고 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        //형변환 
        double d = 3.14;
        int i = (int)d;
        System.out.println("i = " + i);
        
    }
}
 
cs

 - 결과는 i = 3 (실수형이 정수형으로 형변환할 때 반올림이 아니라 버림)

 

3. 타입 크기의 차이가 있는 경우의 형변환

 1) 큰 타입에서 작은 타입으로의 변환

  - 크기 차이 만큼 값 손실이 발생할 수 있다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package test;
 
public class MainClass {
    public static void main(String[] args) {
    
        //큰 타입에서 작은 타입으로의 변환
        int i = 1234567// int는 4byte, short는 2byte
        short sh;
        sh = (short)i;
        System.out.println("sh = " + sh);
    }
}
 
 
cs

  - 결과는 1234567이 아닌, -10617이라는 엉뚱한 숫자가 나타난다. 

  - 왜냐하면 1234567은 int의 저장 가능 범위에 속하지만, short의 저장 가능 범위는 벗어나기 때문

 

 2) 작은 타입에서 큰 타입으로의 변환

  - 값 손실이 발생하지 않는다.

 

 

 

'Java' 카테고리의 다른 글

반복문 - for, while, do - while  (2) 2022.12.22
조건문 - if, switch  (0) 2022.12.22
화면에서 입력받기 - Scanner  (0) 2022.12.20
Data Type, n진법  (0) 2022.12.20
출력, escape sequence, 주석  (0) 2022.12.19

< 소스 코드 >

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
39
40
41
42
43
44
45
46
package sample03;
 
import java.util.Scanner//Scanner class를 사용하기 위해 추가
 
public class MainClass2 {
 
    public static void main(String[] args) {
        
        // input(입력) - console
        Scanner sc = new Scanner(System.in); // Scanner class 객체를 생성
        
        // boolean
        boolean b; // 입력할 데이터를 보관할 변수
        System.out.print("b = "); // 입력할 데이터를 명시
        b = sc.nextBoolean(); // 입력 받음
        System.out.println("b: " + b); // 입력한 결과를 출력
    
    
        
        // integer
        int number;
        System.out.print("number = ");
        number = sc.nextInt();
        System.out.println("number: " + number);
        
        
        
        // double
        double d;
        System.out.print("d = ");
        d = sc.nextDouble();
        System.out.println("d: " + d);
        
        
        
        // string
        String str;
        System.out.print("str = ");
        str = sc.next(); 
        // 주의! next()는 space를 못받아들여서 hello world 치면 hello만 출력
        System.out.println("str: " + str);            
 
    }
 
}
 
cs

< Console >

Theme. next()와 nextLine()의 차이

 - next(): 공백 또는 줄 바꿈까지만 읽는다. (한 단어만 읽을 수 있음)

 - nextLine(): 한 줄 전체를 읽는다(문장을 다 읽을 수 있음)

 

즉, 다음과 같은 차이가 있다.

"Hello Java World"라고 입력했을 때,

1. next()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package sample03;
 
import java.util.Scanner;
 
public class MainClass2 {
 
    public static void main(String[] args) {
        
        // input(입력) - console
        Scanner sc = new Scanner(System.in);
    
        // string
        String str;
        System.out.print("str = ");
        str = sc.next(); 
        System.out.println("str: " + str);            
 
    }
 
}
 
cs

< console >

한 단어만 읽은 모습(공백이 나타나기 전까지 읽은 모습)

 

2. nextLine()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package sample03;
 
import java.util.Scanner;
 
public class MainClass2 {
 
    public static void main(String[] args) {
        
        // input(입력) - console
        Scanner sc = new Scanner(System.in);
    
        // string
        String str;
        System.out.print("str = ");
        str = sc.nextLine(); 
        System.out.println("str: " + str);            
 
    }
 
}
 
cs

< console >

한 줄을 다 읽은 모습

'Java' 카테고리의 다른 글

반복문 - for, while, do - while  (2) 2022.12.22
조건문 - if, switch  (0) 2022.12.22
형변환  (0) 2022.12.21
Data Type, n진법  (0) 2022.12.20
출력, escape sequence, 주석  (0) 2022.12.19

< 소스 코드 >

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
public class MainClass {
 
    public static void main(String[] args) {
        
        /*
             숫자(상수):
                 2진수(BIN): 0, 1
                 8진수(OCT): 0 ~ 7, 8 -> 10으로 취급  10(10진수) -> 12(8진수) -> 012
                 10진수(DEC) 0 ~ 9
                 16진수(HEC) 0 ~ 9 A B C D E F이고
                         A(10) B(11) C(12) D(13) E(14) F(15)
                 1010 1100 -> 2진수
                 8421 8421 -> 10진수로 바꿀 때
                 A     C    -> 16진수 -> 0xAC (16진수임을 표현할 때 앞에 0x를 붙인다)
             
                 0x000000 -> black
                 0xffffff -> white (ff = 255이므로)
                 
                 0xE5 -> 16진수
                 8421 8421 (E 하나에 8421 5 하나에 8421 대응)
                 1110 0101 -> 2진수
             
             변수(variable):
                 빈통(메모리 공간)에 데이터를 저장할 수 있는 수
                 데이터의 종류도 다양하다
             
         */
        // 데이터를 크게 3종류로 나눌 수 있다.
        // 숫자
        //         정수(byte, short, int, long)
        
        // 자료형(byte) 변수(by) -> 1 byte -> 256개 숫자를 표현
        byte by;
        
        // 대입
        // A = B는 B를 A에 대입! (<- 방향)
        by = 12;
        by = 25;
        // by = 255; -> error 발생한다! 왜냐하면 byte의 8bit 8개 자리의 맨앞은 부호 의미
        // 맨앞이 0이면 양수, 맨앞이 1이면 음수를 표현
        by = -128// 1byte는 -128 ~ 127까지 가능 (255개)
        
        short sh; // 자료형(short) 변수(sh) -> 2byte
        sh = 134;
        
        int i; // -> 4byte
        i = 12345;
        
        long l; // -> 8byte
        l = 1231231231232323L; // L을 붙여줘서 long형으로 인식하게 함
        
        //        실수(소수) (float, double)
        float f; // -> 4byte
        f = 123.456f; // f을 붙여줘서 float형으로 인식하게 함
        
        double d; // -> 8byte
        d = 123.4562312;
        // 실무에서는 double을 많이 사용한다.
        
        // 문자열
        //        문자(char)
        char c; // 2 byte
        c = 'A'// 한 문자만 표현할 때는 작은 따옴표! 큰 따옴표 X
        c = '한';
    
        //        문자열(string) -> (wrapper)class
        String str;
        str = "Hello";
        str = "World";
        
        // 논리(true/false) (boolean)
        boolean b;
        
        b = false// false = 0
        b = true// true = 1
        
        // 변수명 규칙
        int hH;
        int humanHeight;
        // 문법상 어긋나는 것은 없으나 유추가 돼야 한다...!
        
        // 불가
        
        // 1. 숫자가 맨 앞에 오면 안된다: int 1abc;
        // 2. 변수명은 사용할 수 없다: int char;
        // 3. 띄어쓰기 사용해서 사용할 수 없다: int ch sfge;
        
        // 삼가라
        
        // 1. 모두 대문자로 사용하는 것은 안좋다: int ABC;
        // 2. 너무 간단한 변수명은 안좋다: int da;
        
        //많이 사용하는 규칙
        int charPositionXdot; // camel 기법(중간중간 대문자)
        int char_Position_xdot; // _(under bar) 사용 (근데 오류 위험있음)
        int charPosXdot; //너무 길지 않은 길이로
        
        System.out.println(by);
        System.out.println(sh);
        System.out.println("i = " + i);
        System.out.println("l = " + l);
        System.out.println("f = " + f);
        System.out.println("d = " + d);
        System.out.println("b = " + b);
    }
 
}
 
cs

< Console >

Theme. n진법

  • 2진법(BIN): 0, 1
  • 8진법(OCT): 0 ~ 7, 8은 10으로 취급
  • 10진법(DEC) 0 ~ 9
  • 16진법(HEC) 0 ~ 9 A(10) B(11) C(12) D(13) E(14) F(15)

1. 8진법, 16진법의 표기

 - 10을 8진법으로 나타내면, 012 (0을 맨 앞에 써준다) ( 10 = 8^1 * 1 + 8^0 * 2 )

 - 16진법으로 나타낼 때는 앞에 0x를 붙여써준다

 

2. 2진법과 16진법 사이의 변환

 10101100 (2진법)이 있을 때, 4자리씩 16진법으로 변환

 즉, 1010 / 1100으로 나눠 변환

 1010 1100 (2진법)

 8421 8421 (10진법)

 A       C       (16진법)  ----> 0xAC !!

 

Theme. Data Type(자료형)

Data Type 크기
문자형 char 2 byte
정수형 byte 1 byte
short 2 byte
int 4 byte
long 8 byte
실수형 float 4 byte
double 8 byte
논리형 boolean 1 byte

- 1byte = 8bit이므로 총 256개의 수를 표현할 수 있다. 주의할 것은 그 범위가 -128 ~ 127이라는 것.

 - long은 수의 끝에 L을 붙이고, float는 f를 붙여 각각 올바르게 인식되도록 한다.

 - char은 작은 따옴표를 사용해야 한다.

 

Theme. 변수명 규칙

1. 불가능

 - 숫자가 맨 앞에 오면 안된다.

 - 자료형으로 된 변수명은 사용할 수 없다.

 - 띄어쓰기 사용할 수 없다.

 

2. 권장하지 않음

 - 모두 대문자로 사용하는 것

 - 너무 간단한 변수명

'Java' 카테고리의 다른 글

반복문 - for, while, do - while  (2) 2022.12.22
조건문 - if, switch  (0) 2022.12.22
형변환  (0) 2022.12.21
화면에서 입력받기 - Scanner  (0) 2022.12.20
출력, escape sequence, 주석  (0) 2022.12.19

+ Recent posts