Java 문법 종합 2주차-1

연산자

계산할 때 계산의 대상이 되는 것이 피연산자, 계산의 목적이 되는 것이 연산자

• 연산자 : 계산에 사용되는 연산 기호(+, - , *, / 등)
• 피연산자 : 

연산자 종류

• 산술 연산자 : 사칙 연산
  • + , - , * ,  / , %, >> , <<
• 비교 연산자 : 크고 작음, 같고 다름 비교
  • > , < , >= , <= , == , !=
• 논리 연산자 : AND, OR 으로 조건을 연결
  • && , || , !
• 대입 연산자 : 우변 값을 좌변에 대입, 연산 복합 대입
  • = , ++ , --
• 기타 연산자 : 형변환 연산자, 삼항 연산자, instance of 연산자
  • (type) , ? : , instance of

사칙연산 연습

package week02;

public class W02 {

    public static void main(String[] args) {
        // 더하기
        System.out.println(5 + 2);
        // 빼기
        System.out.println(5 - 2);
        // 곱하기
        System.out.println(5 * 2);
        // 나누기
        System.out.println(5 / 2);
        // 나머지
        System.out.println(5 % 2);

        // 우선순위 연산
        System.out.println(2 + 2 * 3);
        System.out.println((2 + 2) * 3);

        // 변수 사용 연산
        int a = 20, b = 10;
        int c = a + b;
        System.out.println(c);
        c = a - b;
        System.out.println(c);
        c = a * b;
        System.out.println(c);
        c = a / b;
        System.out.println(c);
        c = a % b;
        System.out.println(c);
    }
}

 

비교 연산 연습

package week02;

public class W03 {

    public static void main(String[] args) {
        // 비교 연산
        System.out.println(10 > 9); // a가 b보다 큰지? true
        System.out.println(10 >= 9); // a가 b보다 크거나 같은지? true
        System.out.println(10 < 9); // a가 b보다 작은지? false
        System.out.println(10 <= 9); // a가 b보다 같거나 작은지? false
        System.out.println(10 == 10); // a와 b가 같은지? true
        System.out.println(10 == 9); // a와 b가 같은지? false
        System.out.println(10 != 10); // a와 b가 다른지? false
        System.out.println(10 != 9); // a와 b가 다른지? true
    }
}

 

논리 연산 연습

package week02;

public class W04 {

    public static void main(String[] args) {
        // 논리 연산
        // 조건을 연결할 때 boolean 값들을 조합하여 true 또는 false 값을 출력
        // &&(AND) , ||(OR), !(NOT)
        // (1 < 3 < 5) 처럼 3개 이상을 동시에 비교는 x
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = false;

        // OR
        System.out.println();
        System.out.println(flag1 || flag2); // true
        System.out.println(flag1 || flag3); // true
        System.out.println(flag1 || flag2 || flag3); // true

        System.out.println();
        System.out.println((5 > 3) || (3 > 1)); // true
        System.out.println((5 > 3) || (3 < 1)); // true
        System.out.println((5 < 3) || (3 < 1)); // false

        // AND
        System.out.println();
        System.out.println(flag1 && flag2); // true
        System.out.println(flag1 && flag3); // false
        System.out.println(flag1 && flag2 && flag3); // false

        System.out.println();
        System.out.println((5 > 3) && (3 > 1)); // true
        System.out.println((5 > 3) && (3 < 1)); // false

        // NOT
        System.out.println();
        System.out.println(!flag1); // false
        System.out.println(!flag3); // true
        System.out.println(!(5==5)); // false
        System.out.println(!(5==3)); // true

    }
}

 

대입 연산 연습

package week02;

public class W05 {
    public static void main(String[] args) {
        // 변수를 바로 연산해서 저장하는 연산자
        // 기본 대입: = 복합 대입: +=(++) , -=(--)
        // 기본대입
        int number = 10;
        number = number + 2;
        System.out.println(number);

        number = number - 2;
        System.out.println(number);

        number = number * 2;
        System.out.println(number);

        number = number / 2;
        System.out.println(number);

        number = number % 2;
        System.out.println(number);

        // 복합대입
        number = 10;

        number += 2;
        System.out.println(number);

        number -= 2;
        System.out.println(number);

        number *= 2;
        System.out.println(number);

        number /= 2;
        System.out.println(number);

        number %= 2;
        System.out.println(number);

        number++;
        System.out.println(number);
        number--;
        System.out.println(number);

    }
}


