πŸ—„οΈ Backend/Java

μžλ°”(Java) - μ—°μ‚°μž

kongmi 2023. 1. 3. 20:30

μžλ°” μ—°μ‚°μž

μ‚°μˆ  +, -, *, /, % 이항 숫자 사칙연산과 λ‚˜λ¨Έμ§€
λΆ€ν˜Έ +, - 단항 숫자 μŒμˆ˜μ™€ μ–‘μˆ˜ ν‘œμ‹œ
λ¬Έμžμ—΄ + 이항 λ¬Έμžμ—΄ 두 λ¬Έμžμ—΄μ„ μ—°κ²°
λŒ€μž… =, +=, -=, *=, /=, %= 이항 λ‹€μ–‘ μš°λ³€μ˜ 값을 μ’Œλ³€μ— λŒ€μž…
증감 ++, — 단항 숫자 1만큼 증가/κ°μ†Œ
비ꡐ ==, ≠, <, >, ≥, ≤, instanceof 이항 boolean κ°’μ˜ 비ꡐ
논리 !, &, , &&,    
쑰건 (쑰건식)?A:B μ‚Όν•­ λ‹€μ–‘ 쑰건식에 따라 A λ˜λŠ” B 쀑 선택

이항 μ—°μ‚°μž

이항 μ—°μ‚°μžλŠ” ν”Όμ—°μ‚°μžκ°€ 두 개인 μ—°μ‚°μž

μ‚°μˆ  μ—°μ‚°μž

사칙연산을 λ‹€λ£¨λŠ” μ—°μ‚°μžλ‘œ κ°€μž₯ κΈ°λ³Έμ μ΄λ©΄μ„œ κ°€μž₯ 많이 μ‚¬μš©λ˜λŠ” μ—°μ‚°μž 쀑 ν•˜λ‚˜

int num1 = 10, num2 = 40;
        System.out.println("+ μ—°μ‚°μž : " + (num1 + num2));
        System.out.println("- μ—°μ‚°μž : " + (num1 - num2));
        System.out.println("* μ—°μ‚°μž : " + (num1 * num2));
        System.out.println("/ μ—°μ‚°μž : " + (num1 / num2)); //λͺ«μ„ ꡬ할 경우
        System.out.println("/ μ—°μ‚°μž : " + ((double)num1 / num2)); //결과값을 ꡬ할 경우, ν˜•λ³€ν™˜
        System.out.println("% μ—°μ‚°μž : " + (num1 % num2));

* Nanκ³Ό Infinity μ—°μ‚°

/λ˜λŠ” % μ—°μ‚°μžλ₯Ό μ‚¬μš© ν•  λ•ŒλŠ” 주의

쒌츑 ν”Όμ—°μ‚°μžκ°€ μ •μˆ˜ νƒ€μž…μΈ 경우 λ‚˜λˆ„λŠ” 수인 우츑 μ—°μ‚°μžλŠ” 0을 μ‚¬μš©ν•  수 μ—†μŒ.

5 / 0.0 → Infinity (λ¬΄ν•œλŒ€)

5 % 0.0 → NaN (Not a Number)

λŒ€μž… μ—°μ‚°μž

λŒ€μž… μ—°μ‚°μžλŠ” λ³€μˆ˜μ— 값을 λŒ€μž…ν•  λ•Œ μ‚¬μš©ν•˜λŠ” μ΄ν•­μ—°μ‚°μžμ΄λ©°, ν”Όμ—°μ‚°μžλ“€μ˜ κ²°ν•© λ°©ν–₯은 였λ₯Έμͺ½μ—μ„œ μ™Όμͺ½

  • 값을 λŒ€μž…ν•˜λŠ” μ—°μ‚°μž (= κ°™λ‹€λŠ” μ˜λ―Έκ°€ μ•„λ‹ˆκ³  λŒ€μž…ν•œλ‹€λŠ” μ˜λ―Έμ— 유의 ν•΄μ•Ό 함)
  • λŒ€μž…μ—°μ‚°μžμ™€ λ‹€λ₯Έ μ—°μ‚°μžλ₯Ό κ²°ν•©ν•˜μ—¬ λ‹€μ–‘ν•œ 볡합 λŒ€μž… μ—°μ‚°μžλ₯Ό 제곡
  • κ°’μ˜ λŒ€μž…μ€ 항상 λ’€μ—μ„œ μ•žμœΌλ‘œ λŒ€μž… ν•œλ‹€.

증감 μ—°μ‚°μž

++ -- : 값을 1증가 ν•˜κ±°λ‚˜ κ°μ†Œ μ‹œν‚€λŠ” μ—°μ‚°μž

μ•žμ— λΆ™μœΌλ©΄ : 증가(κ°μ†Œ)μ‹œν‚€κ³  λŒ€μž…, 뒀에 λΆ™μœΌλ©΄ : λŒ€μž… ν›„ 증가(κ°μ†Œ)

 

int num4 = 10;
        System.out.println(num4++);
        System.out.println(num4);
        System.out.println(++num4);

λΉ„κ΅μ—°μ‚°μž

μ™Όμͺ½μ˜ ν”Όμ—°μ‚°μžμ™€ 였λ₯Έμͺ½μ˜ ν”Όμ—°μ‚°μžλ₯Ό λΉ„κ΅ν•˜μ—¬, μ–΄λŠ μͺ½μ΄ 더 큰지, μž‘μ€μ§€, λ˜λŠ” μ„œλ‘œ 같은지λ₯Ό νŒλ‹¨

