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