1.  연산자의 우선순위와 결합규칙

  👩🏻‍🚀  산술 > 비교 > 논리 > 대입 (제일 마지막에 수행)

  👩🏻‍🚀  단항 > 이항 > 삼항

 

    ⚡️  단항 연산자와 대입 연산자를 제외한 모든 연산의 진행방향은 왼쪽에서 오른쪽

              ➡️ 오른쪽에서 왼쪽으로 연산을 수행


2.  단항 연산자

(1) 증감 연산자

 

    ① 증가 연산자 (++) 피연산자의 값을 1 증가

    ② 감소 연산자 (--)  피연산자의 값을 1 감소

      ⚡️  전위형 : ++a  <증가 후 출력>

      ⚡️  후위형 : a++  <출력 후 증가>

            ** 단독으로 쓰이는 경우엔 전위나 후위 결과값 같음!!


  
public class MyOper_12 {
public static void main(String[] args) {
int i = 5, j = 5;
System.out.println(i++); // 5. 출력 후 증가
System.out.println(++j); // 6. 증가 후 출력
System.out.println("i = " + i + ", j = " +j); // 6 6 실행 후에는 동일한 값
}
}


  
public class Exam007 {
public static void main(String[] args) {
int a = 1;
System.out.println(a); // 1
a++; // a = a + 1;
System.out.println(a); // 2
System.out.println(++a); // 3
System.out.println(a++); // 3
System.out.println(a); // 4
}
}

 


3.  대입 연산자

  ✏️  변수와 같은 저장공간에 '값 또는 수식의 연산결과'를 저장하는데 사용됨

  ✏️  오른쪽 피연산자의 값을 왼쪽 피연산자에 저장

💡 복합 대입 연산자
    * a = a + 2  ▶️  a += 2  (덧셈)
    * a = a - 3   ▶️  a -= 3   (뺄셈)
    * a = a / 2    ▶️  a /= 2   (나눗셈)
    * a = a * 3   ▶️  a *= 3   (곱셈)

  
public class Exam013 {
public static void main(String[] args) {
int a = 3;
int b = 5;
System.out.println(b); // 5
b = a; // copy
System.out.println(b); // 3
System.out.println(a); // 3
a += 1; // a = a + 1
System.out.println(a); // 4
a /= 2; // a = a / 2
System.out.println(a); // 2
a *= a; // a = a * a
System.out.println(a); // 4
}
}

 


4.  비교 연산자

  ✏️  주로 조건문과 반복문의 조건식에 사용되며 연산결과는 오직 true 와 false 둘 중 하나

  1) 대소비교 연산자 ( <, >, <=, >= )

비교연산자
연산결과
>
좌변 값이 크면 true 아니면 false
<
좌변 값이 작으면 true 아니면 false
>=
좌변 값이 크거나 같으면 true 아니면 false
<=
좌변 값이 작거나 같으면 true 아니면 false

  
public class Exam008 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b); // t
System.out.println(a > b); // f
System.out.println(a + b <= c); // 산술연산자가 비교연산자 보다 먼저 실행. t
System.out.println(a + b >= c); // t
}
}

 

  2) 등가비교 연산자 (==, !=)

 

 

비교연산자
연산결과
==
두 값이 같으면 true 아니면 false
!=
두 값이 다르면 true 아니면 false

  
public class Exam009 {
public static void main(String[] args) {
double a = 3.14;
double b = 5.14;
System.out.println(a == b); // false
System.out.println(a != b); // true
/* 문자열의 경우 equals() 메서드를 이용해서 값을 비교 */
String c1 = "Hello JAVA!";
System.out.println(c1.equals("Hello java!")); // false
System.out.println(c1.equals("Hello JAVA!")); // true
}
}

 


5.  논리 연산자 

  ✏️  || (OR 결합) : 피연산자 중 어느 한 쪽만 true이면 true를 결과로 얻는다

  ✏️  && (AND결합) : 피연산자 양쪽 모두 true이어야 true를 결과로 얻는다


  
