์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 | 29 | 30 |
- ๊ฐ์ฒด์งํฅ
- ๋น๊ต ์ฐ์ฐ์
- ๋ฐฐ์ด
- ์ฐ์ฐ์
- SQL
- ์์ฝ์ด
- ์น์ ํ SQL
- ์น์ ํ SQL ํ๋
- ํจ์
- StringBuffer
- ์ดํด๋ฆฝ์ค ์ค์น
- spring ๊ฒ์ํ ์ญ์
- ์์
- ๊ฐ์ฒด
- @PreAuthorize("isAuthenticated()")
- SQL ํ๋
- join
- SpringSecurity ๋ก๊ทธ์์
- ์๋ฐ์์ ์
- ์ธํ ๋ฆฌ์ ์ด Web ์ ํ๋ฆฌ์ผ์ด์
- ์ค๋ฒ๋ผ์ด๋ฉ
- ์ฐ์ ์ฐ์ฐ์
- ๋ฐ๋ณต๋ฌธ
- ์ค๋ฒ๋ก๋ฉ
- SQLํ๋
- ์๋ณ์
- SpringSecurity ๋ก๊ทธ์ธ
- ๋ ผ๋ฆฌ ์ฐ์ฐ์
- java
- ์คํ๋ง์ํ๋ฆฌํฐ ๋ก๊ทธ์์
- Today
- Total
gi_dor
Java (2) Variable ( ์ ์ , ์ค์ , ๋ฌธ์ , ๋ฌธ์์ด , ํ๋ณํ) ๋ณธ๋ฌธ
Java (2) Variable ( ์ ์ , ์ค์ , ๋ฌธ์ , ๋ฌธ์์ด , ํ๋ณํ)
๊ธฐ๋ 2023. 10. 24. 20:11
๐ ๊ตญ๋น 11 ์ผ์ฐจ
Java๊ฐ ์ ์ฉ๋๋ ๋ถ์ผ
- ์น ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐ
- ์๋๋ก์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐ ( ์ฝํ๋ฆฐ์ผ๋ก ์ด์ )
- ์ ๋ณด์์คํ ๊ฐ๋ฐ ( ์น์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์ ๋ฌด์ฉ ํ๋ก๊ทธ๋จ )
- ๋น ๋ฐ์ดํฐ ๋ถ์ ( ํ๋ก , ์คํํฌ )
Java๋ฅผ ์ ์ฉํ๊ธฐ ์ด๋ ค์ด ๋ถ์ผ
- ๋์ ์ฑ๋ฅ์ ์๊ตฌํ๋ ํ๋ก์ ํธ ( Rust , c , c++์ ์ฃผ๋ก ํ์ฉ )
- ์์คํ ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ ( ์ด์์ฒด์ , ๋๋ผ์ด๋ฒ, ์ปค๋)
ํ๋ก๊ทธ๋จ์ด๋?
์ปดํจํฐ๊ฐ ์ฒ๋ฆฌํ ์์ ์ ์์์ ๋ง๊ฒ ์์ฑํ ์์ ์ง์์
์์ ์ง์์ | ์๋ฆฌ ๋ ์ํผ |
๋ฐ์ดํฐ ์ค๋น | ์ฌ๋ฃ ์ค๋น |
๋ฐ์ดํฐ ๊ฐ๊ณต / ์กฐ์ | ์ฌ๋ฃ๊ฐ๊ณต |
์ต์ข ๊ฒฐ๊ณผ๋ฌผ | ์๋ฆฌ |
๋ชฉ์ฐจ
์ ์
์ค์
๋ฌธ์
๋ฌธ์์ด
๋
ผ๋ฆฌํ
ํ๋ณํ
๋ฆฌํฐ๋ด
์ฐ์ฐ์์น
ํ๋ณํ
๊ฐ์ ํ๋ณํ
๐ถ ์๋ฃํ๊ณผ ๋ณ์
๐น ๋ณ์
๋ณ์๋ ๊ฐ์ ๋ด๋ ์ ์ฅ์
๊ณ ์ ํ ํ์
์ ๊ฐ์ผ๋ฉฐ ์ผ์นํ๋ ํ์
์ ๊ฐ๋ง ์ ์ฅํ ์ ์๋ค
๐น ์๋ฐ์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์ ์ข ๋ฅ
- ๋ฐ์ดํฐ ํ์ ์ ๋ณ์๊ฐ ์ ์ฅํ ์ ์๋ ๊ฐ์ ์ข ๋ฅ๋ฅผ ๊ฒฐ์ ํ๋ค
- ๋ณ์๋ฅผ ์์ฑํ ๋์๋ ๋ฐ๋์ ๊ทธ ๋ณ์์ ํ์ ์ ์ง์ ํด์ผ ํ๋ค.
Type | Keyword | Size | Default value |
๋ ผ๋ฆฌํ | boolean | 1 byte | false |
์ ์ํ | byte | 1 byte | 0 |
์ ์ํ | short | 2 byte | 0 |
์ ์ํ | int | 4 byt | 0 |
์ ์ํ | longt | 8 byte | 0L |
์ค์ํ | float | 4 byte | 0.0F |
์ค์ํ | double | 8 btte | 0.0 |
๋ฌธ์ํ | char | 2 byte | '\u0000' |
๐น ์ ์ํ
byte , short , int , long
- ์ ์ ์๋ฃํ์ ๊ธฐ๋ณธ ์๋ฃํ์ int๊ฐ default๋ค
- ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋จ์์ ์ ์ ๊ฐ์ int ๋ฒ์ ๋ด์ ์ํ๊ธฐ ๋๋ฌธ
- ํน๋ณํ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ์ ์๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ int ํ์
์ผ๋ก ์์ฑํ๋ค.
( byte ํ์ ์ ์ ์ถ๋ ฅ์์ ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ฌ์ฉ ํ๋ค. )
(long ํ์ ์ int ๋ฒ์๋ฅผ ์ด๊ณผํ๋ ์ ์๊ฐ์ ๋ค๋ฃฐ ๋ ์ฌ์ฉ ํ๋ค Ex. ์ํ ์๊ธ์ ์์ก )
๐น ์ค์ํ
- float , double
- ์ค์ํ์ default ์๋ฃํ์ double
- ์ค์๊ฐ์ ๋๋ถ๋ถ double ํ์ ์ ๋ณ์๋ก ๋ค๋ฃฌ๋ค
- float ํ์
์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ฑฐ์ ์๋ค
๐น ๋ฌธ์ ์๋ฃํ
- char
- ๋ฌธ์ ์๋ฃํ ํ์ ์ ๋ณ์๋ ์ค์ง ' ํ ๋ฌธ์๋ง ' ์ ์ฅํ ์ ์๋ค
- ๋ฌธ์ ์๋ฃํ์ ์ ๋ ์ฝ๋๋ฅผ ์ง์ํ๊ธฐ ๋๋ฌธ์ ์ ์ธ๊ณ์ ๋ชจ๋ ๊ธ์๋ฅผ ํํํ ์ ์๋ค
- ๋ง์ฝ 1๊ธ์ ์ด์์ ์ ์ฅํ๋ ๊ฒฝ์ฐ String ๊ฐ์ฒด ์ฌ์ฉ
๐น ๋ฌธ์์ด
- ๋ฌธ์์ด์ 1๊ธ์ ์ด์์ ๋ฌธ์๋ฅผ ํํํ๋ ์๋ฃํ์ด๋ค.
- ๋ฌธ์์ด์ " " ์ฌ์ด์ ํ์ํ๋ค.
- ๋ฌธ์์ด์ 1๊ธ์ ์ด์์ ํํ๋๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ ๋์์ผ๋ก ๋ค์ํ ์์ ์ ์ํํ ํ์๊ฐ ์๋ค.
- ๊ธธ์ด ์กฐํํ๊ธฐ , ํน์ ๋ฌธ์์ด์ด ํฌํจ๋์ด ์๋์ง ์กฐํํ๊ธฐ , ํน์ ์์น ํ์ ๋ฌธ์ ์์๋ด๊ธฐ
- ํน์ ๋ฌธ์์ด๋ก ์์ํ๊ฑฐ๋ ๋๋๋์ง ์์๋ด๊ธฐ , ๋ / ์๋ฌธ์๋ก ๋ณํํ๊ธฐ
- ํน์ ์๊ฐ ์์น๋ถํฐ ์ง์ ๋ ์์น๊น์ง ์๋ผ ๋ด๊ธฐ , ํน์ ๋ฌธ์์ด์ ๋ค๋ฅธ ๋ฌธ์์ด๋ก ๋ณ๊ฒฝํ๊ธฐ
Java๋ ๋ฌธ์์ด์ ํํํ๊ณ ๋ฌธ์์ด์ ์กฐ์ํ๋ ๋ค์ํ ๊ธฐ๋ฅ์ ํฌํจํ๊ณ ์๋ String ํด๋์ค (์ค๊ณ๋)๋ฅผ ์ ๊ณตํ๋ค.
String s1 = "ํ๊ธธ๋";
String s2 = "์์ธํน๋ณ์ ์ข
๋ก๊ตฌ ";
String s3 = "ํ๊ธธ๋ , ๊น์ ์ , ๊น์๋ฏผ , ๊ณฝ์ฌ์ฐ";
String s4 = "010-1234-9876";
String s5 = "A";
String s6 = 'A'; // ์ค๋ฅ , ๋ฌธ์ ํ์
์ ๊ฐ์ String ๋ณ์์ ๋ด์์ ์๋ค
char c1 ='A';
char c2 = "A"; // ์ค๋ฅ , ๋ฌธ์์ด ํ์
์ ๊ฐ์ char์ ๋ด์์ ์๋ค
// Error
Type mismatch: cannot convert from char to String
๐น ๋ ผ๋ฆฌํ
- boolean
- ๋ ผ๋ฆฌ ๊ฐ์ true / false 2๊ฐ์ง ๊ฐ๋ง ์กด์ฌํ๋ค
- true์ false๋ ๊ฐ๊ฐ ์ฐธ / ๊ฑฐ์ง ์ ํํํ๋ ์๋ฐ์ ์์ฝ์ด๋ค
- ๋ ผ๋ฆฌ ๊ฐ์ boolean ํ์ ์ ๋ณ์์๋ง ๋์ ํ ์ ์๋ค.
boolean b1 = true;
boolean b2 = false;
boolean ํฉ๊ฒฉ์ฌ๋ถ = true;
boolean ์กด์ฌ์ฌ๋ถ = false;
boolean ๋ฐฐ์ก์๋ฃ์ฌ๋ถ = true;
boolean ํด์ฌ์ฌ๋ถ = false;
๐น Java์ ๋ฆฌํฐ๋ด
โ ์ ์ ๋ฆฌํฐ๋ด : ์ฝ๋์์ ์ ์ ๊ฐ์ ํํํ๋ ๋ฐฉ๋ฒ
100 , -100 , 100_000_00 , 0100 , 0x100
โ ์ค์ ๋ฆฌํฐ๋ด : ์ฝ๋์์ ์ค์ ๊ฐ์ ํํํ๋ ๋ฐฉ๋ฒ
3.16 , -3.24 , 1.235e2
โ ๋ฌธ์ ๋ฆฌํฐ๋ด : ์ฝ๋์์ ํ ๋ฌธ์๋ฅผ ํํํ๋ ๋ฐฉ๋ฒ , char ํ์
์ ๊ฐ์ ํํ
'A' , '๊ฐ' โฌ
๋ฌธ์ ํ์
(char)
'ํ๊ธธ๋' โฌ
์ค๋ฅ
โ ๋ฌธ์์ด ๋ฆฌํฐ๋ด : ์ฝ๋์์ ๋ฌธ์์ด์ ํํํ๋ ๋ฐฉ๋ฒ
"ABCDEF" , "๊ฐ๋๋ค๋ผ๋ง๋ฐ์ฌ์์์ฐจ์นดํํํ"
"A" โฌ
๋ฌธ์์ด ํ์
(String) A
"๊ฐ" โฌ
๋ฌธ์์ด ํ์
(String) ๊ฐ
๐ ๋ณ์์ ์๋ฃํ ๐
1๏ธโฃ ๊ธฐ๋ณธ์๋ฃํ
์ ์ | byte short int long |
์ค์ | double float |
๋ฌธ์ | char |
๋ ผ๋ฆฌ | boolean |
2๏ธโฃ ์ฐธ์กฐ์๋ฃํ
๊ธฐ๋ณธ ์๋ฃํ์ ์ ์ธํ ์ ๋ถ๋ค. | |
๋ฌธ์์ด | String |
๐น Java์ ์ฐ์ฐ์์น
โ ์๋ฐ์ ์ฐ์ฐ์ ๊ฐ์ ํ์
๋ผ๋ฆฌ๋ง ๊ฐ๋ฅํ๋ค ( int๋ int๋ผ๋ฆฌ double ์ double๋ก ๋ผ๋ฆฌ๋ผ๋ฆฌ ์ฐ์ฐํ๊ธฐ)
โก ์๋ฐ์ ์ฐ์ฐ์ ์ฐ์ฐ์ ์ฐธ์ฌํ ๊ฐ์ ํ์
๊ณผ ์ฐ์ฐ๊ฒฐ๊ณผ๊ฐ ํญ์ ๋์ผํ ํ์
์ด๋ค
โข ์๋ฐ์ ์ฐ์ฐ์ ์ฐธ์ฌํ๋ ๊ฐ์ ํ์
์ด ์๋ก ๋ค๋ฅธ๊ฒฝ์ฐ , ๊ฐ์ ํ์
์ผ๋ก ๋ณํ ํ ์ฐ์ฐ์ด ์ผ์ด๋๋ค.
๐ ํ์
๋ณํ์ ๊ฐ์ ์์ค์ด ๋ฐ์ํ์ง ์๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค ( ์ ์ byte → ํฐ byte )
์ ์ ๊ธฐ๋ณธ int (4byte) → ์ค์ ๊ธฐ๋ณธ double (8byte)๋ก ๋ณํ๋ฉด ๋ฐ์ดํฐ์ ์์ค์ด ์๊ธฐ์ง ์๊ณ
๋ฐ๋๋ก ์ค์ double → int๊ฐ ๋๋ฉด ๋ฐ์ดํฐ์ ์์ค์ด ๋ฐ์ํ๋ค. ( 8byte → 4byte )
1. ํฌ๊ธฐ๊ฐ ์์ ํ์
->> ํฌ๊ธฐ๊ฐ ๋ ํฐ ํ์
long x = 10;
// int ํ์
10 ์ด long ํ์
10 ์ผ๋ก ๋ณํํ ๋์
2. ์ ๋ฐ๋๊ฐ ๋ฎ์ ํ์
->> ์ ๋ฐ๋๊ฐ ๋ ๋์ํ์
double d = 3;
// int ํ์
3์ด double ํ์
3.0 ์ผ๋ก ๋ณํํ ๋์
๋๋ค.
๐น ๊ธฐ๋ณธ ์๋ฃํ์ ํ๋ณํ
โ ์๋ ํ๋ณํ
๋ฐ์ดํฐ์ ์์ค์ด ๋ฐ์ํ์ง ์๋ ๋ฐฉํฅ์ผ๋ก์ ํ๋ณํ์ ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ค
โก ๊ฐ์ ํ๋ณํ
๋ฐ์ดํฐ์ ์์ค์ด ๋ฐ์ํ๋ ๋ฐฉํฅ์ผ๋ก์ ํ๋ณํ์ ์๋์ผ๋ก ์ผ์ด๋์ง ์๊ธฐ ๋๋ฌธ์
๊ฐ๋ฐ์๊ฐ ๊ฐ์ ๋ก ํ๋ณํ ๋ฐฉํฅ์ ์ง์ ํ๋ ๊ฒ์ด๋ค.
// ์ฐ์ฐ์ ์ฐธ์ฌํ ๊ฐ์ ํ์
๊ณผ ์ฐ์ฐ๊ฒฐ๊ณผ๋ ๋์ผํ๋ค.
System.out.println(10 / 3);
System.out.println(10.0 / 3.0);
// ์ฐ์ฐ์ ์ฐธ์ฌํ ๊ฐ์ ํ์
์ด ์๋ก ๋ค๋ฅธ๊ฒฝ์ฐ ๊ฐ์ ํ์
์ผ๋ก ๋ณํํ ์ฐ์ฐ์ด ์ผ์ด๋๋ค
// ํ๋ณํ ๋ฐฉํฅ์ ๋ ํฐ ๋ฐ์ดํฐ ํ์
ํน์ ์ ๋ฐ๋๊ฐ ๋ ๋์ ํ์
์ผ๋ก ๋ณํํ๋ค.
// ์ ์ / ์ค์ -> ์ค์ / ์ค์ ----> ์ค์
System.out.println(12 / 5.0); // 12 / 5.0 ->>> 12.0 / 5.0 ---- 2.4
System.out.println(12.0 / 5); // 12.0 / 5 ->>> 12.0 / 5.0 ---- 2.4
// ์ฐ์ฐ์ ์ฐธ์ฌํ๋ ๋ณ์์ ํ์
๊ณผ ๊ฐ์ ํ์
์ด ์๋ก ๋ค๋ฅธ ๊ฒฝ์ฐ
// ๊ฐ์ ํ์
์ ๋ณ์์ ํ์
๊ณผ ๊ฐ์ ํ์
์ผ๋ก ๋ณํ ํ ๋ค์ ์ฐ์ฐ์ด ์คํ๋๋ค.
double num1 = 3; // ์ค์ ํ์
์ธ๋ฐ ๊ฐ์ด ์ ์ ?
// double num1 = 3.0 ์ผ๋ก ๋ฐ์ดํฐ ์์ค ์์ด ๋ฐ๋๋ค.
int num2 = 3.4;
//Type mismatch: cannot convert from double to int
// ๋ณ์ ํ์
์ด int ์ธ๋ฐ ๊ฐ์ ํ์
์ด double ์ด๋ค
// ๋ณ์์ ํ์
๊ณผ ๊ฐ์ ํ์
์ผ๋ก ๊ฐ์ ๋ณํํ๋ฉด ๋ฐ์ดํฐ์ ์์ค์ด ๋ฐ์ํจ
// ์๋ํ๋ณในํ์ด ์ผ์ด๋ ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋ฅ๊ฐ ๋ฐ์
// ๊ฐ์ ํ๋ณํ
int num3 = (int) 3.14;
System.out.println(num3); // 3 , ์์์ ๋ ๋ผ๊ฐ
๐น ํ์ ๊ฐ์ ํ๋ณํ
์ ์ ↔ ์ ์
byte x = 10; int y = x;
int x = 10; byte y = (byte)x;
์ค์ ↔ ์ค์
double x = 3.14; float y = (float) x;
์ ์ ↔ ์ค์
double x = 10;
int x = (int) 3.14;
์ ์ ↔ ๋ฌธ์
char x = 65;
int x = 'A';
ํ๋ณํ์ด ์ ๋๋ ๊ฒฝ์ฐ
int x = (int)"123445";
String x = 'A';
int y = true;
boolean x = 1;
char x = "A";
์ค์ต
โป ์ค์ต - ๋ณ์์์ฑ , ์ด๊ธฐํ
// ๋ณ์ ์์ฑ
int a; // ๋ฉ๋ชจ๋ฆฌ์ ์ ์๋ฅผ ์ ์ฅํ ์ ์๋ ๊ณต๊ฐ์ด ํ๋ณด๊ฐ ๋๊ณ , ๊ทธ ์ ์ฅ์๋ฅผ
// a๋ผ๋ ๋ณ์๋ช
์ผ๋ก ์ก์ธ์ค ํ ์ ์๋ค.
// ์ด๊ธฐํ ํ์ง ์์ ๋ณ์๋ ์ถ๋ ฅ์ด๋ ์ฐ์ฐ์ ์ฌ์ฉ ํ ์๊ฐ ์๋ค
// System.out.println(a);
// The local variable a may not have been initialized at variable.Sample01.main(Sample01.java:29
a = 100; // ๋ณ์ a์ ๊ฐ์ ๋์
, ๋์
/ ์ ์ฅํ๋ ๊ฒ์ ์ฐ๋ฆฌ๋ '๋ณ์๋ฅผ ์ด๊ธฐํ ํ๋ค' ๋ผ๊ณ ํ๋ค.
System.out.println("a = " + a);
โป ์ค์ต - ์ ์
int num1 = 100; // ์์ ์ ์๊ฐ ์ ์ฅ
int num2 = -100; // ์์ ์ ์๊ฐ ์ ์ฅ
int num3 = 100_000_000; // ์๋ฆฟ์๋ฅผ ํํํ๋ ์ ์๊ฐ์ ์ ์ฅ
int num4 = 010; // 8์ง๋ฒ์ผ๋ก ํํ๋ ์ ์ ๊ฐ์ ์ ์ฅ
int num5 = 0x10; // 16์ง๋ฒ์ผ๋ก ํํใ
๋ ์ ์ ๊ฐ์ ์ ์ฅ
System.out.println("num1 ์ ๊ฐ : "+num1);
System.out.println("num2 ์ ๊ฐ : "+num2);
System.out.println("num3 ์ ๊ฐ : "+num3);
System.out.println("num4 ์ ๊ฐ : "+num4);
System.out.println("num5 ์ ๊ฐ : "+num5);
long num6 = 10_000_000_000L;
System.out.println("num6์ ๊ฐ : " + num6);
// ๊ณ์ฐ์ ๊ฒฐ๊ณผ๊ฐ int ๋ฒ์๋ฅผ ์ด๊ณผํ๋ ๊ฒฝ์ฐ
int num7 = 123456789;
int num8 = 123;
int num9 = num7*num8;
System.out.println("num9์ ๊ฐ : " + num9);
long num10 = num7 * num8;
System.out.println("long num10 ์ ๊ฐ : "+ num10);
// long ํ์
์ผ๋ก ๋ฐ๊ฟ์คฌ๋๋ฐ ์ ๊ฐ์ ๊ฐ์ธ - 1994684137 num9 ์ ๊ฐ๊ณผ ๊ฐ์๊ฑฐ์ง ?
long num11 = (long)num7 * num8;
System.out.println("num11์ ๊ฐ : "+num11);
/*
num1 ์ ๊ฐ : 100
num2 ์ ๊ฐ : -100
num3 ์ ๊ฐ : 100000000
num4 ์ ๊ฐ : 8
num5 ์ ๊ฐ : 16
num6์ ๊ฐ : 10000000000
num9์ ๊ฐ : -1994684137
*/
โป ์ค์ต - ์ค์ ( ์ค์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์ ? 2์ง๋ฒ ๋์ค๊ณ ๋๋ฆฌ ๋์ ์ดํด ๋ชปํจ)
// ์ค์ ์๋ฃํ
/*
*
* float , double
* ์ค์ํ์ default ์๋ฃํ์ double
* ์ค์๊ฐ์ ๋๋ถ๋ถ double ํ์
์ ๋ณ์๋ก ๋ค๋ฃฌ๋ค
* float ํ์
์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ฑฐ์ ์๋ค
*/
double num1 = 3.14;
double num2 = 123.4;
double num3 = 1.234e2; // e2๋ 10์ 2์ ๊ณฑ
// float num4 = 3.14;
float num4 = 3.14f;
// Type mismatch: cannot convert from double to float
// ์ค์์ ๊ธฐ๋ณธ ํ์
์ด double ์ด๊ธฐ ๋๋ฌธ์ ์ค์ ๊ฐ์ ์ธ์ ๋ double ํ์
์ ๊ฐ์ผ๋ก ์๊ฐํ๋ค
// ์ค์ ๊ฐ์ float ํ์
์ ๋ณ์์ ๋์
ํ ๋๋
// ์ค์ ๊ฐ์ double ์ด ์๋ floatํ์
์ผ๋ก ์๊ฐํ๊ฒ ํด์ผํ๋ค
// ๊ทธ๋์ ์ค์ ๊ฐ์ f ํน์ F๋ฅผ ๋ถ์ธ๋ค.
System.out.println("num1 ์ ๊ฐ : "+num1);
System.out.println("num2 ์ ๊ฐ : "+num2);
System.out.println("num3 ์ ๊ฐ : "+num3);
System.out.println("num4 ์ ๊ฐ : "+num4);
// ์ค์ ๊ฐ์ ์ฐ์ฐ
// ์ค์ ๊ฐ์ ์ฐ์ฐ์ ํ๋ก๊ทธ๋จ์์ ์ค์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์ ๋๋ฌธ์ด๋ผ๊ณ ํ๋ค
// ๊ณ์ฐ ๊ฒฐ๊ณผ์ ์ค์ฐจ๊ฐ ๋ฐ์ ํ ์ ์๋ค.
double num5 = 0.1;
double num6 = 0.2;
double num7 = num5 + num6;
System.out.println("num7 ์ ๊ฐ : "+num7 );
// ๊ฐ์ด ์ num7 ์ ๊ฐ : 0.30000000000000004 ?????????????
//
}
}
// ์ค์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์ : ๋ถ๋ ์์์ ๋ฐฉ์
/*
* ์ค์ = ๋ถํธ + ์ง์๋ถ + ๊ฐ์๋ถ
*
* Ex.
* -118.625 ๋ถ๋์์์ ๋ฐฉ์์ผ๋ก ์ ์ฅํ๊ธฐ (float ํ์
๊ธฐ์ค)
* ๋ถํธ๋นํธ(1๋นํธ) + ์ง์๋ถ (8๋นํธ) + ๊ฐ์๋ถ (23๋นํธ)
*
*
* 1. ์์ ์ด๊ธฐ ๋๋ฌธ์ ์ต์์ ๋ถํธ ๋นํธ๋ 1
* 2. ์ ๋๊ฐ 118.625๋ฅผ ์ด์ง๋ฒ์ผ๋ก ๋ณํ
* ์ ์๋ถ๋ฅผ ๋ณํ
* 118์ 2์ง๋ฒ์ผ๋ก ๋ฐ๊พธ๋ฉด 1110110
* 0.625๋ฅผ 2์ง๋ฒ์ผ๋ก ๋ฐ๊พธ๋ฉด 101
* ๊ฒฐ๊ณผ
* 118.625 ---> 1110110.101
* 3. ์์์ ์ ์ด๋์์ผ์ ์ ์๋ถ๊ฐ ํ์๋ฆฌ๊ฐ ๋๋๋ก ์กฐ์
* 1110110.101 ---> 1.110110101*2^6
* 4. ์ง์๋ถ์ 127์ ๋ํ๋ค
* 6 + 127 = 133 ---> 100000101
* 5. ๋ถ๋์์์ ๋ฐฉ์์ผ๋ก ์ ์ฅ๋ -118.625
* 1 10000101 1110110101
* ๋ถํธ ์ง์๋ถ ๊ฐ์๋ถ
*
* * ๋ถ๋ ์์์ ๋ฐฉ์์ผ๋ก ์ค์๋ฅผ ์ ์ฅํ๋ฉด
* 0.625 ๊ฐ์ด ์ด์ง์ ์์์ ์ผ๋ก ๋ฑ ๋จ์ด์ง๋ ์๋ ๋ฌธ์ ๊ฐ ์์ง๋ง 0.1 ๊ณผ ๊ฐ์ด
* 0.00011001100110011001100110011... ๋ก ๋ฌดํ๋ฐ๋ณต๋๋ ์ด์ง์ ์ค์๋ ์๋ฌด๋ฆฌ ํฐ ์๋ฅผ ์ ์ฅํ๋
* ๋ถ๋ ์์์ ๋ฐฉ์์ด๋ผ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ๊ณ ๋๋ฌธ์ ์ด๋ ๋ถ๋ถ์์ ๋์ด์ ๋ฐ์ฌ๋ฆผ ํ ์ ๋ฐ์ ์๋ค
*
* ์ปดํจํฐ์์ ์ค์ ๊ฐ์ ํํํ ๋๋ ๊ทธ ๊ฐ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฐ์ด ์ ์ฅ๋๋ค
*
* ์ค์ ๊ฐ์ ๊ณ์ฐ ๊ฒฐ๊ณผ๋ ์ฐ์ฐ์ค์ฐจ๊ฐ ๋ฐ์ํ ์ ์๋ค
*
*/
๐ ์ค์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์ ?
์ง์ ๊ฐ์๋ถ..?
๋ณํํ๊ณ ๋๋ฆฌ ๋ฌ๋ค ๊ทธ๋์ ์์ํ๊ฒ ์ดํด ๋ชป ํ๋ค!
double ๊ณผ float ๋ ์ดํดํ๊ณ ๊ดํ float ์จ์ F , f ์ฐ์ง๋ง๊ณ ๋ง์ ํธํ double ์ฌ์ฉํ์
โป ์ค์ต - ๋ฌธ์ํ
/*
* ๋ฌธ์ ์๋ฃํ
* char
* ๋ฌธ์ ์๋ฃํ ํ์
์ ๋ณ์๋ ์ค์ง 'ํ ๋ฌธ์๋ง' ์ ์ฅํ ์ ์๋ค.
* ๋ฌธ์ ์๋ฃํ์ ์ ๋ ์ฝ๋๋ฅผ ์ง์ํ๊ธฐ ๋๋ฌธ์ ์ ์ธ๊ณ์ ๋ชจ๋ ๊ธ์๋ฅผ ํํํ ์ ์๋ค.
*
* ๋ง์ฝ 1๊ธ์ ์ด์์ ์ ์ฅํ๋ ๊ฒฝ์ฐ String ๊ฐ์ฒด๋ฅผ ์ฌ์ฉ
* ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ฌธ์ ํ๋๋ก ์ด๋ฃจ์ด์ง ๊ฐ์ด๋ผ ํ๋๋ผ๋ char ๋ณด๋ค๋ String ํ์
์ผ๋ก ๋ค๋ฃฌ๋ค
*
*
*/
char ch1 = 'A';
char ch2 = '๊ฐ';
char ch3 = '\uAC00';
char ch4 = '\uAC01';
char ch5 = 65;
String st1 = "ABC";
String st2 = "๊ฐ๋๋ค๋ผ๋ง๋ฐ์ฌ";
System.out.println("ch1์ ๊ฐ : "+ch1); // ch1์ ๊ฐ : A
System.out.println("ch2์ ๊ฐ : "+ch2); // ch2์ ๊ฐ : ๊ฐ
System.out.println("ch2์ ๊ฐ : "+ch3); // ch3์ ๊ฐ : ๊ฐ
System.out.println("ch2์ ๊ฐ : "+ch4); // ch4์ ๊ฐ : ๊ฐ
System.out.println("ch5์ ๊ฐ : "+ch5);
โป ์ค์ต - ๋ฌธ์์ด
String s1 = "ํ๊ธธ๋";
String s2 = "์์ธ ํน๋ณ์ ์ข
๋ก๊ตฌ";
String s3 = "ํ๊ธธ๋ , ๊น์ ์ , ๊น์๋ฏผ , ๊ณฝ์ฌ์ฐ";
String s4 = "010 - 123 - 6294";
String s5 = "A";
// String s6 = 'A'; // Error : Type mismatch: cannot convert from char to String
// ๊ฐ๊ฐ์ ๋ณ์์ ์ ์ฅ๋ ๋ฌธ์์ด ์ถ๋ ฅ
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println(s5);
// ๊ฐ๊ฐ์ ๋ณ์์ ์ ์ฅ๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค
System.out.println(s1.length());
System.out.println(s2.length());
System.out.println(s3.length());
โป ์ค์ต - ๋ ผ๋ฆฌํ
boolean b1 = true;
boolean b2 = 100 < 10;
System.out.println(b1);
System.out.println(b2);
โป ์ค์ต - ํ๋ณํ
System.out.println(10 / 3);
System.out.println(10.0 / 3.0);
System.out.println(12 / 5.0); // 12 / 5.0 ->>> 12.0 / 5.0 ---- 2.4
System.out.println(12.0 / 5); // 12.0 / 5 ->>> 12.0 / 5.0 ---- 2.4
double num1 = 3; // ์ค์ ํ์
์ธ๋ฐ ๊ฐ์ด ์ ์ ?
// int num2 = 3.4; Type mismatch: cannot convert from double to int
// ๋ฐ์ดํฐ ์์ค ๋ฐ์
// ์๋ ํ๋ณํ ์ผ์ด๋ ์ ์์ด์ ์ค๋ฅ
โป ์ค์ต - ๊ฐ์ ํ๋ณํ
int num3 = (int) 3.14;
System.out.println("๊ฐ์ ํ๋ณํ : "+num3);
int kor = 80;
int eng = 70;
int math = 70;
int subCount = 3;
int total = kor + eng + math;
double avg = (double)total / subCount ;
System.out.println("ํ๊ท : "+avg);
'Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java (5) - ๋ฐฐ์ด (0) | 2023.10.27 |
---|---|
Java (4) ์ ์ด๋ฌธ - ๋ฐ๋ณต๋ฌธ + Scanner (1) | 2023.10.26 |
Java (4) ์ ์ด๋ฌธ - ์กฐ๊ฑด๋ฌธ (0) | 2023.10.26 |
Java (3) Operator ( ์ฐ์ , ๋์ , ์ฆ๊ฐ , ๋น๊ต , ๋ ผ๋ฆฌ , ์กฐ๊ฑด , ๋นํธ ) (0) | 2023.10.25 |
Java (1) OT - Java์ ๋ํด , ๊ฐ๋ฐํ๊ฒฝ ์ธํ (1) | 2023.10.23 |