JAVA 수업 복습 정리(7)_연산자/Operator/java/프로그래밍

* 연산자(Operate)

• 연산자(Operate) : 계산을 목적으로 제공되는 기호 또는 키워드
  → 피연산자 : 연산자에 의해 계산되어지는 값
  → 피연산자의 갯수에 따라 단항연산자(1개), 이항연산자(2개), 삼항연산자(3개)로 구분(연산자가 여러개인 경우 단항 >> 이항 >> 삼항 순서로 처리)

• 최우선 연산자 : 무조건 가장 먼저 명령이 실행되도록 처리하는 연산자
  => () : 우선처리 연산자, [] : 배열 연산자, . : 객체 연산자
• 단항 연산자 : 피연산자의 갯수가 1개인 연산자
  => + : 양수화 연산자 - 피연산자에 +1을 곱한 결과값을 제공하는 연산자
  => - : 음수화 연산자(2의 보수 연산자) - 피연산자에 -1을 곱한 결과값을 제공하는 연산자
  => ~(틸드) : Bit Not 연산자(1의 보수 연산자) - 피연산자(정수값)의 Bit 단위로 표현된 값을 반대로 변환하여 제공하는 연산자 0은 1로, 1은 0으로 변환(기계제어에 필요해서 실제로 우리가 쓸 일은 없다)
  => ! : Not 연산자 - 피연산자(논리값)를 반대로 변환하여 제공하는 연산자
  => ++ : 1증가 연산자 - 피연선자를 반드시 변수로 사용하며, 변수값을 1 증가하여 저장하는 연산자
  => -- : 1감소 연산자 - 피연선자를 반드시 변수로 사용하며, 변수값을 1 감소하여 저장하는 연산자.
  => (자료형) : 강제 형변환 연산자 - 피연산자의 자료형을 일시적으로 변환하여 제공하는 연산자
  => new : 객체 생성 연산자 - 클래스의 생성자를 호출하여 객체를 생성하여 제공하는 연산자
      → ex) String name = new String()
  
  
• //++a2; //a2=a2+1; => 왜 ++a2로 쓰나? 가독성때문에(연산자개수), a2=a2+1는 저장할때 형변환이 일어남
  --a3; //a3=a3-1;
• ++ 연산자와 -- 연산자는 피연산자 뒤에 위치하여 작성 가능
  => ++ 연산자와 -- 연산자를 사용한 단일 명령인 경우 연산자의 위치는 연산결과에 영향을 주지 않는다

• 이항 연산자 : 피연산자의 갯수가 2개인 연산자
  => 산술 연산자, 이동 연산자, 비교 연산자, 논리 연산자, 대입 연산자
  
  
• 산술 연산자 : *(곱), /(나누기), %(나머지), +(합 또는 문자열 결), -(차)
• 이동 연산자 : 정수값을 원하는 방향으로 Bit 수만큼 이동하는 연산자
  => <<(왼쪽 이동 연산자), >>(오른쪽 이동 연산자 : 남는 왼쪽을 부호Bit로 채움), >>>(오른쪽
  이동 연산자 : 남는 왼쪽을 0으로 채움)
  
  
• 비교(관계) 연산자 : 값을 비교하여 논리값을 제공하는 연산자
  ⇒ >(크다), <(작다), >=(크거나같다), <=(작거나같다), ==(같다), !=(같지않다), instanceof : 객체 구분(비교) 연산자
  ⇒크다, 작다가 먼저 연산되고 그 다음에 같다, 같지않다가 연산된다.
  
  
• 논리 연산자 : Bit 논리 연산자, 일반 논리 연산자(Bit 논리 연산자가 먼저 실행)
  => Bit 논리 연산자 : 두 피연산자(정수값)를 Bit 단위로 계산하기 위한 연산자 - &(논리곱), ^(배타적 논리합), |(논리합)
  => 일반 논리 연산자 : 비교식를 연결하여 처리하기 위한 연산자 - &&(And 연산자), ||(Or 연산자)

• 변수값이 작은값~큰값 범위의 값을 확인하기 위한 연산식
  => 작은값<=변수<=큰값 ->  이렇게 쓰면 안됨
  => 변수값>=작은값 && 변수값<=큰값 -> 이렇게 써야함

 

