Language/Java

[JAVA 13] 자바 연산자 ( Operator )

reifier.tistory.com 으로 이전하였습니다. 2018. 2. 8. 14:54
반응형


■ Operator ( 연산자 )

1. 데이터를 연산하게 하는 기호

2. 종류

(01) 산술 연산자 

+ , - , * , / , %

순서대로 더하기 , 빼기 , 곱하기 , (나누기)몫 , (나누기)나머지


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Operator1{    // 산술 연산자
    int a = 10;
    int b = 5;
 
    void m1(){         // + , - , * , / , %
        int r1 = a+b;    // result 결과 = r
        int r2 = a-b;
        int r3 = a*b;
        int r4 = a/b;
        int r5 = a%b;
        System.out.println(" 더하기    > r1 : " + r1);
        System.out.println(" 빼기    > r2 : " + r2);
        System.out.println(" 곱하기    > r3 : " + r3);
        System.out.println(" 몫        > r4 : " + r4);
        System.out.println(" 나머지    > r5 : " + r5);
    }
 
    public static void main(String[] args){
        Operator1 os1 = new Operator1();
        os1.m1();
    }
}
cs



cf) +연산자를 String 과 함께 사용시 '결합 연산자'가 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Operator0{
    int a = 10;
    String b = "10";
 
    void m1(){
        System.out.println("1. 10" + a);
        System.out.println("2. " + a + b);
    }
 
    void m2(){
        System.out.println("1" + a + 10);
        System.out.println(" 답은 21 이 아니라, 11010 이 된다.");
        System.out.println("1" + ( a + 10 ));
        System.out.println(" 답은 220이 된다.");
    }
 
    public static void main(String[] args){
        Operator0 ot = new Operator0();
        ot.m1();
        System.out.println(" 답은 20 이 아니라, 1010 이 된다.");
        ot.m2();
    }
}
cs




(02) 증감 연산자

++ , --


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Operator2{    // 증감 연산자
    void m1(){      // + , - , * , / , %
        int a = 10;
        System.out.println("1. a  : " + a);
        System.out.println("++a   : " + (++a));        // 우선순위가 가장 높다.
        System.out.println("2. a  : " + a);
    }
 
    void m2(){        // + , - , * , / , %
        int a = 10;
        System.out.println("1. a   : " + a);
        System.out.println("a++    : " + (a++));     // 우선순위가 가장 낮다.
        System.out.println("2. a   : " + a);
    }
 
    public static void main(String[] args){
        Operator2 os2 = new Operator2();
        os2.m1();
        System.out.println("");    // 가독성을 위해서 한칸 내림
        os2.m2();
    }
}
cs


(03) 대입 연산자

=

대입 연산자는 이해하기 쉽고,

이전 포스트에서 부터 계속 쓰이던 연산자이기 때문에 생략하겠습니다.


(04) 산술 대입 연산자

+= , -= , *= , /= , %=


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
class Operator4{    // 산술 대입 연산자
    int a = 10;
    int b = 5;
 
    void m1(){        // + , - , * , / , %
        a += b;
        /*
        a *= b;
        a /= b;
        a %= b;
        */
 
        System.out.println(" a += b : " + a);
        /*
        System.out.println(" a -= b : " + a);
        System.out.println(" a *= b : " + a);
        System.out.println(" a /= b : " + a);
        System.out.println(" a %= b : " + a);
        */
    }
 
    public static void main(String[] args){
        Operator4 os4 = new Operator4();
        os4.m1();
    }
}
cs



(05) 비트 연산자

& , | , ^ , ~ , << , >> , >>> (시프트)


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
class Operator5{ // 비트 연산자
    int a = 10;        // 16    8    4    2    1    <2^4 / 2^3 / 2^2 / 2^1 / 2^0>
                     //  0    1    0    1    0    < 10을 2진법으로 변환 >
 