// 전위/후위 연산
public class W06 {
    public static void main(String[] args) {
        // 대입 연산 주의 점
        // 전위 연산 후위 연산을 신경 쓰자
        int a = 10;
        int b = 10;
        int val = ++a + b--;
        System.out.println(val);
    }
}

 

기타 연산 연습

package week02;

public class W07 {

    public static void main(String[] args) {
        // 기타 연산
        // 형변환 , 삼항 연산
        // instance of

        // 형변환
        int intNumber = 93 + (int)98.8;
        System.out.println(intNumber);

        double doubleNumber = (double) 93 + 98.8;
        System.out.println(doubleNumber);

        // 삼항 연산 조건 ? 참 : 거짓
        int x = 1, y = 9;

        boolean b = (x==y) ? true:false;
        System.out.println(b);

        String s = (x != y) ? "정답" : "오답";
        System.out.println(s);

        int max = (x > y) ? x : y;
        System.out.println(max);

        int min = (x < y) ? x : y;
        System.out.println(min);
        
        // instance of : 피연산자가 조건에 명시된 클래스 객체인지 비교
    }
}

 

연산자 우선 순위

package week02;

public class W08 {
    public static void main(String[] args) {
        // 연산자 우선 순위: 산술 > 비교 > 논리 > 대입
        // 괄호로 감싸면 괄호 안이 우선 순위가 제일 높음
        int x = 2, y=9, z=10;
        boolean result = x <  y && y < z;
        System.out.println(result);

        result = x + 10 < y && y < z;
        System.out.println(result);

        result = x + 2 * 3 > y;
        System.out.println(result);

        result = (x + 2) * 3 > y;
        System.out.println(result);
    }
}

 

산술 변환

• 연산 전에 피연산자의 타입을 일치시키는 것(둘 중 저장공간 크기가 더 큰 타입으로 일치)

package week02;

public class W09 {
    public static void main(String[] args) {
        short x =10;
        int y = 20;
        int z  = x + y;

        long lx = 30L;
        long lz = z + lx;

        float fx = x;
        float fy = y;
        float fz = z;

        System.out.println(z);
        System.out.println(lx);
        System.out.println(lz);
        System.out.println(fx);
        System.out.println(fy);
        System.out.println(fz);
    }
}

 

비트 연산

• Bit의 자리 수를 옮기는 것

package week02;

public class W10 {
    public static void main(String[] args) {
        System.out.println(3 << 2);
        System.out.println(3 >> 1);
    }
}

 

문맥 만들기(조건문, 반복문)

조건문

• 특정 조건에 따라 다른 연산을 수행하고 싶을 때 사용

조건문 종류

• if문 : 특정 조건이 참인지 확인하고, 그 조건이 참일 경우 if문 내 코드 블록을 실행
• switch문 : if문을 조금 더 편리하게 사용할 수 있음(switch문은 단순히 값이 같은지만 비교 가능)

if문

• if(조건)
  • 특정 조건에 따라 다른 연산을 수행하고 싶을 때 사용
  • if (조건) { 연산 } 형태로 사용
  • if( ) 괄호 안의 조건이 참(true)일 경우 { } 안의 연산을 수행
• if(조건)-else
  • if문 조건이 거짓(false)일 경우에 따른 연산을 수행하기 위해 else { 연산 } 형태로 사용
  • if( ) 안의 조건이 거짓(false)일 경우 else { } 안의 연산을 수행
• if(조건)-else if(조건)
  • if문 조건이 거짓일 경우 다시 다른 조건으로 체크해서 참일 경우 연산을 수행하기 위해 else if(조건) { 연산 } 형태로 사용
  • else if ( ) 안의 조건이 참(true)일 경우 else if { } 안의 연산을 수행
• 중첩 if(조건)
  • if문에, else, else if로 해결할 수 없는 복잡한 조건을 수행하기 위해 사용
  • 중첩을 통해 if, else, else if문을 if 문 안에 넣어서 사용

if , else if , else 연습

package week02;

public class W11 {
    public static void main(String[] args) {
        boolean flag = true;
        
        // if else 조건문
        if (flag) {
            // true인 경우
            System.out.println("값이 true 입니다.");
        } else {
            System.out.println("값이 false 입니다.");
        }

        // if-else if-else 조건문
        int number = 1;
        if (number > 1) {
            System.out.println("값이 1보다 큽니다.");
        } else if (number == 1) {
            System.out.println("값이 1입니다.");
        } else {
            System.out.println("값이 1보다 작습니다.");
        }
    }
}

 

