JAVA의 정석 4일차 - 연산자

2020.06.18(목)

   1. 연산자의 종류
    1) 단항연산자
     (1) 증감연산자 (++, --)
     (2) 부정연산자 (!)
     (3) 부호연산자 (+, -)
     (4) 형변환연산자 ((type)) type ==> int, byte, char, double, long...
                                                       (int) (byte) (char) (double) (long)
   ===> 데이터형을 변경해서 연산처리가 가능하게 만든다 (연산: 데이터형이 동일)

     2) 이항연산자
       (1) 산술연산자 (+, -, *, /, %) => 형변환
   나누기 /
   => 0으로 나눌 수 없다
   => 정수/정수=정수 => 5/2=2
   % => 나머지 (배수) 항상 왼쪽 부호를 따라감.
   ==> 5%2 (1) 
   ==> 5%-2 (1)
   ==> -5%2 (-1)
   ==> -5%-2 (-1)
      (2) 비트연산자 (&, |, ^)
      (3) 쉬프트연산자 (<<. >>)
      (4) 비교연산자 (==, !=, <, >, <=, >=)
      (5) 논리연산자 (&&. ||)
      (6) 대입연산자 (=, +=, -=, ...)

    3) 삼항연산자
    - 조건 ? 값1:값2
      조건:true ==> 값1
      조건:false ==> 값2

 

*참고

  (1) 단항

   증감 => int 
   부정 => boolean 
  (2) 이항 
   산술 => 결과값이 뭐가 나올지 알 수 없음. 
   int + int = int 
   double + int = double 
   비교, 논리 => boolean 
  (3) 삼항 : 조건?값1:값2 
   sex==1?"남자":"여자" 
   sex==1?1:2

 2. 단항연산자
   1) 증감연산자
    ++ : 무조건 한개를 증가한다
    -- : 무조건 한개를 감소한다
    사용법
     int a = 10; 변수 선언
     ++10(X)
  
     ==> ++a (--a) : 전치연산자
     a++ (a--) : 후치연산자 
   ==================> 반복문을 사용, 게임로직
   예) for(int i=1; i<=10; i++)

   - 전치연산자 : 증가한 다음에 대입
   int a=10;
   int b= ++a;
   ==2 ==1 (++1번째 계산) (=2번째 계산)
   ==> ++a a=11
   ==> b=a b=11
   a=11, b=11
   - 후치연산자 : 대입을 먼저하고 나중에 증가
   int a=10;
   int b = a++
   ===1 ==2
   ==> b=a ===> b=10
   ==> a++ ===> a=11
  
 2) 부정연산자 (true=>false, false=>true) ==> !
   ====== 반드시 boolean을 사용한다
   예)
   boolean bCheck=false;
   bCheck=!bCheck

==> System.out.println(bCheck); => false. 증감 ++, --와달리 자동으로 바뀌지 않음.

       메모리에 저장하려면 bCheck=!bCheck. 바뀐값을 받아야함.

 

 3) 형변환연산자 (cast연산자)

  필요시에 데이터형을 변경해서 사용 (강제 형변환)
  (int)double ==> int ===> 큰데이터 => 작은데이터 변경
  (char)int ==> char
  int + double = double (자동 형변환)
  ===
  double
  
  char + int = int
  ====
  int
  
  int + long = long
  ===
  long
  
  char + int + long + double = double
  ===
  int
  ======= 
      int
      ==========
           long
           ==============
                    double
  앞에서부터 순차적으로 바뀌어나감
  
  1) boolean은 제외
  2) int 이하는 연산을 하면 결과값이 int
   byte + byte => int
   char + char => int
   sohrt + byte => int
   char + byte + short => int

 

3. 이항연산자

 1) 산술연산자 (+, -, *, /, %)
   => 자바에서 제공하는 모든 연산자는 산술로 변환 할 수 있다
   => 자바프로그램에서 가장 많이 사용되는 연산자
   => 주의점
   (1) 형변환 ==> 가장 큰 데이터형으로 변경
   (2) / 나누기  
   => 0으로 나누면 오류가 발생
   => 정수/정수=정수
   (3) % 나머지 
   => 부호는 왼쪽편 부호가 남는다.
  
   5<<2  (5의 2진법 101) 
   10100 
   16+4 ==> 20
   9<<3  (9의 2진법 1001)
   1001000
   =  =
   64  8  =>72
   >>
   x << y  => x * 2 y승

 

  'A' + 'B'
  ==   ==
  65 + 66 => 131 (int)  char, short, byte => 연산 => 결과값 int
  
  *** 주의점 : 데이터형을 초과하면 error가 아니라 오버플로우를 발생
  
  예) int ==> 1~10   11 => 1
  
      -128~127 ==> 128 ==>
      =========================
       0 1 1 1 1 1 1 1 ==> 127이 컴퓨터에 저장
      =========================
       1 0 0 0 0 0 0 0 ==> -128
      
      128 64 32 16 8 4 2 1
       1  0  0  0  0 0 0 0
       
       10+10.5
       ==
       10.0 ==> 같은 데이터형만 연산이 가능
       
       'A'+1 ==> int 66
       == 
       65
       
       강제형변환
        (int)(10.5+10.5) // 괄호안이 우선순위이기 때문에
        =============
        1=> 21.0 => 21
        (int)10.5+(int)10.5 ==> 20 // int가 우선순위이기 때문에
        ========= =========
        10   10

 

 2) 비트연산자 => 비트와 비트를 연산
    8
    =======
    1 0 0 0
    =======
    6
    =======
    0 1 1 0
    =======
      &  |  ^ ==> 회로, 암호화/복호화
       (*)(+)
      ======
    00  0  0  0 (^연산자는 비트 XOR서로 다를 때 1)
    01   0  1  1
    10   0  1  1
    11   1  1  0
    
    10 & 5
    
    1010
    0101
    ==== & (곱하면 됨)
    0000 ==> 0
    
    1010
    0101
    ==== | (더하면 됨)
    1111 ===> 15
    
    1010
    0101
    ==== ^ (서로 다를 때 1, 같으면 0)
    1111 ==> 15
    
    
    27 & 13
    27 | 13
    27 ^ 13
    
    11011
    01101
    
    01001 & 9
    
    11111 | 31
    
    10110 ^ 22
    
    & => *를 한다
    | => +를 한다
    ^ => 다른비트 찾는다

 

3) 쉬프트연산자 => 비트이동 연산자 <<, >>
  << : 왼쪽으로 이동 ==> 공백에 0을 채운다 => 숫자가 커질수밖에없음
   ==========> X<<Y ==> X*2^Y
   ==> 10 << 2 ==> 10*2^2 ==> 40
   10 << 2
   1010 => 10
   101000 => 40
  
  >> : 오른쪽이동 ==> 비트를 제거
       ==========> X>>Y ==> X/2^Y
        ==> 10 >> 2 ==> 10/2^2 ==> 10/4 ==> 2
   10 >> 2
   1010 => 10
   10 => 2
      
    8<<3
    1000 =>8
    1000000 => 64
    
    8>>3
    1000 => 8
    1 => 1
       
    20<<3 ==> 160 20*8
    20>>3 ==> 2 20/8
     
    10100
    10100000 => 128+32 => 160
    10 => 2