이항 μ—°μ‚°μžμ΄λ©°, ν”Όμ—°μ‚°μžλ“€μ˜ κ²°ν•© λ°©ν–₯은 μ™Όμͺ½μ—μ„œ 였λ₯Έμͺ½μž…λ‹ˆλ‹€.

int x = 10, y = 20;
        System.out.println(x > y); //false
        System.out.println(x >= y);
        System.out.println(x < y); //true
        System.out.println(x <= y);
        System.out.println(x == y);
        System.out.println(x != y);

λ…Όλ¦¬μ—°μ‚°μž

  • && : A와 Bκ°€ λͺ¨λ‘ λ§Œμ‘±ν•΄μ•Ό μ°Έ
  • || : OR μ—°μ‚°μžμ΄λ©° Aμ΄κ±°λ‚˜ B, 즉 A와 B쀑 ν•œκ°œλ§Œ λ§Œμ‘±ν•˜λ©΄ 참이 λœλ‹€.
  • ! : NOTμ—°μ‚°μžμ΄λ©°, ν˜„μž¬μ˜ 쑰건을 λΆ€μ •ν•˜λ―€λ‘œ λ°˜λŒ€κ°€ λœλ‹€.
  • λ…Όλ¦¬μ—°μ‚°μžλ§Œ μ“°μ΄λŠ” κ²½μš°λŠ” μ—†μœΌλ©°, 비ꡐ μ—°μ‚°μžμ™€ ν•¨κ»˜ 쓰인닀.
int num5 = 10, num6 = 20;
        boolean rst1, rst2, rst3;
        rst1 = (num5 > num6) && (num5 > 5);
        rst2 = (num5 > num6) || (num5 > 5);
        rst3 = !((num5 > num6) || (num5 > 5));
        System.out.println(rst1);
        System.out.println(rst2);
        System.out.println(rst3);

μ‚Όν•­ μ—°μ‚°μž

ν”Όμ—°μ‚°μžκ°€ 3개..

if ~ else λ¬Έ 보닀 간결함!

Scanner sc = new Scanner(System.in);
        System.out.print("λ‚˜μ΄λ₯Ό μž…λ ₯ν•˜μ„Έμš”. : ");
        int age = sc.nextInt();
        boolean isAdult = (age > 19) ? true : false;
        System.out.println(isAdult);

λ¬Έμžμ—΄ κ²°ν•© μ—°μ‚°μž

λ¬Έμžμ—΄ κ²°ν•© μ—°μ‚°μžμΈ +λŠ” λ¬Έμžμ—΄μ„ μ„œλ‘œ κ²°ν•©ν•˜λŠ” μ—°μ‚°μž μž…λ‹ˆλ‹€.

ν”Όμ—°μ‚°μž 쀑 ν•œμͺ½μ΄ λ¬Έμžμ—΄μ΄λ©΄ + μ—°μ‚°μžλŠ” λ¬Έμžμ—΄μ˜ κ²°ν•© μ—°μ‚°μžλ‘œ μ‚¬μš© λ©λ‹ˆλ‹€.

λΉ„νŠΈμ—°μ‚°μž

  • λΉ„νŠΈ λ‹¨μœ„μ˜ 연산을 의미
  • 1 ByteλŠ” 8개의 bit ꡬ성 (1bitλŠ” 전기적인 μ‹ ν˜Έμ— 따라 ν‘œμ‹œν•  수 μžˆλŠ” 0κ³Ό 1을 의미)
  • ν•˜λ“œμ›¨μ–΄λ₯Ό μ œμ–΄ν•˜κ±°λ‚˜ μ˜μƒμ²˜λ¦¬, μŒμ„±μ²˜λ¦¬λ“±μ— ν™œμš© 될 수 μžˆλ‹€.
  • & (λΉ„νŠΈ AND) : λ‘κ°œμ˜ λΉ„νŠΈλ₯Ό 비ꡐ해 λͺ¨λ‘ 1이면 1
  • |(λΉ„νŠΈ OR) : λ‘κ°œμ˜ λΉ„νŠΈ 쀑 ν•œκ°œλ§Œ 1이면 1
  • ^(XOR) : λ‘κ°œμ˜ λΉ„νŠΈμ˜ 값이 κ°™μœΌλ©΄ 0, λ‹€λ₯΄λ©΄ 1
  • ~(λΉ„νŠΈ NOT) : 0이면 1, 1이면 0으둜 λΉ„νŠΈλ₯Ό λ°˜μ „ μ‹œν‚¨λ‹€.
  • << (μ™Όμͺ½μœΌλ‘œ 이동) : μ§€μ •λœ 수만큼 λΉ„νŠΈλ₯Ό μ™Όμͺ½μœΌλ‘œ 이동
  • (였λ₯Έμͺ½μœΌλ‘œ 이동) : μ§€μ •λœ 수만큼 λΉ„νŠΈλ₯Ό 였λ₯Έμͺ½μœΌλ‘œ 이동
int num1 = 10; // 00001010
        int num2 = 12; // 00001100
        System.out.println(num1 & num2); // 1000 == 8
        System.out.println(num1 | num2); // 1110 == 14
        System.out.println(num1 ^ num2); // 0110 == 6
        System.out.println(~num1); // -11
        System.out.println(num1 << 1); // 00010100 == 20
        System.out.println(num1 >> 1); // 00000101 == 5