중첩 조건문

package week02;

public class W12 {
    public static void main(String[] args) {
        // 중첩 if
        boolean flag = true;
        int number = 2;

        if (flag) {
            if (number ==1) {
                System.out.println("flag 값: true, number 값: 1");
            } else if (number ==2) {
                System.out.println("flag 값: true, number 값: 2");
            } else {
                System.out.println("flag 값: true, number 값: 알 수 없음");
            }
        } else {
            if (number ==1) {
                System.out.println("flag 값: false, number 값: 1");
            } else if (number ==2) {
                System.out.println("flag 값: false, number 값: 2");
            } else {
                System.out.println("flag 값: false, number 값: 알 수 없음");
            }
        }
    }
}

 

중첩 조건문 활용

// 가위, 바위, 보 제작
package week02;

import java.util.Objects;
import java.util.Scanner;

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

        // A input
        System.out.println("A 입력 : ");
        String aHand = scanner.nextLine();

        // B input
        System.out.println("B 입력 : ");
        String bHand = scanner.nextLine();

        // 가위바위보
        if (Objects.equals(aHand, "가위")) {
            if (Objects.equals(bHand, "가위")) {
                System.out.println("A와 B는 비겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("B가 이겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("A가 이겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else if (Objects.equals(aHand, "바위")) {
            if (Objects.equals(bHand, "바위")) {
                System.out.println("A와 B는 비겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("B가 이겼습니다.");
            } else if (Objects.equals(bHand, "가위")) {
                System.out.println("A가 이겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else if (Objects.equals(aHand, "보")) {
            if (Objects.equals(bHand, "보")) {
                System.out.println("A와 B는 비겼습니다.");
            } else if (Objects.equals(bHand, "가위")) {
                System.out.println("B가 이겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("A가 이겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else {
            System.out.println("A가 이상한 값을 입력했습니다.");
        }
    }
}

 

Switch문

switch(피연산자)/ case(조건)

• swtich 문은 case 문과 함께 사용하여 if문보다 좀 더 가독성이 좋은 조건문 표현식
  • switch(피연산자) { case(조건): (연산) } 형태로 사용
  • switch 피연산자가 case 조건 만족 시 case: 뒤의 연산을 수행
  • case(조건): (연산)은 여러 개 설정가능
    • 각 case 연산문 마지막에는 break; 필수(break; 를 넣지않을 경우 switch문의 모든 case를 실행함)
    • break; 는 switch문을 종료 시켜 준다.
  • switch문 { }의 마지막에는 default: (연산)을 명시해 case 조건이 모두 거짓(false)일 때 수행할 연산을 정한다.
    • default: (연산)은 없을 경우 생략 가능.

switch

package week02;

public class W14 {
    public static void main(String[] args) {
        int month = 8;
        String monthString = "";

        // switch
        switch (month) {
            // case
            case 1:
                monthString = "1월";
                break;
            case 2:
                monthString = "2월";
                break;
            case 3:
                monthString = "3월";
                break;
            case 4:
                monthString = "4월";
                break;
            case 5:
                monthString = "5월";
                break;
            case 6:
                monthString = "6월";
                break;
            case 7:
                monthString = "7월";
                break;
            case 8:
                monthString = "8월";
                break;
            case 9:
                monthString = "9월";
                break;
            case 10:
                monthString = "10월";
                break;
            case 11:
                monthString = "11월";
                break;
            case 12:
                monthString = "12월";
                break;
            default:
                monthString = "알 수 없음.";
        }
        System.out.println(monthString);
    }
}

 

if문 vs switch문

• 차이점 1. 복합 조건
  • if문은 복합 조건을 지원함
    • 복합 조건 : ( ) 안에 조건 여러 개를 지정하여 조건문을 수행할 수 있음
  • switch문은 피연산자 1개에 대한 조건만 지원
• 차이점 2. 코드 중복
  • if문은 상대적으로 코드 중복이 많음
  • switch문은 코드 중복이 적음

 

 

반복문

• 특정 조건에 따라 반복해서 동일한 연산을 수행하고 싶을 때 사용

for문

• for (초기값; 조건문; 증가연산) { (연산) } 형태로 사용
• 특정 조건은 초기값과 조건문을 통해서 정의
• 반복할 때마다 값을 증가시키는 증가연산을 정의
• 초기값이 조건문을 만족할 때까지 (연산)을 수행하면서 회차마다 증가연산을 수행

향상된 for문

• for ( ) 안의 값을 2개로 줄여주는 방법
• 연속된 변수목록을 출력할 때 사용
• for (변수 타입 변수 명: 목록 변수) { (연산) } 형태로 사용
• 변수 타입과 변수 명은 for문 안에서 연산을 수행할 변수를 정의
• 목록변수(배열)는 값 여러 개를 하나의 변수로 저장하고 싶을 때 사용

 

for

package week02;

public class W15 {
    public static void main(String[] args) {
        // for(초기값;조건문;증가연산)
        for (int i=0; i < 4; i++) {
            // 연산
            System.out.println(i + " 번째 출력!");
        }

        // 향상된 for문
        // 2개만 사용
        int[] numbers = {3, 6, 9, 12, 15};
        for (int number: numbers) {
            System.out.println(number + " ");
        }

        for (int i=0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
    }
}

 

while문, do-while문

• for문처럼 특정 조건에 따라 연산을 반복 수행할 때 사용
• 초기 값 없이 조건문만 명시하여 반복함
• while(조건문) { (연산) } 형태로 사용(while문)
  • while문으로 사용하면 조건문을 만족해야 연산이 반복 수행됨
  • 한 번 반복할 때마다 조건문을 체크해서 조건문이 불만족(false)이면 반복을 중단
• do { (연산) } while(조건문) 형태로 사용(do-while문)
  • do-while문으로 사용 시 최초 1회 연산 수행 후 조건문을 체크하여 반복 수행을 결정
  • 반복 시 매 회차마다 조건문을 체크해서 조건문이 불만족(false)이면 반복을 중단

while, do-while & break, continue

package week02;

public class W16 {
    public static void main(String[] args) {
        // while
        int number = 0;
        while (number < 3) {
            number++;
            System.out.println(number + "출력");
        }

        // do-while
        number = 4;
        do {
            System.out.println(number + "출력");
        } while (number < 3);

        // break
        number = 0;
        while (number < 3) {
            number++;
            if (number == 2) {
                break;
            }
            System.out.println(number + "출력");
        }

        for (int i = 0; i < 10; i++) {
            System.out.println("i: " + i);
            if (i == 2) {
                break;
            }
            for (int j = 0; j < 10; j++) {
                System.out.println("j: " + j);
                if (j == 2) {
                    break;
                }
            }
        }

        // continue
        number = 0;
        while (number < 3) {
            number++;
            if (number == 2) {
                continue;
            }
            System.out.println(number + "출력");
        }
    }
}

 

break

• break; 명령 호출 시 가장 가까운 블럭의 for문 또는 while문을 중단(또는 switch)
• 반복문 안에서 break; 형태로 사용

continue

• for문 또는 while문에서 해당 순서를 패스하고 싶을 때 continue명령을 사용
• 반복문 안에서 continue; 형태로 사용

 

반복문 활용

package week02;

import java.util.Scanner;

public class W17 {
    public static void main(String[] args) {
        // 구구단
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= 9; j++) {
                System.out.println(i + "단");
                System.out.println(i + " * " + j + " = " + i*j);
            }
        }

        // 입력 받는 단 제외 출력
        Scanner scanner = new Scanner(System.in);
        System.out.println("출력을 제외할 단 수를 입력하세요: ");
        int  passNum = scanner.nextInt();
        for (int i = 1; i <= 9; i++) {
            if (i ==  passNum) {
                continue;
            }
            for (int j = 1; j <= 9; j++) {
                System.out.println(i + "단");
                System.out.println(i + " * " + j + " = " + i*j);
            }
        }

        // 특정 단만 출력
        Scanner scanner2 = new Scanner(System.in);
        System.out.println("출력하고 싶은 단 수를 입력하세요");
        int printNum = scanner2.nextInt();
        for (int i = 1; i <= 9; i++) {
            if (i == printNum) {
                for (int j = 1; j <= 9; j++) {
                    System.out.println(i + "단");
                    System.out.println(i + " * " + j + " = " + i * j);
                }
            }
        }
    }
}