public class MyOper_21 {
public static void main(String[] args) {
// 논리곱
System.out.println(true && true); // true 1 * 1 = 1
System.out.println(true && false);// false 1 * 0 = 0
System.out.println(false && true); // false 0 * 1 = 0
System.out.println(false && false); // false 0 * 0 = 0
// 논리합
System.out.println(true || true); // true 1 + 1 = 2
System.out.println(true || false); // true 1 + 0 = 1
System.out.println(false || true); // true 0 + 1 = 1
System.out.println(false || false); // false 0 + 0 = 0
}
}


  
public class Exam010 {
public static void main(String[] args) {
/* 논리 연산자
* 2항 연산자이고, 항은 boolean 값이고 결과도 boolean
*/
int a = 10;
// 비교연산자가 논리연산자 보다 먼저 실행
System.out.println(5 < a && a < 15); // true -> true && true
System.out.println((5 < a && a < 15) && a % 2 == 0); // true -> true && true
a = 4;
System.out.println((5 < a && a < 15) && a % 2 == 0); // false -> false && true
System.out.println((5 < a && a < 15) || a % 2 == 0); // true -> false || true
}
}

 


6.  삼항 연산자

a ? b : c

 

    - a 값이 true면 b, false면 c 결과 값이 도출

 


  
import java.util.Scanner;
public class Exam012 {
public static void main(String[] args) {
int age = 20;
System.out.println(age > 19 ? "성인입니다" : "청소년입니다");
// 성인입니다
Scanner scanner = new Scanner(System.in);
// 같은 줄에서 입력을 받기 위해 prinln() 대신 print() 사용.
System.out.print("나이를 입력하세요: ");
int age1 = scanner.nextInt();
System.out.println(age1 > 20 ? "성인입니다" : "청소년입니다" );
scanner.close();
}
}

 

 


💡  키보드 입력 데이터 변수에 저장하는 방법
       Scanner scanner = new Scanner(System.in);
         ➡️  생성된 scanner 객체를 변수에 대입
       int 변수명 = scanner.nextInt();  /  String 변수명 = scanner.nextLine();
         ➡️  입력된 문자열을 변수에 대입

    ** nextLine()메소드는 Enter를 치기 전까지 쓴 문자열을 모두 리턴
         next() 메소드는 스페이스 즉 공백 전까지 입력받은 문자열을 리턴

       (
출처: https://deftkang.tistory.com/55 [deftkang의 IT 블로그:티스토리])

 


  
import java.util.Scanner;
public class InputString {
public static void main(String[] args) {
String name;
int age;
Scanner scanner = new Scanner(System.in);
System.out.print("이름을 입력하시오: ");
name = scanner.nextLine(); // 문자열 입력
System.out.println("나이를 입력하시오: ");
age = scanner.nextInt(); // 정수 입력
System.out.println(name + "님 안녕하세요! " + age + "살이시네요.");
scanner.close();
}
}

 

사용자로부터 숫자를 입력받아 cm를 inch 단위로 변환하여 출력하는 프로그램
    * 1cm는 0.393701 inch로 반환
    * 예) cm 단위의 숫자를 입력해주세요. * 입력 > 24 * 24cm는 9.448824 inch 입니다. 

  
import java.util.Scanner;
public class Ex_07 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int cm;
double inch;
System.out.print("cm 단위의 숫자를 입력해주세요. ");
System.out.print("입력 > ");
cm = scanner.nextInt();
inch = cm * 0.393701;
System.out.println(cm + "cm는 " + inch + "inch 입니다.");
scanner.close();
}
}

사용자로부터 숫자를 입력받아 달러를 원으로 변환하여 출력하는 프로그램
    * 1달러는 1289.50원으로 반환
    * 예) 달러 단위의 금액을 입력해주세요.  입력 > 24  -> 원화 : 30948.0 

  
import java.util.Scanner;
public class Ex_08 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int dollar;
double won;
System.out.print("달러 단위의 금액을 입력해주세요. ");
System.out.print("입력 > ");
dollar = scanner.nextInt();
won = dollar * 1289.50;
System.out.println("-> 원화 : " + won );
scanner.close();
}
}

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 자바의 정석 3rd ]


1.  형변환 Casting

· 변수 또는 상수의 타입을 다른 타입으로 변환하는 것

· 형변환 방법 ; (타입)피연산자

· float 타입의 값을 int 타입으로 변환할 때 소수점 이하의 값은 버림으로 처리됨

 

    ⚡️  자동 형변환 : 값의 범위가 작은 타입에서 큰 타입으로의 형변환은 생략가능

    ⚡️  명시적 형변환 : 변수의 자료형을 강제로 바꾸는 것 ▶️ 숫자크기 상관없이 앞에 형변환 해줘야 함

 
