03_연산자(Operation)
1. 최우선 연산자
1) 직접 접근 연산자 [우선순위 1]
(1) ( ) 소괄호: - 우선 계산
(2) . 점: 접근 연산자
(3) { } 중괄호
2. 단항 연산자 - 피연산자(연산을 당하는 것)의 수가 1개인 연산자 [우선순위 2]
(1) +: 양수를 나타냄
(2) -: 음수를 나타냄
(3) (자료형): 형변환 연산자
(4) ++
(5) --
(6) ~
*증감 연산자: 단항 연산자로써 값을 1씩만 증가시키거나 혹은 감소시키는 연산자
[ 종류 ]
++: 값을 1씩 증가시키는 연산자
++값(전위 연산자)
값++(후위 연산자)
--: 값을 1씩 감소시키는 연산자
--값(전위연산자)
값--(후위연산자)
* (증감 연산자)값: 전위연산 => 선 증감 후 처리
* 값(증감 연산자): 후위연산 => 선 처리 후 증감
package com.kh.operator;
// 증감 연산자
public class B_InDecrease {
public void method1() {
int num = 10;
System.out.println("num: " + num);
num++; // num에 1을 증가시키겠다
// num = num + 1; 와 같은 의미
System.out.println("변경된 num: " + num);
int num2 = 10;
System.out.println("num2: " + num2);
num2--; // num2에 1을 감소시키겠다
// num2 = num2 - 1; 와 같은 의미
System.out.println("변경된 num2: " + num2);
}
public void method2() {
// ++ 기준으로
// 전위 연산: 선 증감 후 처리
int a = 10; // 이 시점에서는 a의 값이 10
int b = ++a; // a의 값이 우선적으로 1 증가 후 b에 대입
System.out.println("a: " + a + ", b: " + b); // a: 11, b: 11
// 후위연산: 선 처리 후 증감
int c = 10; // 이 시점에서는 c의 값이 10
int d = c++; // 우선적으로 d에 c의 값이 대입되고 나서 c가 1 증가
// 후위연산이 보이면 일단 지우고 시작해!
// int d = c; 로 계산한 다음 ++ 살려서 c = c+1 = 11로 생각하기
System.out.println("c: " + c + ", d: " + d); // c: 11, d: 10
}
public void method3() {
int num1 = 20;
int result1 = num1++ * 3;
// 후위연산자니까 지우고 생각해 보면 result1: 60
// 계산 후 후위연산자 살려서 계산하면 num1: 21
System.out.println("num1: " + num1); // 21
System.out.println("result1: " + result1); // 60
int num2 = 20;
int result2 = ++num2 * 3;
// 전위연산자는 가릴 필요 없음! num2: 21
// result2 = 21 * 3 = 63
System.out.println("num2: " + num2); // 21
System.out.println("result2: " + result2); // 63
// 요령: 후위 연산자 같은 경우는 일단 없다 생각하고 처리할 걸 먼저 처리한 다음 살리기!
}
// 퀴즈
public void method4() {
int a = 5;
int b = 10;
int c = (++a) + b;
int d = c / a;
int e = c % a;
int f = e++;
int g = (--b) + (d--);
int h = 2;
int i = a++ + b / (--c / f) * (g-- - d) % (++e + h);
// a = 5; -> 6 -> 7
// b = 10; -> 9
// c = 16; -> 15
// d = 2; -> 1
// e = 4; -> 5 -> 6
// f = 4;
// g = 9 + 2 = 11; -> 10
// h = 2
// i = 6 + 9 / (15 / 4) * (11 - 1) % (6 + 2)
// = 6 + 9 / 3 * 10 % 8
// = 6 + 9 / 3 * 10 % 8
// = 6 + 3 * 10 % 8
// = 6 + 30 % 8
// = 6 + 6
// = 12
System.out.println(a); // 7
System.out.println(b); // 9
System.out.println(c); // 15
System.out.println(d); // 1
System.out.println(e); // 6
System.out.println(f); // 4
System.out.println(g); // 10
System.out.println(h); // 2
System.out.println(i); // 12
}
}
3. 이항 연산자 - 피연산자(연산을 당하는 것)의 수가 2개인 연산자
1) 산술 연산자(사칙 연산)
(1) *, /, %: (차례로) 곱하기, 나누기, 나머지 [우선순위 3]
(2) +, -: (차례로) 더하기, 빼기 [우선순위 4]
*산술 연산자: 이항 연산자로써 연산 방법과 우선 순위가 일반 수학 산술과 동일
[ 종류 ]
+: 덧셈
-: 뺄셈
*: 곱셈
/: 나눗셈 => 나눗셈에서 몫을 구한다
%: 모듈러(Modular,나머지) => 나눗셈에서 나머지를 구한다
package com.kh.operator;
import java.util.Scanner;
// 산술 연산자
public class A_Arithmetic {
public void method1() {
int num1 = 10;
int num2 = 3;
System.out.println("num1 + num2 = " + (num1 + num2));
// 문자열과 int를 연결지어 주는 +와
// 숫자끼리의 산술연산을 해 주는 +의 우선순위가 동일하기 때문에
// 왼쪽에서부터 차례대로 연산이 진행되기 때문에 ()로 실제 산술연산인 +의 우선순위를 높여 줌
// System.out.println("num1 - num2 = " + num1 - num2);
// 문자열 int를 연결지어 주는 +와
// 숫자끼리의 산술연산을 해 주는 -의 우선 순위가 동일하기 때문에
// 문자열 - 숫자 => undefined가 발생한 것
System.out.println("num1 - num2 = " + (num1 - num2));
// 소괄호로 우선순위 매겨 주면 됨
System.out.println("num1 * num2 = " + (num1 * num2));
System.out.println("num1 / num2 = " + (num1 / num2));
System.out.println("num1 % num2 = " + (num1 % num2));
// 곱셈, 나눗셈, 모듈러의 경우 덧셈보다 우선순위가 높기 때문에
// 소괄호() 로 묶지 않아도 정확한 결과가 나옴
// => 다만! 소괄호로 묶는 게 가독성이 좋으므로 권장함
// System.out.println(10 / 0);
// ArithmeticException: / by zero 오류
// 수학과 마찬가지로 프로그래밍 상에서 0으로 나누기는 불가함. 주의!
// System.out.println(10 % 0);
// 나머지를 구할 때도 나눗셈을 해야 하니까 같은 오류 나옴!
//실수일 경우
double a = 35; // 35.0
double b = 10; // 10.0
System.out.println("a + b = " + (a + b)); // 45.0
System.out.println("a - b = " + (a - b)); // 25.0
System.out.println("a * b = " + (a * b)); // 350.0
System.out.println("a / b = " + (a / b)); // 3.5
System.out.println("a % b = " + (a % b)); // 5.0
// 실수끼리의 실행 결과는 실수
}
// 응용문제
public void method2() {
/*
* 인원 수와 사탕의 갯수를 키보드로부터 입력받고
* 1인당 동일하게 나눠 가진 사탕의 개수와
* 남은 사탕의 개수를 출력하세요
*
* 실행 예시
* 인원 수: x
* 사탕 개수: x
*
* 1인당 나눠 가진 사탕 개수: x
* 남는 사탕 개수: x
*
*/
Scanner sc = new Scanner(System.in);
System.out.print("인원 수: ");
int person = sc.nextInt();
sc.nextLine();
System.out.print("사탕 개수: ");
int candy = sc.nextInt();
sc.nextLine();
System.out.println();
// System.out.println("1인당 나눠 가진 사탕 개수: " + (candy / person));
// System.out.println("남는 사탕 개수: " + (candy % person));
System.out.printf("1인당 나눠 가질 사탕 개수: %d \n", (candy / person));
System.out.printf("남는 사탕 개수: %d \n", (candy % person));
}
}
2) 쉬프트 연산자(>>, <<, >>> 한 칸씩 당겨 주세요~ 두 칸씩 당겨 주세요~ / 웹에서 잘 안 씀) [우선순위 5]
3) 비교 연산자
(1) >, <, >=, <=: (차례로) 크다, 작다, 크거나 같다, 작거나 같다 [우선순위 6]
(2) ==, !=: (차례로) 같다, 같지 않다 [우선순위 7]
*비교 연산자(관계 연산자): 이항 연산자로써 두 개의 값을 가지고 비교
비교 연산한 결과가 참일 경우 true / 거짓일 경우 false
=> 후에 특정 조건을 제시할 수 있는 "조건문"에서 많이 쓰일 예정
크고 작음을 비교 (4가지)
* a < b: a가 b보다 작습니까?
* a > b: a가 b보다 큽니까?
* a <= b: a가 b보다 작거나 같습니까?
* a >= b: a가 b보다 크거나 같습니까?
*
* 일치함을 비교 (2가지)
* a == b: a와 b가 일치합니까?
* a != b: a와 b가 일치하지 않습니까?
package com.kh.operator;
// 비교 연산자
public class E_Comparison {
public void method1() {
int a = 10;
int b = 25;
System.out.println("a > b: " + (a > b)); // a = 10, b = 25
// 비교 연산보다 산술연산이 우선순위가 더 크기 때문에
// (a > b) 부분은 괄호로 묶어서 우선순위를 더 높여 줘야 한다
System.out.println("a <= b: " + (a <= b));
boolean result1 = (a == b); // false
System.out.println("result1: " + result1);
boolean result2 = (a != b); // true
System.out.println("result2: " + result2);
// 산술연산 + 비교연산 => 우선 순위에 의해서 산술연산이 먼저 진행되고 마지막으로 비교가 이루어짐
System.out.println("a - b < 0: " + (a - b < 0)); // true
// 예시1) 어떤 수가 있을 때 양수 / 음수임을 판별
// => 양수: 0보다 큰 수
// => 음수: 0보다 작은 수
// => 0: 양수도 음수도 아님! 그냥 0
// 예시2) 어떤 수가 있을 때 짝수 / 홀수임을 판별
// => 짝수: 2로 나누어 떨어지는 수 (== 2로 나눈 나머지가 0)
// => 홀수: 2로 나누어지지 않는 수 (== 2로 나눈 나머지가 1)
System.out.println("a가 짝수입니까?: " + (a % 2 == 0));
System.out.println("b가 짝수입니까?: " + (b % 2 == 0));
// 예시3) 어떤 수가 있을 때 n의 배수임을 판별
// => n의 배수: 어떤 수를 n으로 나누었을 때 나머지가 0인 경우
System.out.println("a는 5의 배수입니까? " + (a % 5 == 0));
System.out.println("b는 a의 배수입니까? " + (b % a == 0));
}
// 실습 문제
public void method2() {
/*
* 사용자로부터 키보드로 정수값 1개를 입력 받고
* 양수인지, 짝수인지 판별해 보세요
*
* 실행 예시
* 정수값 1개 입력: x
*
* 사용자가 입력한 값이 양수입니까?: xxx
* 사용자가 입력한 값이 짝수입니까?: xxx
*/
Scanner sc = new Scanner(System.in);
// java.util.Scanner sc = new java.util.Scanner(System.in);
// 이렇게 쓰면 import 구문 필요 없음!
System.out.print("정수값 1개 입력: ");
int num = sc.nextInt();
sc.nextLine();
System.out.println();
System.out.println("사용자가 입력한 값이 양수입니까?: " + (num > 0));
System.out.println("사용자가 입력한 값이 짝수 입니까?: " + (num % 2 == 0));
// 사용자가 입력한 값이 양수이고 그리고 짝수입니까?
}
}
*논리 연산자: 이항 연산자로써 두 개의 논리값을 연산하는 연산자
즉, 논리값끼리 연산이 이루어지고 그 연산값도 논리값
[ 종류 ]
AND 연산자: 논리값 && 논리값
왼쪽, 오른쪽 둘 다 논리값이 true여야지만 최종 결과가 true
~이고, 그리고, ~이면서, ...
OR 연산자: 논리값 || 논리값 (||는 shift + 원화 표시)
왼쪽, 오른쪽 중에 하나라도 값이 true라면 최종 결과가 true
~ 또는, ~ 혹은, ~이거나, ...
public void method1() {
Scanner sc = new Scanner(System.in);
System.out.print("정수값 한 개 입력: ");
int num = sc.nextInt();
sc.nextLine();
// boolean result1 = num > 0;
// boolean result2 = num % 2 == 0;
boolean result = (num > 0) && (num % 2 == 0);
// &&의 의미: ~ 이면서, ~ 그리고, ~ 이고
// System.out.println("사용자가 입력한 값이 양수이면서 짝수입니까?: " + (result1 && result2));
System.out.println("사용자가 입력한 값이 양수이면서 짝수입니까?: " + result);
}
public void method2() {
// 사용자가 입력한 정수값이 1 이상 100 이하의 수인지 확인하지
Scanner sc = new Scanner(System.in);
System.out.print("정수값 한 개 입력: ");
int num = sc.nextInt();
sc.nextLine();
// 이상, 이하 => 해당 범위를 포함하는 개념
// 미만, 초과 => 해당 범위를 포함하지 않는 개념
// num 에 담긴 수가 1 이상 100 이하
// 1 <= num <= 100 자바에서는 이게 허용이 안 됨! <=, >=가 이항 연산자라서!
// 1 <= num 한 개, num <= 100 한 개로 쪼개서 표현해야 함
// num에 담긴 수가 1보다 크거나 같습니까?
// 그리고
// num에 담긴 수가 100보다 작거나 같습니까?
boolean result = (1 <= num) && (num <= 100);
System.out.println("사용자가 입력한 값이 1 이상 100 이하입니까?: " + result);
}
public void method3() {
Scanner sc = new Scanner(System.in);
System.out.print("계속하시려면 y 또는 Y를 입력하세요: ");
char ch = sc.nextLine().charAt(0);
boolean result = (ch == 'y')|| (ch == 'Y');
// ||: 또는, ~이거나
System.out.println("사용자가 입력한 값이 y 또는 Y입니까?: " + result);
}
public void method4() {
/*
* *논리 연산자의 경우의 수
* &&: 두 개의 조건이 모두 true여야 결과값이 true (AND의 의미)
* true && true == true
* true && false == false
* false && true == false
* false && false == false
* ||: 두 개의 조건 중 하나라도 true일 경우 결과값이 true (OR의 의미)
* true || true == true
* true || false == true
* false || true == true
* false || false == false
*/
int num1 = 10;
boolean result1 = false && (num1 > 0); // false
// 노란 밑줄: 경고, 실행 시 오류는 나지 않지만 추후에 문제가 생길 여지가 있는 상태
// (num1 > 0)은 Dead code
// 컴퓨터의 입장에서 false && 이후로는 계산할 필요가 없음 == 어차피 결과는 false이기 때문에
// 뒤의 코드를 굳이 왜 작성했는지 알려 주는 경고
System.out.println("result1: " + result1);
boolean result2 = true || (num1 > 0); // true
// => true || 까지만 연산을 해 버려도 어차피 결과는 true이기 때문에 Dead code 발생
System.out.println("result2: " + result2);
}
}
*삼항 연산자: 3개의 항목을 가지고 연산하는 연산자
[ 표현법 ]
조건식 ? 조건식이true일경우의결과값 : 조건식이false일경우의결과값
조건식: 연산의 결과가 true 아니면 false로 나오는 식
public void method1() {
// 사용자가 입력한 정수값이 양수인지 아닌지 판별 후에 그에 맞는 결과를 출력
Scanner sc = new Scanner(System.in);
System.out.print("정수값 입력: ");
int num = sc.nextInt();
sc.nextLine();
// String result = 조건식 ? true일경우원하는값 : false일경우원하는값
String result = (num > 0) ? "양수입니다." : "양수가 아닙니다.";
// x은 양수입니다.
// System.out.println(num + "은 " + result);
//System.out.println(num + "은 " + ((num > 0) ? "양수입니다." : "양수가 아닙니다."));
// 산술연산이 삼항연산보다 우선순위가 높으므로
// 삼한 연산 부분의 우선순위를 높여 줘야 한다.
System.out.println(num + "은 " + ((num <= 0) ? "양수가 아닙니다." : "양수입니다."));
// 결론적으로 같은 결과를 출력하지만
// 조건에 따라서 참 거짓 결과가 다르므로 : 기준으로 왼쪽과 오른쪽에 내용이 다를 수도 있다.
}
public void method2() {
// 사용자가 입력한 정수값이 짝수인지 홀수인지 판별 후 결과를 출력
Scanner sc = new Scanner(System.in);
System.out.print("정수값 입력: ");
int num = sc.nextInt();
sc.nextLine();
// String result = (num % 2 == 0) ? "짝수입니다." : "홀수입니다.";
String result = (num % 2 == 1) ? "홀수입니다." : "짝수입니다.";
System.out.printf("%d은 %s \n", num, result);
}
public void method3() {
// 사용자로부터 영문자 하나를 입력받아서 대문자인지 대문자가 아닌지 판별 후 결과 출력
Scanner sc = new Scanner(System.in);
System.out.print("영문자 한 문자 입력: ");
char ch = sc.nextLine().charAt(0);
// String result = (ch >= 65 && ch <= 90) ? "대문자입니다." : "대문자가 아닙니다.";
String result = ((ch >= 'A') && (ch <= 'Z')) ? "대문자입니다." : "대문자가 아닙니다.";
//System.out.println("영문자는 " + result);
System.out.printf("%c는 %s", ch, result);
}
public void method4() {
// method1의 내용 보완
// 사용자가 입력한 정수값이 양수인지, 0인지, 음수인지 판별 후 그에 맞는 결과를 출력
Scanner sc = new Scanner(System.in);
System.out.print("정수값 입력: ");
int num = sc.nextInt();
sc.nextLine();
// 삼항연산자 특) true 아니면 false일 경우 두 가지만 제공
// String result = (조건식) ? true일경우 : ((조건식) ? true일경우 : false일경우);
String result = (num > 0) ? "양수입니다." : ((num == 0) ? "0입니다." : "음수입니다.");
System.out.println(result);
// 내가 표현하고 싶은 경우의 수가 3개 이상일 경우에는
// 삼항연산자 안에 삼항연산자를 중첩해서 사용할 수 있음!!!
}
// 실습 문제
public void method5() {
/* 사용자로부터 나이를 입력받아서
* 나이가 13세 이하면 "어린이입니다."
* 나이가 19세 미만이면 "청소년입니다."
* 나이가 19세 이상이면 "성인입니다."
*
* 를 출력하세요
*/
Scanner sc = new Scanner(System.in);
System.out.print("나이를 입력하세요: ");
int age = sc.nextInt();
sc.nextLine();
String result = (age <= 13) ? "어린이입니다." : ((age > 18) ? "성인입니다." : "청소년입니다.");
System.out.println(result);
}
}
4) 논리 연산자
(1) 비트 논리 연산자 (웹에서 잘 안 씀)
&: and 연산 [우선순위 8]
^: xor 연산 [우선순위 9]
||: or 연산 [우선순위 10]
(2) 일반 논리 연산자
&&: 앤드 [우선순위 11]
||: 오아 [우선순위 12]
*논리 부정 연산자: 단항 연산자로써 논리값(true / false) 를 반대로 바꿔 주는 연산자
[ 표현법 ]
!논리값
package com.kh.operator;
// 논리 부정 연산자
public class D_LogicalNegation {
public void method() {
System.out.println("true의 부정: " + !true);
System.out.println("false의 부정: " + !false);
boolean b = true;
boolean b2 = !b;
// b2에는 false가 들어 있을 것임
// b에는 원본 true가 있을지, false로 바뀌어 대입되어 있을지 궁금해
System.out.println("b: " + b);
System.out.println("b2 = " + b2);
// 논리 부정 연산자는 연산 결과를 다시 자기자신에게 대입하지 않음
System.out.println(!(3 + 5 < 1));
}
}
4. 삼항 연산자
(조건식) ? 참일때 사용 값: 거짓일 때 사용 값 [우선순위 13]
5. 대입 연산자
1) 순수 대입
(1) = : 대입
2) 복합 대입 [우선순위 14]
(1) 산술 대입
+=, -=, *=, /=, %=:
복합 대입 연산자: 산술 연산자와 대입 연산자를 함께 사용하는 연산자
[ 종류 ]
+=
-=
*=
/=
%=
=> 해당 산술 연산 진행 후에 자기 자신한테 대입하겠다
ex) a = a + 3;
a += 3;
package com.kh.operator;
// 복합 대입 연산자
public class C_Compound {
public void method() {
int num = 12;
System.out.println("현재 num: " + num);
// num을 3 증가시키기
num = num + 3;
System.out.println("3 증가시킨 num: " + num);
// num을 3 증가시키기
num += 3;
System.out.println("또 3 증가시킨 num: " + num);
// num을 5 감소시키기
num -= 5; // num = num - 5;
System.out.println("5 감소시킨 num: " + num);
// num을 6배 증가시키기
num *= 6; // num = num * 6;
System.out.println("6배 증가시킨 num: " + num);
// num을 2배 감소시키기
num /= 2; // num = num / 2
System.out.println("2배 감소시킨 num: " + num);
// num을 4로 나눴을 때의 나머지
num %= 4; // num = num % 4
System.out.println("최종 num: " + num );
// +: 숫자끼리 연산하면 덧셈, 문자열과 다른 타입끼리 연산하면 접합(한 개의 문자열로 연이어짐)
// +=: 문자열에도 적용 가능
String str = "Hello";
str += " World"; // str = str + " World";
System.out.println(str);
}
}
(2) 쉬프트 대입
<<=, >>=, >>>=:
(3) 비트 논리 대입
&=, ^=, |, =:
5. 나열 연산자 [우선순위 15]
, : printf 빵꾸 채울 때 등