    int b = 9;         // 16    8    4    2    1    <2^4 / 2^3 / 2^2 / 2^1 / 2^0>
                     // 0    1    0    0    1    < 9를 2진법으로 변환 >
    void m(){
        int c = a|b;                                     　 // 1010    
        System.out.println("비트 |  (또는)     : " + c);     // 1001
        // a 와 b 를 비교하여 하나라도 1일 경우 1이다.         // 1011    -> 8+0+2+1 = 11
        
        int d = a&b;                                        // 1010    
        System.out.println("비트 & (그리고)    : " + d);     // 1001
        // a 와 b 를 비교하여 두개가 모두 1일 경우 1이다.     // 1000 -> 8+0+0+0 = 8
    
        int f = a^b;                                        // 1010
        System.out.println("비트 ^ (같지않으면): " + f);     // 1001
        // a 와 b 를 비교하여 두개가 하나만 1일 경우 1이다.  // 0011 -> 0+0+2+1 = 3
        
        int g = a<<b;
        System.out.println("비트 << (시프트)   : " + g);
        // 죄송합니다. 아직 잘 모르겠습니다.
        // 최대한 빠르게 학습하겠습니다.
    } 
 
    public static void main(String[] args){
        new Operator5().m();
    }
}
//cs





(06) 비교 연산자

== , != , > , < , >= , <=


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Operator6{    // 비교 연산자
    int a = 10;
    int b = 10;
 
    void m6(){        // >= , <= , > , < , == , !=
        boolean r1 = (a == b);                      // a 와 b는 같다.
        System.out.println(" a == b  : " + r1);
        System.out.println("");                        
        
        boolean r2 = (a != b);                      // a 는 b가 아니다(다르다).
        System.out.println(" a != b  : " + r2);
        System.out.println("");                        
 
        boolean r3 = (a >= ++b);                    // a 가 b 보다 크거나 같다.
        System.out.println(" a >= b  : " + r3);
        System.out.println(" b=10 -> : " + b);
    }
 
    public static void main(String[] args){
        Operator6 os6 = new Operator6();
        os6.m6();
    }
}
cs


(07) 논리 연산자

&& , & , || , |


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Operator7{    // 논리 연산자
 
    int a = 10;
    int b = 10;
 
    void m7(){     // && , & , || , |
        boolean r1 = true && (a==b);        //  A && B : A 와 B 의 결과가 모두 같다면 true
        System.out.println("r1 : " + r1);
        boolean r2 = true || (a>b);         //  A || B : A 와 B 의 결과가 하나만 true 라도 true
        System.out.println("r2 : " + r2);   //  Short Circuit Effect
    }                                       //  || 와 | 는 같은 의미 이지만,
                                            //  || 은 융통성이 있어서 앞에서 true 라면 뒤에는 보지 않는다.
 
    public static void main(String[] args){
        new Operator7().m7();
    }
}
cs



(08) 논리 대입 연산자

&= , |=


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Operator8{    // 논리 대입 연산자
 
    void m8(){            // &= , |=
        boolean flag1 = true;
        flag1 &= false;
 
        boolean flag2 = true;
        flag2 |= false;
        System.out.println("flag1 : " + flag1);
        System.out.println("flag2 : " + flag2);
    }
 
    public static void main(String[] args) {
        new Operator8().m8();
    }
}
 
cs


(09) 조건 연산자 (=삼항 연산자)

A? B:C


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
class Operator9{    // 삼항(조건) A? B:C
    
    void m9_1(){
        int a = 10;
        String r = ( a > 20 )? "맞아요 (삼항)":"틀려요 (삼항)";
        System.out.println(r);
    }
 
    void m9_2(){
        int a = 10;
        String r = "";
        if(a > 20){
            r = "맞아요 (if)";
        }else{
            r = "틀려요 (if)";
        }
        System.out.println(r);
    }
    
    public static void main(String[] args) {
        Operator9 o9 = new Operator9();
        o9.m9_1();
        o9.m9_2();
    }
}
 
cs



(10) instanceof

객체 instanceof클래스


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Operator10 {    // 객체 instanceof 클래스
 
    void m10(){
        String str = "CIVIC";
        boolean r1 = str instanceof Object;
        System.out.println("r1 : " + r1);
 
        Object obj = str;
        boolean r2 = obj instanceof String;
        System.out.println("r2 : " + r2);
    }
 
    public static void main(String[] args) {
        new Operator10().m10();
    }
}
cs


반응형