<기본형의 자동 형변환이 가능한 방향>

 


  
public class Etc0208 {
public static void main(String[] args) {
byte b = 10;
int i = b;
System.out.println("i=" + i); // 10
System.out.println("b=" + b); // 10
int i2 = 10;
byte b2 = (byte)i2;
System.out.println("i2=" + i2); // 10
System.out.println("b2=" + b2); // 10
}
}

 


  
public class Exma001 {
public static void main(String[] args) {
byte a = 127; // byte가 가질 수 있는 최대값
int b = a; // 자동 형변환 (byte -> int)
System.out.println(b); // 127
float c = b; // 자동형변환 (int -> float) 값손실이 없기 때문.
System.out.println(c); // 127.0
//int d = c; // float 자료형을 int 변수에 대입하면 자동형변환이 안됨.
}
}

 


문자열을 기본 타입으로 강제 타입 변환


  📌  String은 int나 char처럼 기본 자료 타입이 아닌 클래스의 객체 형태라서 일반적인 형변환과 다름


  
public class MyVar_09 {
public static void main(String[] args) {
String str = "1a";
//int value = Integer.parseInt(str); // 문자열에 숫자외의 문자가 있으면 변환이 되지 않음
// String -> byte
String str1 = "10";
byte value1 = Byte.parseByte(str1);
System.out.println(value1); // 10
// String -> short
String str2 = "200";
short value2 = Short.parseShort(str2);
System.out.println(value2); // 200
// String -> int
String str3 = "300000";
int value3 = Integer.parseInt(str3);
System.out.println(value3); // 300000
// String -> long
String str4 = "400000000";
long value4 = Long.parseLong(str4);
System.out.println(value4); // 400000000
// String -> float
String str5 = "12.345";
float value5 = Float.parseFloat(str5);
System.out.println(value5); // 12.345
// String -> double
String str6 = "12.345";
double value6 = Double.parseDouble(str6);
System.out.println(value6); // 12.345
// String -> boolean
String str7 = "true";
boolean value7 = Boolean.parseBoolean(str7);
System.out.println(value7); // true
}
}

 


기본 타입과 문자열 간의 변환


  📌  기본 타입의 값을 문자열로 변경하는 경우에는 String.valueOf() 메소드를 이용


  
String str = String.valueOf(기본타입값);

  
public class MyVar_10 {
public static void main(String[] args) {
// 문자열을 기본 타입으로 변환
int value1 = Integer.parseInt("10");
double value2 = Double.parseDouble("3.14");
boolean value3 = Boolean.parseBoolean("true");
System.out.println("value1 : " + value1); // value1 : 10
System.out.println("value2 : " + value2); // value2 : 3.14
System.out.println("value3 : " + value3); // value3 : true
// 기본 타입을 문자열로 변환
String str1 = String.valueOf(10);
String str2 = String.valueOf(3.14);
String str3 = String.valueOf(false);
System.out.println("str1 : " + str1); // str1 : 10
System.out.println("str2 : " + str2); // str2 : 3.14
System.out.println("str3 : " + str3); // str3 : false
}
}

 


연습 문제

 

   📌  'int result = '에 1) 변수 4개를 모두 사용하고 2) 사칙연산중 + 연산만 사용해서 9가 나오도록 코드를 완성


  
public class Ex_01 {
public static void main(String[] args) {
long var1 = 2L;
float var2 = 1.8f;
double var3 = 2.5;
String var4 = "3.9";
int result = (int)var1 + (int)(var2 + var3) + (int)Double.parseDouble(var4);
// 이 부분만 수정. 0대신 코드 입력.
System.out.println(result); // 9
}
}

 


2.  연산자  Operator

 

· 연산자 : 연산을 수행하는 기호

· 피연산자(operand) : 연산자의 작업 대상 (변수, 상수, 리터럴, 수식)

· 단항 연산자의 우선순위가 이항 연산자보다 높다.

· 단항 연산자와 대입 연산자를 제외한 모든 연산의 진행방향은 왼쪽에서 오른쪽

 

 

(1)  산술 연산자

 

    a) 사칙 연산자 :  +(덧셈), -(뺄셈), *(곱셈), /(나눗셈)

    b) 나머지 연산자 :  %  ▶️ a를 b로 나눈 후 나머지를 반환, 주로 짝수 홀수 구분에 사용


  
public class Exam004 {
public static void main(String[] args) {
int num1 = 10; // 10을 대입
int num2 = 3; // 3을 대입
System.out.println(num1 + num2); // 13
System.out.println(num1 - num2); // 7
System.out.println(num1 * num2); // 30
System.out.println(num1 / num2); // 3
System.out.println(num1 % num2); // 1
System.out.println(num1 % 2); // 0
System.out.println(num2 % 2); // 1
}
}

 


 

