[JAVA] 자바의 연산자

산술 연산자(+, -, *, /, %)

• *기본 사칙연산(+, -, , /) 과 나머지 연산자로 구성
• 나눗셈 연산자(/)는 나눗셈 결과 중 몫만 계산하고, 나머지 연산자(%)는 나눗셈 결과 중 나머지만 계산
• 덧셈연산자의 경우 일반적인 덧셈 기능 외에 문자열에 사용 시 문자열 결합 연산자로 동작함ex) "문자열" + 정수 = "문자열정수" 실수 + "문자열" = "실수문자열"
• (문자열과 특정 데이터타입간에 덧셈연산시 두 데이터를 결합하여 하나의 문자열로 만들어준다)

		int a = 10, b = 3, c;
		
		c = a + b;
		System.out.println(a + " + " + b + " = " + c);

		c = a - b;
		System.out.println(a + " - " + b + " = " + c);

		c = a * b;
		System.out.println(a + " * " + b + " = " + c);

		c = a / b; // 10 나누기 3 의 몫 = 3
		System.out.println(a + " / " + b + " = " + c);

		c = a % b; // 10 나누기 3 의 나머지 = 1
		System.out.println(a + " % " + b + " = " + c);
		
		System.out.println("----------------------------");
		
		// 덧셈연산자(+)의 다른 사용법 = 문자열 결합
		String s1 = "Java";
		String s2 = "Programming";
		String s3 = s1 + s2; // 두 문자열을 결합하여 하나의 문자열을 생성
		System.out.println(s3);
		
		String s4 = s1 + 111; // "Java" + 111 = "Java111" 문자열이 생성됨
		System.out.println(s4);
		
		System.out.println(1 + 1 + "1");
		// => 정수 1 + 1 산술연산을 먼저 수행하여 2가 된 후
		//    다시 문자열 "1" 과 결합하여 "21" 이 출력됨
		System.out.println(1 + "1" + 1);
		// => 정수 1 과 문자열 "1" 을 결합하여 "11" 이 되고
		//    다시 문자열 "1" 과 결합하여 "111" 이 출력됨

산술 연산에서의 자동 형변환

• 산술 연산 수행 시 두 피연산자의 타입이 다를 경우 연산 수행 전에 두 피연산자의 타입을 일치시킨 후 연산을 수행함

타입을 일치시키는 규칙

1. int 보다 작은 타입(byte, short, char) 끼리의 연산 시 모든 피연산자를 int로 변환
2. ex) byte + byte = int + int = int short + char = int + int = int
3. int 이상의 타입이 피연산자로 있을 경우 두 피연산자 중 큰 타입으로 일치시킨 후 연산을 진행
4. ex) int + long = long + long = long float + long = float + float = float

		byte b1 = 10, b2 = 3;
		//byte b3 = b1 + b2;
		// b1 과 b2 모두 byte 타입이므로 연산 전 int 타입으로 자동 변환됨
		// 따라서, 연산 결과가 int 타입이 되어 byte 타입에 저장 불가능
		//byte b3 = (byte)b1 + (byte)b2; // 주의! 잘못된 문법
		// => 최종적으로 연산 시점에서 다시 int 로 변환 후 연산 수행함
		
		// 연산 결과(int)를 다시 byte 타입으로 변환해야한다!
		byte b3 = (byte)(b1 + b2);
		System.out.println(b3);
		
		short s1 = 10;
		//short s2 = b1 + s1; // byte + short = int + int = int
		short s2 = (short) (b1 + s1); // int -> short 으로 강제형변환
		System.out.println(s2);
		
		
		// int 이상의 타입이 피연산자로 있을 경우
		// => 둘 중 큰 타입으로 변환 후 연산을 진행
		char ch1 = 'A';
		//char ch2 = ch1 + 3; // char + int = int + int = int
		char ch2 = (char)(ch1 + 3); // int -> char 로 강제형변환
		System.out.println(ch2);
		
		int i1 = 100;
		long l1 = 200;
		//int i2 = i1 + l1; // int + long = long + long = long
		int i2 = (int)(i1 + l1); // long -> int 로 강제형변환
		System.out.println(i2);
		
		float f1 = 1.0f;
		//long l2 = f1 + l1; // float + long = float + float = float
		long l2 = (long) (f1 + l1);
		System.out.println(l2);
		
		System.out.println("----------------------");
		
		System.out.println(10 / 3); // int / int = int
		// 나눗셈 연산자는 몫만 계산하지만 
		// 정수 연산에서 연산 결과와
		// 실수가 포함된 나눗셈 연산 결과가 달라짐
		System.out.println(10 / 3.0); // int / double = double
		// => 10 / 3 과 달리 3.0 은 double 타입이므로
		//    실수 나눗셈을 수행하여 소수점 자리까지 계산됨
		
		System.out.println(10 / (double)3); // 위의 연산과 동일하지만
		// 일반적으로 정수 -> 실수 변환하여 표현 시 .0 을 붙여서 표기
		
		// -----------------------------
		
		// byte 타입 변수에 int형 리터럴 간의 연산 결과를 저장할 때
		// 연산 결과를 최종적으로 변수에 할당하므로 별도의 형변환 필요없음
		byte b4 = 10 + 10; // 10 + 10 = int + int 이지만
		// byte b4 = 20; 코드를 실행한 결과와 같다. 따라서 오류 X
		System.out.println(b4);
		
		//byte b5 = 10 + 120; // 오류 발생
		// 연산 결과가 byte 범위를 벗어나므로 int 형으로 취급되어
		// byte 타입 변수에 저장 불가능 => 이 때는 강제 형변환 필요함
		
		// ------------------------------------
		
		float f10 = 2.0f, f11 = 1.1f;
		float f12 = f10 - f11;
		System.out.println(f12);
		
		double d10 = 2.0, d11 = 1.1;
		double d12 = d10 - d11;
		System.out.println(d12);

 

