JAVA1_day05 | 연산자

# 연산자

1. 연산자 (operator): 연산을 수행하기 위한 기호 (+, -, *, /, %..)

2. 피연산자 (operand): 연산자의 작업 대상 (숫자)

1. 증감 연산자 ++, --

1) 변수 이름 앞 또는 뒤에 적는다. (숫자에는 적용X)

ex. num++;     ++num; (O)

     10++; (X)

package operatorex;
 
public class OpTest01 {
    public static void main(String[] args) {
 
        int a = 10;
        ++a;
        a++;
        System.out.println("변수 a의 값: " + a);
        
        a = 10;
        int result = a++;
        System.out.println("변수 result의 값: " + result);
        System.out.println("변수 a의 값: " + a);
        
    }
}
 
/*
        단독으로 쓰일 때는 위치에 상관없이 a의 값이 증가한 것을 알 수 있다.
        그러나 대입 연산자와 후위형을 함께 사용하였을 때는,
        우선 증가되지 않은 a값을 result에 넘겨주고 그 이후에 a++;이 실행된 것을 알 수 있다.    
*/

2) 전위형 ++num; > 변수가 사용되기 이전에 증감 연산

    후위형 num++; > 변수가 사용된 이후 증감 연산을 실시

3) num++은 num = num + 1의 줄인 표현이다.

4) 증감 연산자는 단독으로 쓰일 경우 아무런 영향을 받지 않고 변수의 값이 증감한다. (num++, ++num)

    그런데 다른 연산자와 함께 쓰일 경우, 증감 연산자의 위치에 따라 연산 순서가 달라지므로 주의해야한다. 

    특히 후위형은 다른 연산자를 먼저 수행한 후, 본인의 역할인 증감을 실행한다. 

ex. int result = a++;

> int result = a; 부터 하고

   a++; 증감

      

# 설명: 대입 연산자와 후위형을 함께 사용하였을때는 아래와 같은 순서로 실행된다. 

1) int num = a;

2) a++;

5) 증감 연산자는 주로 단독으로만 쓰인다!

package operatorex;
 
public class OpTest02 {
    public static void main(String[] args) {
 
        // 연습문제 1
        // println의 ()도 연산자로 작용하여 우선순위로 적용된다. 
        int a = 10;
        System.out.println(a++);
        System.out.println(++a);
        System.out.println(++a);
        System.out.println(a++);
        System.out.println(++a);
        System.out.println(a);
        
    }
}
 
/*
        전위형 ++a; 의 경우 a의 값을 바로 증가시키고 동시에 출력문도 진행된다.
        후위형 a++; 의 경우 증가되지 않은 a의 값을 출력시키고 그 다음 a의 값을 증가시킨다. 
        이는 System.out.println에 있는 () 기호가 연산자로 작용하여 우선순위로 작용하기 때문이다. 
*/

# 증감 연산자 연산 과정표

 

package operatorex;
 
public class OpTest03 {
    public static void main(String[] args) {
 
        // 연습문제 2 
        int a = 10;
        int b = ++a + a++;
        System.out.println("변수 a의 값: " + a);
        System.out.println("변수 b의 값: " + b);
        
        System.out.println();
        
        a = 10;
        int c = ++a + ++a;
        System.out.println("변수 a의 값: " + a);
        System.out.println("변수 c의 값: " + c);
    }
}
 
/*    
        전위형 ++a; 의 경우 a의 값을 바로 증가시키고 동시에 출력문도 진행된다.
        후위형 a++; 의 경우 증가되지 않은 a의 값을 출력시키고 그 다음 a의 값을 증가시킨다. 
        이는 System.out.println에 있는 () 기호가 연산자로 작용하여 우선순위로 작용하기 때문이다. 
*/

  

2. 산술 연산자 +, -, *, /, %

1) % 연산자는 왼쪽의 피연산자의 부호를 따른다.

ex. 10 % -8 == 2

    -10 % 8 == -2

2) / : 몫

   % : 나머지

3) 15 % 2 == 1 > 홀수

    12 % 2 == 0 > 짝수

package operatorex;
 
public class OpTest04 {
    public static void main(String[] args) {
 
        int num1 = 10;
        int num2 = 3;
        
//      문자열로 읽혀 105가 되는 것을 주의!
        System.out.println("덧셈: " + num1 + num2); 
        System.out.println("덧셈: " + (num1 + num2));
        System.out.println("뺄셈: " + (num1 - num2));
        System.out.println("곱셈: " + (num1 * num2));
        System.out.println("나눗셈(몫): " + (num1 / num2));
        System.out.println("나머지: " + (num1 % num2));
 
//      15 % 2 == 1 > 홀수
//      12 % 2 == 0 > 짝수 
        
//      % 연산자는 왼쪽의 피연산자의 부호를 따른다. 
        System.out.println(10 % 8);
        System.out.println(10 % -8);
        System.out.println(-10 % 8);
        
    }
}

package operatorex;
 
import javax.swing.JOptionPane;
 
/* # 화폐매수 구하기
 * 예) 65,700원 출금
 * 오만원: 1장 / 만  원: 1장 / 오천원: 1장 / 천  원: 0장 / 오백원: 1개 / 백  원: 2개 
 * */
 