(2) 논리부정 연산자 : !

 

    -  피연산자가 true이면 false를, false면 true를 결과로 반환


  
public class Exam006 {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
boolean c = !b; // b의 값을 반대로 바꾸어 입력
System.out.println(a); // true
System.out.println(!a); // false
System.out.println(b); // false
System.out.println(c); // true
}
}

 


(3) 정수와 실수 연산

 

    - 정수와 정수의 연산의 결과 값은 정수. 정수와 실수 연산의 결과 값은 실수 


  
public class MyVar_11 {
public static void main(String[] args) {
byte kor, math, eng;
kor = 55;
math = 99;
eng = 87;
int sum = kor + math + eng;
System.out.println("총점 : " + sum); // 총점 : 241
int avg_01 = sum /3;
System.out.println("평균 : " + avg_01); // 평균 : 80
double avg_02 = sum /3; // 정수 / 정수
System.out.println("평균 : " + avg_02); // 평균 : 80.0 -> 정수 연산으로 정수 값이 나온 후에 실수에 저장.
double avg_03 = (double)sum / 3; // 실수 / 정수
System.out.println("평균 : " + avg_03); // 평균 : 80.33333333333333
double avg_04 = sum / 3.0; // 정수 / 실수
System.out.println("평균 : " + avg_04); // 평균 : 80.33333333333333
double avg_05 = (double)sum / 3.0; // 실수 / 실수
System.out.println("평균 : " + avg_05); // 평균 : 80.33333333333333
}
}

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 자바의 정석 3rd ]


 

1.  산술 연산자

종류 설명 예시
+ 두 피연산자의 값을 더함  c = a + b
- 첫 번째 피연산자 값에서 두 번째 피연산자 값을 뺌  c = a - b 
* 두 피연산자의 값을 곱함  c = a * b
/ 첫 번째 피연산자 값을 두 번째 피연산자 값으로 나눔  c = a / b
% 첫 번째 피연산자 값을 두 번째 피연산자 값으로 나눈 나머지를 구함  c = a % b
++ 피연산자를 1 증가  a++ / ++a 
-- 피연산자를 1 감소  b-- / --b

 

+, -, * , /  연산 예시

  
<script>
const num1 = 20;
const num2 = 10;
const score1 = num1 + num2;
const score2 = num1 - num2;
const score3 = num1 * num2;
const score4 = num1 / num2;
console.log(score1 + ',' + score2 + ',' + score3 + ',' + score4);
// 30, 10, 200, 2
</script>

 

% 연산 예시

  
<script>
const evenOdd = 2;
const result = evenOdd % 2;
let comment; // const는 선언과 동시에 초기화 해야 함
if (result === 0) {
comment = evenOdd + '는(은) "짝수" 입니다.';
}else {
comment = evenOdd + '는(은) "홀수" 입니다.';
}
console.log(comment); // 2는(은) "짝수" 입니다.
// 삼항 연산자를 사용하면 선언과 동시에 초기화 가능
const comment2 = (result === 0) ? evenOdd +'는(은) "짝수" 입니다.'
: evenOdd + '는(은) "홀수" 입니다.';
console.log(comment2); // 2는(은) "짝수" 입니다.
</script>

 

💡 증감 연산자
a++  : 기존의 변수 값에 1을 더함. 후위.
++a  : 기존의 변수 값에 1을 더함. 전위.
a--   : 기존의 변수 값에 1을 뺌. 후위.
--a   : 기존의 변수 값에 1을 뺌. 전위.

  
<script>
let num1 = 10;
num1++;
document.write(num1); // 11
// 후위 : 해당 문장을 실행한 후 값을 더함.
let num2 = 10;
document.write(num2++); // 10
document.write(num2++); // 11
// 전위 : 값을 더한 후 해당 문장을 실행
let num3 = 10;
document.write(++num3); // 11
document.write(++num3); // 12
</script>

 


  
<script>
/* 응용 예시 */
var increase = 0;
var add = 0;
++increase;
console.log(increase); // 1
increase++;
console.log(increase); // 2
add = ++increase; // 3
console.log(add + ',' + increase); // 3, 3
add = increase++;
console.log(add + ',' + increase); // 3, 4
</script>

 


2.  복합대입연산자

