์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- thymeleaf
- Codeup
- Spring
- Gradle
- ์คํ๋ง
- Postman
- Spring Boot
- Git
- ์ค๋ธ์
- springboot
- ํด๋ฆฐ ์ฝ๋
- ๊ฐ์ฌ์ค
- golang
- ํด๋ฆฐ์ฝ๋
- JPA
- ํ์ด์ฌ
- Vue.js
- ๋กฌ๋ณต
- mariadb
- MySQL
- GitHub
- go
- java
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- H2 ์ค์น
- spring security
- ์๊ณ ๋ฆฌ์ฆ
- ๊ธฐ์ด100์
- ์ฝ๋์
- Python
- Today
- Total
nyximos.log
[Java] ์ฐ์ฐ์ ๋ณธ๋ฌธ
๐ฉ๐ ๋ชฉํ
์๋ฐ๊ฐ ์ ๊ณตํ๋ ๋ค์ํ ์ฐ์ฐ์ ํ์ตํ๊ธฐ
๐ฉ๐ป ํ์ตํ ๊ฒ
- ์ฐ์ ์ฐ์ฐ์
- ๋นํธ ์ฐ์ฐ์
- ๊ด๊ณ ์ฐ์ฐ์
- ๋ ผ๋ฆฌ ์ฐ์ฐ์
- instanceof
- assignment(=) operator
- ํ์ดํ(->) ์ฐ์ฐ์
- 3ํญ ์ฐ์ฐ์
- ์ฐ์ฐ์ ์ฐ์ ์์
- (optional) Java 13. switch ์ฐ์ฐ์
์ฐ์ฐ์๋ ํผ์ฐ์ฐ์๋ค์ ๋ํด ํน์ ์ฐ์ฐ์ ์ํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํน์ ๊ธฐํธ์ด๋ค.
์ฐ์ฐ์๊ฐ ์ฐ์ฐ์ ์ํํ๊ธฐ ์ํด์๋ ๋ฐ๋์ ์ฐ์ฐ์ ๋์์ด ์์ด์ผ ํ๋๋ฐ ์ด๊ฒ์ ํผ์ฐ์ฐ์๋ผ ๋ถ๋ฅธ๋ค.
์ฐ์ฐ์์๋ ์ฐ์ ์ฐ์ฐ์, ๊ด๊ณ ์ฐ์ฐ์, ๋
ผ๋ฆฌ ์ฐ์ฐ์, ๋์
์ฐ์ฐ์, ํ๋ณํ ์ฐ์ฐ์, ์ผํญ ์ฐ์ฐ์, instanceof ์ฐ์ฐ์, ์ฆ๊ฐ ์ฐ์ฐ์, ๋ถํธ ์ฐ์ฐ์ ๋ฑ์ด ์๋ค.
๐์ฐ์ ์ฐ์ฐ์
์ฌ์น ์ฐ์ฐ๊ณผ ๋๋จธ์ง ์ฐ์ฐ์ ํ๋ ์ฐ์ฐ์
๐คฏ ํผ์ฐ์ฐ์๊ฐ ์ ์ํ์ผ ๊ฒฝ์ฐ 0์ผ๋ก ๋๋์ ArithmeticException์ด ๋ฐ์ํ๋ค!
๐ฎ ๋ฌธ์๋ ์ฐ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๋ค → ์ ์ฅ๋ ๋ ์ ๋์ฝ๋๋ก ์ ์ฅ๋๊ธฐ ๋๋ฌธ์
Operator | Description | |
+ | ๋ง์ ์ฐ์ฐ์ | Additive operator (also used for String concatenation) |
- | ๋บ์ ์ฐ์ฐ์ | Subtraction operator |
* | ๊ณฑ์ ์ฐ์ฐ์ | Multiplication operator |
/ | ๋๋์ ์ฐ์ฐ์ | Division operator |
% | ๋๋จธ์ง ์ฐ์ฐ์ | Remainder operator |
public class Main {
public static void main(String[] args) {
// Additive operator
int result = 1 + 2;
System.out.println("1 + 2 = " + result);
int original_result = result;
// Subtraction operator
result = result- 1;
System.out.println(original_result + " - 1 = " + result);
original_result = result;
// Multiplication operator
result = result * 3;
System.out.println(original_result + " * 3 = " + result);
original_result = result;
// Division operator
result = result / 2;
System.out.println(original_result + " / 2 = " + result);
original_result = result;
// Remainder operator
result = result % 2;
System.out.println(original_result + " % 2 = " + result);
}
}
1 + 2 = 3
3 - 1 = 2
2 * 3 = 6
6 / 2 = 3
3 % 2 = 1
๐ ๋นํธ ์ฐ์ฐ์
ํผ์ฐ์ฐ์๋ฅผ ๋นํธ ๋จ์๋ก ์ฐ์ฐํ๋ค.
ํผ์ฐ์ฐ์๋ก ์ ์๋ง ์ฌ์ฉํ ์ ์์ผ๋ฉฐ ์ค์๋ฅผ ํผ์ฐ์ฐ์๋ก ์ฌ์ฉํ ์ ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
Operator | Description |
& | AND ์ฐ์ฐ์ ๋ชจ๋ ๋นํธ ๊ฐ 1์ผ๋ ๊ฒฐ๊ณผ๋ 1 ์ด์ธ์๋ 0์ ๋ฐํ |
| | OR ์ฐ์ฐ์ ๋ชจ๋ ๋นํธ์ค ํ ๋นํธ๊ฐ 1์ด๋ฉด ๊ฒฐ๊ณผ๋ 1 ์ด์ธ์๋ 0์ ๋ฐํ |
^ | XOR ์ฐ์ฐ์ ๋นํธ๊ฐ ๊ฐ์ผ๋ฉด 0 ์๋ก ๋ค๋ฅผ๋ 1 |
~ | NOT ์ฐ์ฐ์, ๋นํธ ์ ํ ์ฐ์ฐ์ 0์ 1๋ก 1์ 0์ผ๋ก ๋ณํํ๋ค. |
<< | ๋นํธ ์ผ์ชฝ ์ด๋ ์ผ์ชฝ์ผ๋ก ์ด๋ ํ ์ค๋ฅธ์ชฝ์ 0์ ์ฑ์ ๋ฃ๋๋ค. |
>> | ๋นํธ ์ค๋ฅธ์ชฝ ์ด๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ ์ผ์ชฝ์ ํด๋น ๋ถํธ ๋นํธ๋ก ์ฑ์ด๋ค. |
>>> | ๋นํธ ์ค๋ฅธ์ชฝ ์ด๋ (unsigned) ์ผ์ชฝ ๋นํธ๊ฐ ๋ถํธ ๋นํธ๋ก ์ฑ์์ง์ง ์๊ณ 0์ผ๋ก ์ฑ์์ง๋ค. |
public class Main {
public static void main(String[] args) {
// & ๋ชจ๋ 1์ด๋ฉด 1
System.out.println("1&1 = " + (1&1));
System.out.println("1&0 = " + (1&0));
// | ํ์ชฝ ๊ฐ์ด 1์ด๋ฉด 1
System.out.println("1|1 = " + (1|1));
System.out.println("1|0 = " + (1|0));
// ^ ๊ฐ์ด ์๋ก ๋ค๋ฅผ ๋ 1
System.out.println("1^1 = " + (1^1));
System.out.println("1^0 = " + (1^0));
// ~ ๋นํธ๊ฐ 0์ด๋ฉด 1, 1์ด๋ฉด 0์ผ๋ก ๋ณํ
System.out.println("~-2 = " + (~-2));
System.out.println("~-1 = " + (~-1));
System.out.println("~0 = " + (~0));
System.out.println("~1 = " + (~1));
System.out.println("~2 = " + (~2));
}
}
1&1 = 1
1&0 = 0
1|1 = 1
1|0 = 1
1^1 = 0
1^0 = 1
~-2 = 1
~-1 = 0
~0 = -1
~1 = -2
~2 = -3
public class Main {
public static void main(String[] args) {
int x = 3;
int y = 6;
System.out.println("~x = " + ~x);
System.out.println("x & y = " + (x & y));
System.out.println("x | y = " + (x | y));
System.out.println("x << 1 = " + (x << 1));
System.out.println("x >> 1 = " + (x >> 1));
System.out.println("x >>> 1 = " + (x >>> 1));
}
}
~x = -4
x & y = 2
x | y = 7
x << 1 = 6
x >> 1 = 1
x >>> 1 = 1
๐ ๊ด๊ณ ์ฐ์ฐ์
๋ ํผ์ฐ์ฐ์๋ฅผ ๋น๊ตํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์ฐ์ฐ์์ด๋ค.
์ฃผ๋ก ์กฐ๊ฑด๋ฌธ์ด๋ ๋ฐ๋ณต๋ฌธ์ ์กฐ๊ฑด์์ ์ฌ์ฉ๋๋ค.
๊ฒฐ๊ณผ๋ true์ false ๋ ์ค ํ๋๋ก ๊ณ์ฐ๋๋ค.
์ดํญ ์ฐ์ฐ์์ด๋ฏ๋ก ํผ์ฐ์ฐ์์ ํ์ ์ด ์๋ก ๋ค๋ฅผ ๊ฒฝ์ฐ์๋ ์๋ฃํ์ด ๋ ํฐ ์ชฝ์ผ๋ก ์๋ ํ๋ณํํ์ฌ ํผ์ฐ์ฐ์์ ํ์ ์ ์ผ์น์ํจํ ๋น๊ตํ๋ค.
๊ฐ์ด ๊ฐ์์ง ๋ค๋ฅธ์ง ๋น๊ตํ๋ ๋ฑ๊ฐ ๋น๊ต ์ฐ์ฐ์์
ํผ์ฐ์ฐ์ ๊ฐ์ ๋น๊ตํ๋ ๋์๋น๊ต ์ฐ์ฐ์๊ฐ ์๋ค.
Operator | Description |
== | equal to |
!= | not equal to |
> | greater then |
>= | greater than or equal to |
< | less than |
<= | less than or equal to |
public class Main {
public static void main(String[] args) {
int a = 1;
int b = 2;
if(a == b) {
System.out.println("a == b");
}
if(a != b) {
System.out.println("a != b");
}
if(a > b) {
System.out.println("a > b");
}
if(a >= b) {
System.out.println("a >= b");
}
if(a < b) {
System.out.println("a < b");
}
if(a <= b) {
System.out.println("a <= b");
}
}
}
a != b
a < b
a <= b
๐บ ๋ ผ๋ฆฌ ์ฐ์ฐ์
'๊ทธ๋ฆฌ๊ณ (AND)' ์ '๋๋(OR)' ์ผ๋ก ์กฐ๊ฑด์ ์ฐ๊ฒฐํ๋ค.
๐ฎ ๊ฐ์ ์กฐ๊ฑด์์ด๋ผ๋ ํผ์ฐ์ฐ์์ ์์น์ ๋ฐ๋ผ ์ฐ์ฐ ์๋๊ฐ ๋ฌ๋ผ์ง ์ ์๋ค.
Operator | Description |
! | NOT ์ฐ์ฐ ํผ์ฐ์ฐ์๊ฐ ์ฐธ์ด๋ฉด ๊ฑฐ์ง ํผ์ฐ์ฐ์๊ฐ ๊ฑฐ์ง์ด๋ฉด ์ฐธ |
&& | AND ์ฐ์ฐ ํผ์ฐ์ฐ์ ๋ชจ๋ ์ฐธ์ด๋ฉด ์ฐธ ๊ทธ๋ ์ง ์์ผ๋ฉด ๊ฑฐ์ง |
|| | OR ์ฐ์ฐ ํผ์ฐ์ฐ์ ๋์ค ํ๋๋ง ์ฐธ์ด๋ฉด ์ฐธ, ๋ชจ๋ ๊ฑฐ์ง์ด๋ฉด ๊ฑฐ์ง |
x | y | x && y | x || y | !x |
false | false | false | false | true |
false | true | false | true | true |
true | false | false | true | false |
true | true | true | true | false |
public class Main {
public static void main(String[] args) {
int a = 1;
int b = 2;
if((a == 1) && (b == 2) ) {
System.out.println("a is 1 AND b is 2");
}
if((a == 1) || (b == 1)) {
System.out.println("a is 1 OR b is 1");
}
}
}
a is 1 AND b is 2
a is 1 OR b is 1
๐ instanceof
instanceof์ฐ์ฐ์๋ ๊ฐ์ฒด๋ฅผ ์ง์ ๋ ์ ํ๊ณผ ๋น๊ตํ๋ค.
ํผ์ฐ์ฐ์์ ํ์์ ์ฐธ์กฐํ์ ๋๋ null ํ์์ด์ด์ผ ํ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด ์ปดํ์ผ ํ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
ReferenceType์ด ์์ ๊ฐ๋ฅํ ์ฐธ์กฐ์ ํ์ ๋ํ๋ด์ง ์์ผ๋ฉด ์ปดํ์ผ ํ์ ์๋ฌ์ด๋ค.
ReferenceType์ ๋ํ RelationalExpression์ cast๊ฐ ์ปดํ์ผ ์๊ฐ ์ค๋ฅ๋ก ๊ฑฐ๋ถ๋๋ฉด instanceof ๊ด๊ณ์๋ ์ปดํ์ผ ํ์ ์๋ฌ๋ฅผ ์์ฑํ๋ค.
๋ฐํ์์ RelationalExpression ๊ฐ์ด null์ด ์๋๋ฉด์ ClassCastException์ ์ฌ๋ฆฌ์ง ์๊ณ cast ํ ์ ์์ผ๋ฉด ๊ฒฐ๊ณผ๊ฐ ์ฐธ์ด๋ค.
๐ assignment(=) operator
๋์ ์ฐ์ฐ์๋ ์ฐ๋ณ์ ๊ฐ์ ์ข๋ณ์ ์ ์ฅํ๋ ๊ฒ์ ๋งํ๋ค.
๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํ ๋นํ๊ธฐ ์ํด ๊ฐ์ฒด์ ์ฌ์ฉํ ์๋ ์๋ค.
int number = 10;
System.out.println(number); // 10
Person person = new Person("nyximos", 19200);
๋ณตํฉ ๋์ ์ฐ์ฐ์
๋์ ์ฐ์ฐ์๋ฅผ ๋ค๋ฅธ ์ฐ์ฐ์์ ๊ฒฐํฉํ์ฌ ์์ค๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์๋ค.
Operator | Description |
= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ๋์ |
+= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์ ๋ํ ํ, ๋ํ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ |
-= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์ ๋บ ํ, ๋บ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ |
*= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์ ๊ณฑํ ํ, ๊ณฑํํ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ |
/= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์ ๋๋ ํ, ๋๋ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ |
%= | ์ผ์ชฝ ํผ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์ ๋๋ ํ, ๋๋จธ์ง ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ |
&= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์์ ๋นํธ AND ์ฐ์ฐ ํ, ์ฐ์ฐํ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
|= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์์ ๋นํธ OR ์ฐ์ฐ ํ, ์ฐ์ฐํ ๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
^= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์์ ๋นํธ XOR ์ฐ์ฐํ ํ, ๊ทธ ๊ฒฐ๊ด๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
<<= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์๋งํผ ์ผ์ชฝ ์ํํธํ ํ, ๊ทธ ๊ฒฐ๊ด๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
>>= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์๋งํผ ๋ถํธ๋ฅผ ์ ์งํ๋ฉฐ ์ค๋ฅธ์ชฝ ์ํํธํ ํ, ๊ฒฐ๊ด๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
>>>= | ์ผ์ชฝ ํผ์ฐ์ฐ์๋ฅผ ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์๋งํผ ๋ถํธ์ ์๊ด์์ด ์ค๋ฅธ์ชฝ ์ํํธํ ํ, ๊ฒฐ๊ด๊ฐ์ ์ผ์ชฝ ํผ์ฐ์ฐ์์ ๋์ ํจ. |
๐ ํ์ดํ(->) ์ฐ์ฐ์
ํ์ดํ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๋๋ค ํํ์์ ์์ฑํ ์ ์๋ค.
Jaba 8์ ์ถ๊ฐ๋ ๋๋ค์์ ์ง์ํ๊ธฐ์ํ ์ฐ์ฐ์์ด๋ค.
Lambda expression ๋๋ค ํํ์
ํจ์(๋ฉ์๋)๋ฅผ ๊ฐ๋จํ ์์ผ๋ก ํํํ๊ฒ
// ๊ธฐ์กด ์
int max(int a, int b){
return a > b ? a : b;
}
// ๋๋ค์
(a,b) -> a > b ? a: b
๐ค ํจ์์ ๋ฉ์๋์ ์ฐจ์ด
- ๊ทผ๋ณธ์ ์ผ๋ก ๋์ผํ๋ ํจ์๋ ์ผ๋ฐ์ ์ฉ์ด์ด๊ณ , ๋ฉ์๋๋ ๊ฐ์ฒด์งํฅ๊ฐ๋ ์ ์ฉ์ด์ด๋ค.
- ํจ์๋ ํด๋์ค์ ๋ ๋ฆฝ์ ์ด๊ณ , ๋ฉ์๋๋ ํด๋์ค์ ์ข ์์ ์ด๋ค.
๐ฉ๐ป ๋๋ค์ ์์ฑํ๊ธฐ
- ๋ฉ์๋ ์ด๋ฆ๊ณผ ๋ฐํํ์ ์ ์ ๊ฑฐํ๊ณ -> ๋ฅผ ๋ธ๋ก ์์ ์ถ๊ฐํ๋ค.
- ๋ฐํ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ์์ด๋ ๊ฐ๋ง ์ ๊ณ return๋ฌธ ์๋ต ๊ฐ๋ฅ ( ๋์ ; ์ ๋ถ์ธ๋ค. )
- ๋งค๊ฐ๋ณ์์ ํ์ ์ด ์ถ๋ก ๊ฐ๋ฅํ ๊ฒฝ์ฐ ์๋ต ๊ฐ๋ฅํ๋ค. ( ๋๋ถ๋ถ ์๋ต ๊ฐ๋ฅ)
๐ฎ ๋๋ค์ ์์ฑ์ ์ฃผ์์ฌํญ
- ๋งค๊ฐ๋ณ์๊ฐ ํ๋์ธ ๊ฒฝ์ฐ, ๊ดํธ ( ) ์๋ต ๊ฐ๋ฅ (ํ์ ์ด ์์ ๋๋ง)
- ๋ธ๋ก ์์ ๋ฌธ์ฅ์ด ํ๋ ๋ฟ์ผ ๋, ๊ดํธ { } ์๋ต ๊ฐ๋ฅ ( ๋์ ; ์ ๋ถ์ธ๋ค. )
ํ๋๋ฟ์ธ ๋ฌธ์ฅ์ด return๋ฌธ์ด๋ฉด ๊ดํธ ์๋ต ๋ถ๊ฐ๋ฅ
๐ 3ํญ ์ฐ์ฐ์
์ธ๊ฐ์ ํผ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ ์ฐ์ฐ์์ด๋ค.
์กฐ๊ฑด์ ? ์ฒซ๋ฒ์งธ์ : ๋๋ฒ์งธ์
์กฐ๊ฑด์์ ๊ฒฐ๊ณผ๊ฐ true์ผ๋ ์ฒซ๋ฒ์งธ ์์ด ๋ฐํ๋๊ณ , false์ผ๋๋ ๋๋ฒ์งธ์์ด ๋ฐํ๋๋ค.
3ํญ ์ฐ์ฐ์๋ฅผ ์ค๋ณตํด์ ์ฌ์ฉํ ๊ฒฝ์ฐ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๋ค.
3ํญ ์ฐ์ฐ์๋ if๋ฌธ์ผ๋ก ๋ฐ๊ฟ ์ธ ์ ์๋ค.
public class Main {
public static void main(String[] args) {
String a = "true";
String b = "false";
String result;
boolean condition = true;
result = condition ? a : b;
System.out.println("condition์ " + a + "์ด๋ค.");
}
}
condition์ true์ด๋ค.
๐์ฐ์ฐ์ ์ฐ์ ์์
์์ ์ฌ์ฉ๋ ์ฐ์ฐ์๊ฐ ๋ ์ด์์ผ ๊ฒฝ์ฐ ์ฐ์ฐ์์ ์ฐ์ ์์์ ์ํด ์ฐ์ฐ ์์๊ฐ ๊ฒฐ์ ๋๋ค.
๋์ผํ ์ฐ์ ์์์ ์ฐ์ฐ์๊ฐ ๋์ผํ ํํ์์ ๋ํ๋ ๋ ์ด๋ค ๊ฒ์ด ๋จผ์ ์ฐ์ฐํด์ผ๋๋์ง ๊ฒฐ์ ํด์ผ ํ๋ค.
ํ ๋น ์ฐ์ฐ์์ ๋จํญ์ฐ์ฐ์, ์ฆ๊ฐ ์ฐ์ฐ์๋ ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก, ์ด์ธ์ ์ดํญ ์ฐ์ฐ์๋ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฐ์ฐํ๋ค.
์ฐ์ > ๋น๊ต > ๋ ผ๋ฆฌ > ๋์
๋จํญ > ์ดํญ > ์ผํญ
์ฐ์ฐ์ ์ฐ์ ์์
Operators | Precedence | ||
1 | ์ ๋ฏธ์ฌ | postfix | expr++ expr-- |
2 | ๋จํญ ์ฐ์ฐ์ | unary | ++expr --expr +expr -expr ~ ! |
3 | ๊ณฑ์ ๋๋์ ์ฐ์ฐ์ | multiplicative | * / % |
4 | ๋ง์ ๋บ์ ์ฐ์ฐ์ | additive | + - |
5 | ์ฌํํธ ์ฐ์ฐ์ | shift | << >> >>> |
6 | ๊ด๊ณ(๋น๊ต) ์ฐ์ฐ์ | relational | < > <= >= instanceof |
7 | ๊ด๊ณ(๋น๊ต) ์ฐ์ฐ์ | equality | == != |
8 | ๋นํธ ๋จ์์ ๋ ผ๋ฆฌ ์ฐ์ฐ์ | bitwise AND | & |
9 | ๋นํธ ๋จ์์ ๋ ผ๋ฆฌ ์ฐ์ฐ์ | bitwise exclusive OR | ^ |
10 | ๋นํธ ๋จ์์ ๋ ผ๋ฆฌ ์ฐ์ฐ์ | bitwise inclusive OR | | |
11 | ๋ ผ๋ฆฌ ์ฐ์ฐ์ | logical AND | && |
12 | ๋ ผ๋ฆฌ ์ฐ์ฐ์ | logical OR | || |
13 | 3ํญ ์ฐ์ฐ์ | ternary | ? : |
14 | ๋์ , ํ ๋น ์ฐ์ฐ์ | assignment | = += -= *= /= %= &= ^= |= <<= >>= >>>= |
๐(optional) Java 13. switch ์ฐ์ฐ์
switch statement
์ค๋ฅ๊ฐ ๋ฐ์ํ๊ธฐ ์ฝ๋ค.
break๊ฐ ๋ถํ์ํ๊ฒ ๋ค์ด๊ฐ ์ฅํฉํ๋ค. → ๋๋ฒ๊น ํ๊ธฐ ์ด๋ ต๋ค.
break๊ฐ ์์ผ๋ฉด ์๋์น ์๊ฒ ์ฝ๋๋ฅผ ์คํํ ์ ์๋ค.
int numLetters;
switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
numLetters = 6;
break;
case TUESDAY:
numLetters = 7;
break;
case THURSDAY:
case SATURDAY:
numLetters = 8;
break;
case WEDNESDAY:
numLetters = 9;
break;
default:
throw new IllegalStateException("Wat: " + day);
}
์ด๊ฒ์ ๋ฌธ์ฅ์ผ๋ก ํํํ๋ ๊ฒ์ ์ฐํ์ ์ด๊ณ ๋ฐ๋ณต์ ์ด๋ฉฐ ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ธฐ ์ฝ๋ค.
Case L -> ๋ฐฉ์์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
int numLetters = switch (day) {
case MONDAY, FRIDAY, SUNDAY -> 6;
case TUESDAY -> 7;
case THURSDAY, SATURDAY -> 8;
case WEDNESDAY -> 9;
};
Case L -> ์ค๋ฅธ์ชฝ์๋ ๋จ์ผ ํํ์์ ๊ฐ์ง๋๋ฐ
full block์ด ํ์ํ ๊ฒฝ์ฐ์ ๊ฐ์ ์ฐ์ถํ๊ธฐ ์ํ yield๋ฅผ ์ฌ์ฉํด ๊ฐ์ ๋ฐํํ ์ ์๋ค.
๊ธฐ์กด์ case L:๊ณผ ํจ๊ป ์ฌ์ฉํ ์ ์๋ค.
์ฐธ์กฐ
๋จ๊ถ์ฑ, ์๋ฐ์ ์ ์ ๊ธฐ์ดํธ, ๋์ฐ์ถํ, 2019
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html
Operators (The Java™ Tutorials > Learning the Java Language > Language Basics)
The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated
docs.oracle.com
์ผํญ ์ฐ์ฐ์ - https://ssdragon.tistory.com/4
Java ์ผํญ ์ฐ์ฐ์(์กฐ๊ฑด ์ฐ์ฐ์) - Conditional Operator
์ผํญ ์ฐ์ฐ์(์กฐ๊ฑด ์ฐ์ฐ์)๋ ๋ฌด์์ธ๊ฐ? ์ผํญ ์ฐ์ฐ์(์กฐ๊ฑด ์ฐ์ฐ์)๋ Java 8 Language Specification์์ Conditional Operator ๋ผ๊ณ ์ ์๋์ด ์๋ค. ์๋ ์ฌ์ง์ oracle ๊ณต์๋ฌธ์์ ๋ฐ๋ฅด๋ฉด ์กฐ๊ฑด ์ฐ์ฐ์๋ ํ ํํ
ssdragon.tistory.com
Switch Expressions - https://openjdk.java.net/jeps/354
JEP 354: Switch Expressions (Second Preview)
JEP 354: Switch Expressions (Second Preview) AuthorGavin BiermanOwnerJan LahodaTypeFeatureScopeSEStatusClosed / DeliveredRelease13Componentspecification / languageDiscussionamber dash dev at openjdk dot java dot netEffortSDurationMRelates toJEP 325
openjdk.java.net
Switch Expressions - https://catch-me-java.tistory.com/31
'Programming > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ํด๋์ค (0) | 2022.08.05 |
---|---|
[Java] ์ ์ด๋ฌธ (0) | 2022.08.04 |
[Java] ์๋ฐ ๋ฐ์ดํฐ ํ์ , ๋ณ์ ๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด (0) | 2022.01.14 |
[JAVA] JVM์ ๋ฌด์์ด๋ฉฐ ์๋ฐ ์ฝ๋๋ ์ด๋ป๊ฒ ์คํํ๋ ๊ฒ์ธ๊ฐ (0) | 2022.01.08 |
[JAVA] ์๋ฐ๋? (0) | 2022.01.06 |