• && 연산자는 첫번째 비교식이 거짓인 경우 두번째 && 연산자 뒤의 명령은 미실행(어차피 첫번째 비교식 때문에 거짓이기 때문)
• &&을 &로 표시해도 되기는 함(정석은 아님). 그런데 앞 비교식이 거짓이어도 뒤 비교식까지 읽는다.
• || 연산자는 첫번째 비교식이 참인 경우 || 연산자 뒤의 비교식 미시행(어차피 첫번째가 비교식 때문에 참이기 때문)

 

• 삼항 연산자 : 피연산자의 갯수가 3개인 연산자
  - 삼항 연산자 형식 : 조건식 ? 참값 : 거짓값
  => 조건식 : 논리값(false 또는 true)을 제공하는 연산자
  => 조건식의 결과값이 [true]인 경우 참값을 제공하고, [false]인 경우 거짓값을 제공한다.
  
  
• [X % Y == 0]의 결과값이 [true]인 경우 X는 Y의 배수로 표현 - 배수 표현식
• 산술 연산자 > 비교 연산자 순서대로 진행
  
  
• 대입 연산자 : 왼쪽 피연산자(변수)에 값을 저장하기 위한 연산자
  => 무조건 마지막에 실행되는 연산자(연산 결과를 저장해야 하기 때문)
  (이항 연산자이긴 하지만 삼항 연산자보다 먼저 실행되지는 않는다.)
  => 순수 대입 연산자 (=) : 변수에 값을 저장하는 연산자
  => 계산 대입 연산자(*=, /=, %=, +=., -=, <<=, >>=, >>>=, &=, ^=, |=) : 계산 처리 결과값을 변수에 저장
  
  
• 일반적인 연산식은 왼쪽에서 오른쪽 방향으로 해석되어 실행되지만 단항 연산자 및 대입 연산자를 사용한 연산식은 오른쪽 방향에서 왼쪽 방향으로 해석되어 실행
  ex) A + B + C A = B = C
        -------->   <--------

 

package basic;

//연산자(Operate) : 계산을 목적으로 제공되는 기호 또는 키워드
//=> 피연산자 : 연산자에 의해 계산 되어지는 값
//=> 피연산자의 갯수에 따라 단항연산자(1개), 이항연산자(2개), 삼항연산자로(3개) 구분
//   (연산자가 여러개 있으면 단항먼저, 그다음 이항, 그다음 삼항 순서로 처리한다)