✏️  대입 연산자(=)와 다른 연산자를 함께 사용하는 연산자

종류 설명
= 연산자 오른쪽의 값을 왼쪽 변수에 할당
+= a += 1  ▶️  a = a + 1
-= a -= 1  ▶️  a = a - 1
*= a *= 1  ▶️  a = a * 1
/= a /= 1  ▶️  a = a / 1
%= a %= 1  ▶️  a = a % 1

 


  
<script>
let value = 10;
value += 10; // value = value + 10;
document.write(value); // 20
// 복합 대입 연산자를 사용해서 문자열을 조합
let list = '';
list += '<ul>';
list += ' <li>Hello</li>';
list += ' <li>javaScript..!</li>';
list += '</ul>';
document.write(list);
</script>


3.  비교 연산자

종류 설명 예시
조건식 결과값
== 피연산자가 서로 같으면 true 3 == "3" true
=== 피연산자도 같고 자료형도 같으면 true a === "3" false
!= 피연산자가 서로 같지 않으면 true 3 != "3" false
!== 피연산자가 같지 않거나 자료형이 같지 않으면 true 3 !== "3" true
< 왼쪽 피연산자가 오른쪽 피연산자보다 작으면 true 3 < 4 true
<= 왼쪽 피연산자가 오른쪽 피연산자보다 작거나 같으면 true 3 <= 4 true
> 왼쪽 피연산자가 오른쪽 피연산자보다 크면 true 3 > 4 false
>= 왼쪽 피연산자가 오른쪽 피연산자보다 크거나 같으면 true 3 >= 4 false

  
<script>
const comparison1 = (5 > 2);
console.log(comparison1); // true
const comparison2 = (5 < 2);
console.log(comparison2); // false
const comparison3 = (5 == 5);
console.log(comparison3); // true
const comparison4 = (5 == '5');
console.log(comparison4); // true
const comparison5 = (5 === '5');
console.log(comparison5); // false
const comparison6 = (5 != '5');
console.log(comparison6); // false
const comparison7 = (5 !== '5');
console.log(comparison7); // true
const comparison8 = (5 === Number('5'));
console.log(comparison8); // true
</script>

 

💡  문자열 비교
    -  비교 연산자는 숫자뿐만 아니라 문자열도 서로 비교 가능
    -  문자들의 아스키 ASCII 값을 비교해서 결정
    -  대문자 < 소문자  / 내림차순 값이 더 크다

 


4.  논리 연산자

✏️  boolean 연산자라고도 하며 true, false를 처리하는 연산자

종류 기호 설명
OR 연산자 || 피연산자 중 하나면 true여도 true
AND 연산자 && 피연산자가 모두 true일 경우에만 true
NOT 연산자 ! 피연산자의 반댓값을 지정

 


  
<script>
let logic1, logic2, logic3, logic4, logic5, logic6;
logic1 = (3 > 2) && (5 > 3);
console.log(logic1); // true
logic2 = (3 < 2) && (5 > 3);
console.log(logic2); // false
logic3 = (3 > 2) || (5 > 3);
console.log(logic3); // true
logic4 = (3 < 2) || (5 < 3);
console.log(logic4); // false
logic5 = !(3 < 2);
console.log(logic5); // true
logic6 = !(3 > 2);
console.log(logic6); // false
</script>

 


 

5.  삼항 연산자

 

✏️  조건식의 결과(true, false)에 따라 결과 값을 다르게 나오게 해주는 연산자
✏️  형식 [ 조건식 ? 실행문1 : 실행문2; ]
✏️  조건식이 true 일 때는 실행문1, false 일 때는 실행문2가 실행됨


  
<script>
let num1 = 10;
let num2 = -10;
console.log(num1 > 0 ? '양수' : '음수'); // 양수
console.log(num2 > 0 ? '양수' : '음수'); // 음수
let num3 = 31;
let type = num3 % 2 === 0 ? '짝수' : '홀수';
console.log(`${num3}${type}입니다.`); // 31는 홀수입니다.
// 템플릿 문자열을 사용해서 직접 코드를 넣는 방법도 추천
let num4 = 32;
console.log(`${num4}${num4 % 2 === 0 ? '짝수' : '홀수'}입니다.`); // 32는 짝수입니다.
// 숫자 0은 false, 나머지 숫자는 true.
console.log(`${num4}${num4 % 2 ? '홀수' : '짝수'}입니다.`); // 32는 짝수입니다.
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

 

+ Recent posts