public class OpTest05 {
    public static void main(String[] args) {
 
        int money = Integer.parseInt(JOptionPane.showInputDialog("출금할 금액 입력"));
 
        int w50000 = money / 50000;
        int w10000 = (money % 50000) / 10000;
 
        int w5000 = (money % 10000) / 5000;
        int w1000 = (money % 5000) / 1000;
        
        int w500 = (money % 1000) / 500;
        int w100 = (money % 500) / 100;
        
        
        String message = money + "원\n";
        message += "오만원: " + w50000 + "장\n";
        message += "만  원: " + w10000 + "장\n";
        message += "오천원: " + w5000 + "장\n";
        message += "천  원: " + w1000 + "장\n";
        message += "오백원: " + w500 + "개\n";
        message += "백  원: " + w100 + "개\n";
        
        JOptionPane.showMessageDialog(null, message);
    }
}

3. 비교 연산자 >, <, >=, <=, ==, !=

1) 연산의 결과는 true, false로 반환된다. 

2) ! 는 부정의 뜻 

package operatorex;
 
public class OpTest06 {
    public static void main(String[] args) {
 
        int num = 10;
        
        boolean result = num - 10 >= 0;        // true
        System.out.println(result);
        
        System.out.println(num - 10 != 0);      // false 
        
    }
}

n1   >  n2 : n1이 n2보다 큰가요?

n1   <  n2 : n1이 n2보다 작은가요?

n1 >=  n2 : n1이 n2보다 크거나 같나요?

n1 <=  n2 : n1이 n2보다 작거나 같나요?

n1 ==  n2 : n1이 n2보다 같나요?

n1  !=  n2 : n1이 n2보다 서로 다른가요?

4. 논리 연산자 &&, ||, ! 

1) A && B (논리곱, AND): 주어진 연산식 모두 true 일 때, true

2) A || B (논리합, OR): 주어진 연산식들 중 하나라도 true 이면, true

3) ! (NOT): boolean 변수 혹은 데이터에만 사용 가능

4) 진리표

# A && B

       

# A || B

5) boolean t = false;

    sysout(!t) = true;

package operatorex;
 
public class OpTest07 {
    public static void main(String[] args) {
 
        int a = 10;
        boolean result1 = a > 0 && a > 5;                     // t && t > t        
        boolean result2 = a > 0 && a < 5;                    // t && f > f
        boolean result3 = a < 0 && a > 5 && a > 10;    // f && t && f > f
        boolean result4 = a > 0 || a < 5 || a > 10;         // t || f || f > t
        boolean result5 = !result4;                               // !t > f
        
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
        System.out.println(result5);
    }
}

6) SCE (Short Circuit Evaluation: 최단거리연산)

연산 과정에서 왼쪽의 결과가 총 결과와 같다면 오른쪽 연산은 진행하지 않음

package operatorex;
 
/*  SCE (Short Circuit Evaluation: 최단거리연산)
 * 연산 과정에서 왼쪽의 결과가 총 결과가 같다면 오른쪽 연산은 진행하지 않음
 */
 
public class OpTest08 {
    public static void main(String[] args) {
 
        int num1 = 0;
        int num2 = 0;
        
        boolean result;
        result = (num1 += 10) < 0 && (num2 += 10) > 0;    // f && t > f
        System.out.println("result = " + result);                   // false
        System.out.println("num1 = " + num1);                    // 10
        System.out.println("num2 = " + num2);                   // 0
        
        result = (num1 += 10) < 0 || (num2 += 10) > 0;       // f || t > t
        System.out.println("result = " + result);                   // true
        System.out.println("num1 = " + num1);                   // 20
        System.out.println("num2 = " + num2);                  // 10
        
    }
}
 
/*
        첫번째 구문에서 num2 = 0이 된 이유는 SCE 때문이다.
        (num+=10)<0 는 false가 되고 논리곱 && 값에서는 어찌됐던간에 false가 
        되어버리기 때문에 뒤에 (num2 += 10)>0 자체는 연산하지 않는다. 
        때문에 num2 += 10 조차 연산되지 않아 초기값인 0으로 출력되는 것이다. 
*/

5. 대입 연산자 =

1) 모든 연산자 중에서 제일 마지막에 수행된다.

2) 복합 대입연산자 +=, -=, *=

- 산술 연산자 + 대입 연산자

ex. num += 1;    ==    num = num+1;

package operatorex;
 
public class OpTest09 {
    public static void main(String[] args) {
 
//    대입연산자: 모든 연산자 중에서 제일 마지막에 수행된다.
//    복합 대입연산자 (산술연산자 + 대입연산자)
        
        int num = 10;
        num += 1;        // num = num + 1;
        
    }
}

6. 삼항 연산자    조건식 ? true : false

# 조건식의 결과에 따라 true이면 왼쪽 true 영역을 실행

package operatorex;
 
public class OpTest10 {
    public static void main(String[] args) {
 
        int a = 10;
        int b = 5;
        
        // 조건문의 연산 결과의 타입형에 따라 변수 타입을 선언해야 한다! 
        int result1 = a > b ? 100 : 0;
        System.out.println(result1);
        
        String result2 = a > b ? "크다" : "작다";
        System.out.println("변수 a는 b보다 " + result2);
        
    }
}