//연산자의 처리 순서에 의해 분류
public class OperatorApp {
	public static void main(String[] args) {
		//최우선 연산자 : 무조건 가장 먼저 명령이 실행되도록 처리하는 연산자
		//=> () : 우선처리 연산자, [] : 배열 연산자, . : 객체 연산자
		System.out.println("10 + 20 * 3 = "+(10+20*3));
		System.out.println("(10 + 20) * 3 = "+((10+20)*3));
		System.out.println("=====================================================");
		
		//단항 연산자 : 피연산자의 갯수가 1개인 연산자
		//=> + : 양수화 연산자 - 피연산자에 +1을 곱한 결과값을 제공하는 연산자
		//=> - : 음수화 연산자(2의 보수 연산자) - 피연산자에 -1을 곱한 결과값을 제공하는 연산자
		//=> ~(틸드) : Bit Not 연산자(1의 보수 연산자) - 피연산자(정수값)의 Bit 단위로 표현된 값을 반대로 변환하여 제공하는 연산자
					// 0은 1로, 1은 0으로 변환(기계제어에 필요해서 실제로 우리가 쓸 일은 없다)
		//=> ! : Not 연산자 - 피연산자(논리값)를 반대로 변환하여 제공하는 연산자
		//=> ++ : 1증가 연산자 - 피연선자를 반드시 변수로 사용하며, 변수값을 1 증가하여 저장하는 연산자.
		//=> -- : 1감소 연산자 - 피연선자를 반드시 변수로 사용하며, 변수값을 1 감소하여 저장하는 연산자.
		//=> (자료형) : 강제 형변환 연산자 - 피연산자의 자료형을 일시적으로 변환하여 제공하는 연산자
		//=> new : 객체 생성 연산자 - 클래스의 생성자를 호출하여 객체를 생성하여 제공하는 연산자
		//			ex) String name = new String()
		int a1=10;
		System.out.println("a1 = "+a1);
		System.out.println("-a1 = "+(-a1));
		System.out.println("20 > 10 = "+(20>10));
		System.out.println("!(20 > 10) = "+!(20>10));
		System.out.println("=====================================================");
		
		int a2=10, a3=10;
		System.out.println("a2 = "+a2+", a3 = "+a3);
		
		//++a2; //a2=a2+1; => 왜 ++a2로 쓰나? 가독성때문에(연산자개수), a2=a2+1는 저장할때 형변환이 일어남
		//--a3; //a3=a3-1;
		
		//++ 연산자와 -- 연산자는 피연산자 뒤에 위치하여 작성 가능
		//=> ++ 연산자와 -- 연산자를 사용한 단일 명령인 경우 연산자의 위치는 연산결과에 영향을 주지 않는다
		a2++;
		a3--;
		
		System.out.println("a2 = "+a2+", a3 = "+a3);
		
		char mun='A';
		//mun=(char)(mun+1);
		++mun;
		System.out.println(mun);
		System.out.println("=====================================================");
		int a4=10, a5=10;
		
		//++ 연산자와 -- 연산자를 사용한 단일 명령이 아닌 경우 연산자의 위치는 연산결과에 영향을 준다.
		int b1=++a4; //전처리 : ++a4 명령을 실행하고 결과값을 b1 변수에 저장한다(나를 먼저처리하고 다른 명령은 나중에)
		int b2=a5++; //후처리 : a5 변수값을 b2 변수에 저장하고 b5++ 명령 실행(다른 명령을 먼저 처리하고 나는 나중에)
		
		//int tot = ++a4 + a5--; => 결과값은 21
		//System.out.println(++a4); // 결과값은 11(1 먼저 증가하고 출력)
		//System.out.println(a4++); // 결과값은 10(출력을 먼저하고 1 증가)
		
		System.out.println("a4 = "+a4+", a5 ="+a5);
		System.out.println("a4 = "+b1+", a5 ="+b2);
		System.out.println("=====================================================");
		
		//이항 연산자 : 피연산자의 갯수가 2개인 연산자
		//=> 산술 연산자, 이동 연산자, 비교 연산자, 논리 연산자, 대입 연산자
		
		//산술 연산자 : *(곱), /(나누기), %(나머지), +(합 또는 문자열 결), -(차)
		int c1=20, c2=10;
		System.out.println(c1+" * "+c2+" = "+(c1*c2));
		System.out.println(c1+" / "+c2+" = "+(c1/c2));
		System.out.println(c1+" % "+c2+" = "+(c1%c2));
		System.out.println(c1+" + "+c2+" = "+(c1+c2));
		System.out.println(c1+" - "+c2+" = "+(c1-c2));
		System.out.println("=====================================================");
		//이동 연산자 : 정수값을 원하는 방향으로 Bit 수만큼 이동하는 연산자
		//=> <<(왼쪽 이동 연산자), >>(오른쪽 이동 연산자 : 남는 왼쪽을 부호Bit로 채움), >>>(오른쪽 이동 연산자 : 남는 왼쪽을 0으로 채움)
		//50(10진수) : 4Byte(32Bit) - 00000000000000000000000000110010
		//50 << 3(왼쪽으로 3Bit 이동) : 00000000000000000000000110010000 -> 400(10진수) / 왼쪽 이동후 오른쪽 3칸은 무조건 0으로 채운다
		//50 >> 3(왼쪽으로 3Bit 이동) : 00000000000000000000000000000110 -> 왼쪽은 최초 부호비트 값으로 채운다.
		// 기계제어할 때 외에는 shift 를 쓸 일이 없어서 우리는 실제적으로 필요없다.
		
		//-50(10진수) : 4Byte(32Bit) - 11111111111111111111111111111111001101
		//-50 >> 3 : 11111111111111111111111111111111111001
		//-50 >>> 3 : 00011111111111111111111111111111111001 -> 오른쪽으로 밀고 왼쪽 3칸을 부호Bit로 채우는게 아니라 무조건 0으로 채움
		System.out.println("=====================================================");
		
		//비교(관계) 연산자 : 값을 비교하여 논리값을 제공하는 연산자
		//=> >(크다), <(작다), >=(크거나같다), <=(작거나같다), ==(같다), !=(같지않다), instanceof : 객체 구분(비교) 연산자
		//크다, 작다가 먼저 연산되고 그 다음에 같다, 같지않다가 연산된다.
		System.out.println("20 > 10 = "+(20>10));
		System.out.println("20 < 10 = "+(20<10));
		System.out.println("20 == 10 = "+(20==10));
		System.out.println("20 != 10 = "+(20!=10));
		System.out.println("=====================================================");
		
		//논리 연산자 : Bit 논리 연산자, 일반 논리 연산자(Bit 논리 연산자가 먼저 실행)
		//=> Bit 논리 연산자 : 두 피연산자(정수값)를 Bit 단위로 계산하기 위한 연산자 - &(논리곱), ^(배타적 논리합), |(논리합)
		/*
		     01011100
		   & 11001110
		   -----------
		     01001100 (두 값 모두 1이면 1이고, 둘중 하나만 0이여도 0이다.-곱이기 때문)
		    
		     01011100
		  ^  11001110
		  -----------
		     10010010 (위아래 값이 같으면 0, 다르면 1)
		     
		     01011100
		  |  11001110
		  -----------
		     11011110 (하나라도 1이면 1)
		 */
		
		//=> 일반 논리 연산자 : 비교식를 연결하여 처리하기 위한 연산자 - &&(And 연산자), ||(Or 연산자)
		int d=20;
		System.out.println("d = "+d);
		
		// 변수값이 작은값~큰값 범위의 값을 확인하기 위한 연산식
		//=> 작은값<=변수<=큰값 ->  이렇게 쓰면 안됨
		//=> 변수값>=작은값 && 변수값<=큰값 -> 이렇게 써야함 
		
		//&& 연산자는 첫번째 비교식이 거짓인 경우 두번째 && 연산자 뒤의 명령은 미실행
		//(어차피 첫번째 비교식 때문에 거짓이기 때문)
		// &&을 &로 표시해도 되기는 함(정석은 아님). 그런데 앞 비교식이 거짓이어도 뒤 비교식까지 읽는다.
		System.out.println("d >= 10 && d <= 30 ="+(d >= 10 && d <=30)); //범위 안에 있는 값
		//|| 연산자는 첫번째 비교식이 참인 경우 || 연산자 뒤의 비교식 미시행
		//(어차피 첫번째가 비교식 때문에 참이기 때문)
		System.out.println("d < 10 || d > 30 ="+(d < 10 || d > 30)); //범위 밖에 있는 값
		System.out.println("=====================================================");
		
		//삼항 연산자 : 피연산자의 갯수가 3개인 연산자
		//형식) 조건식 ? 참값 : 거짓값
		//=> 조건식 : 논리값(false 또는 true)을 제공하는 연산자
		//=> 조건식의 결과값이 [true]인 경우 참값을 제공하고, [false]인 경우 거짓값을 제공한다.
		//int e1=20, e2=10;
		int e1=10, e2=20;
		System.out.println("큰 값 = "+e1);
		System.out.println("큰 값 = "+(e1 > e2 ? e1 : e2)); //변수에 저장된 값이 바뀌어도 큰값을 출력하고 싶을때
		System.out.println("=====================================================");
		
		int e3=10;
		
		//[X % Y == 0]의 결과값이 [true]인 경우 X는 Y의 배수로 표현 - 배수 표현식
		System.out.println(e3+" = "+(e3 % 2 == 0 ? "짝수" : "홀수"));
		//산술 연산자 > 비교 연산자 순서대로 진행
		System.out.println("=====================================================");
		
		//대입 연산자 : 왼쪽 피연산자(변수)에 값을 저장하기 위한 연산자
		//=> 무조건 마지막에 실행되는 연산자(연산 결과를 저장해야 하기 때문)
		     //(이항 연산자이긴 하지만 삼항 연산자보다 먼저 실행되지는 않는다.)
		//=> 순수 대입 연산자 (=) : 변수에 값을 저장하는 연산자
		//=> 계산 대입 연산자(*=, /=, %=, +=., -=, <<=, >>=, >>>=, &=, ^=, |=) : 계산 처리 결과값을 변수에 저장
		
		int e4=10;
		System.out.println("e4 ="+e4);
		
		e4+=20; // e4라는 변수값에 20을 더해서 저장한다.
		System.out.println("e4 ="+e4);
		System.out.println("=====================================================");
		int f1, f2, f3;
		
		//일반적인 연산식은 왼쪽에서 오른쪽 방향으로 해석되어 실행되지만
		//단항 연산자 및 대입 연산자를 사용한 연산식은 오른쪽 방향에서 왼쪽 방향으로 해석되어 실행
		//ex) A + B + C					A = B = C
		//    -------->					<--------
		f1=f2=f3=10;
		System.out.println("f1 = "+f1+", "+"f2 = "+f2+", "+"f3 = "+f3);
		System.out.println("=====================================================");
		
		
	}
}