대입연산자(=)

• 우변의 피연산자 데이터를 좌변의 변수에 대입(저장)

 

반응형

 

확장(복합) 대입연산자(+=, -=, *=, /=, %=)

• 산술연산자와 대입연산자를 결합한 연산자
• 두 피연산자의 산술 연산 결과를 좌변의 변수에 대입
• 연산 과정에서 자동 형변환이 일어나지 않음

		int a = 10;
		
		// a + 10 의 연산 결과를 다시 변수 a 에 저장
		//		a = a + 10; // 10 + 10 = 20
		a += 10; // 확장대입연산자(연산 결과는 동일함)
		System.out.println(a);
		
		// a - 10 의 연산 결과를 다시 변수 a 에 저장
		//		a = a - 10; // 20 - 10 = 10
		a -= 10;
		System.out.println(a);
		
		// a * 10 의 연산 결과를 다시 변수 a 에 저장
		//		a = a * 10; // 10 * 10 = 100
		a *= 10;
		System.out.println(a);
		
		// a / 10 의 연산 결과를 다시 변수 a 에 저장
		//		a = a / 10; // 100 / 10 = 10
		a /= 10;
		System.out.println(a);
		
		// a % 10 의 연산 결과를 다시 변수 a 에 저장
		//		a = a % 10; // 10 % 10 = 0
		a %= 10;
		System.out.println(a);

증감연산자(++, - -)

• 단항연산자로 피연산자가 1개뿐인 연산자
• 피연산자(변수)의 값을 1만큼 **증가(++)**시키거나 **감소(--)**시킴
• 피연산자의 앞에 붙을 경우 전위(선행)연산자로 사용되며 피연산자의 뒤에 붙을 경우 후위(후행)연산자로 사용됨
• 전위(선행)연산자
• 피연산자의 값을 먼저 1만큼 증가 또는 감소시킨 뒤 다른 연산 등에 참여함
• 후위(후행)연산자
• 피연산자를 먼저 다른 연산 등에 참여시킨 뒤 피연산자의 값을 1만큼 증가 또는 감소시킴
• 확장 대입연산자와 마찬가지로 연산 과정에서 별도의 형변환이 일어나지 않는다

		int a = 10;
		++a; // 증감연산자를 사용하여 a값을 1만큼 증가시킴
		System.out.println(a);
		// => a 값을 1만큼 증가시키는 다른 방법 : a = a + 1 또는 a += 1
		
		a++; // 증감연산자를 사용하여 a값을 1만큼 증가시킴
		System.out.println(a);
		
		--a; // 증감연산자를 사용하여 a값을 1만큼 감소시킴
		System.out.println(a);
		
		a--; // 증감연산자를 사용하여 a값을 1만큼 감소시킴
		System.out.println(a);

		int x = 5;
		int y = ++x; // 전위(선행)연산자로 사용되는 증감연산자
		// 먼저 x 의 값을 1만큼 증가시킨 후 변수 y 에 x값을 대입한다.
		// 따라서, x가 5 -> 6 으로 변화된 후 y 에 저장되므로 y 도 6 이 저장
		System.out.println(x + ", " + y);
		
		int x2 = 5;
		int y2 = x2++; // 후위(후행)연산자로 사용되는 증감연산자
		// 먼저 x2 의 값을 변수 y2 에 대입한 뒤, x2 의 값을 1만큼 증가시킴
		// 따라서, x2가 5 일 때 y2 에 저장되고, 
		// 그 후 x2 의 값이 5 -> 6 으로 증가됨
		System.out.println(x2 + ", " + y2);
		
		
		int i = 5;
		int j = ++i; 
		// 선행연산자이므로 i 값을 1 증가시킨 후 j 에 저장(i = 6, j = 6)
		
		System.out.println(j++);
		// 후행연산자이므로 j 값을 출력한 후, 1 증가시킴
		// => 6이 출력된 후, j 값은 6 -> 7 로 증가됨
		
		System.out.println(--j);
		// 선행연산자이므로 j 값을 1 감소시킨 후, 출력
		// => j 값은 7 -> 6 으로 감소된 후 6이 출력됨

	char ch = 'A';
		
		// char 타입 변수 ch 의 값을 1 만큼 증가시키는 방법 3가지
		// 1. 기본 산술연산자와 대입연산자를 조합하여 사용
		ch = (char)(ch + 1); // 반드시 강제형변환 필수!
		System.out.println(ch);
		
		// 2. 확장 대입연산자를 사용
		ch += 1; // 별도의 형변환 필요없음
		System.out.println(ch);
		
		// 3. 증감연산자를 사용
		ch++; // 별도의 형변환 필요없음
		System.out.println(ch);