์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 | 31 |
- Absolute
- AGI
- ai
- AI agents
- AI engineer
- AI researcher
- ajax
- algorithm
- Algorithms
- aliases
- Array ๊ฐ์ฒด
- ASI
- bayes' theorem
- Bit
- Blur
- BOM
- bootstrap
- canva
- challenges
- ChatGPT
- Today
- In Total
A Joyful AI Research Journey๐ณ๐
[22] 230130 Java Ch. 2 ๋ณ์์ ํ์ : 1. ๋ณ์, 2. ๊ธฐ๋ณธ ํ์ [K-๋์งํธ ํธ๋ ์ด๋ 22์ผ] ๋ณธ๋ฌธ
[22] 230130 Java Ch. 2 ๋ณ์์ ํ์ : 1. ๋ณ์, 2. ๊ธฐ๋ณธ ํ์ [K-๋์งํธ ํธ๋ ์ด๋ 22์ผ]
yjyuwisely 2023. 1. 30. 12:49230130 Mon 22nd class
Ch. 2 ๋ณ์์ ํ์
์ง๋: p. 59 ~ (๊ต์ฌ: ํผ์ ๊ณต๋ถํ๋ ์๋ฐ, ์ ์: ์ ์ฉ๊ถ)
์ค๋ ๋ฐฐ์ด ๊ฒ ์ค ๊ธฐ์ตํ ๊ฒ์ ์ ๋ฆฌํ๋ค.
์ง๋ ์์
๋ ๋ฐฐ์ด ๊ฒ ์ค ๋ค์ ๊ธฐ์ตํ ๊ฒ
parseInt()
๋ฌธ์์ด์ ์ซ์๋ก ๋ณํํ๋ค.
parse: to divide (a sentence) into grammatical parts and identify the parts and their relations to each other.
[Computing] analyse (a string or text) into logical syntactic components
syntactic: ๊ตฌ๋ฌธ๋ก ์(์ธ์ด ๋จ์ด ๊ฒฐํฉ์ผ๋ก ์ด๋ฃจ์ด์ง๋ ๋ฌธ์ฅ(ๆ็ซ )์ ๊ตฌ์กฐ๋ ๊ตฌ๋ฌธ(ๆงๆ) ์์๋ฅผ ๋ถ์ํจ์ผ๋ก์จ, ๊ฐ ๋ฌธ์ฅ ์ฑ๋ถ์ด ๊ตฌ์ฑ๋๋ ๊ท์น์ ์ฐ๊ตฌํ๋ ๋ถ์ผ.)
Ch. 2 ๋ณ์์ ํ์ p. 48
์ฑ ์ ๋ชฉ์ฐจ
02-1 ๋ณ์
02-2 ๊ธฐ๋ณธ ํ์
02-3 ํ์ ๋ณํ
02-4 ๋ณ์์ ์์คํ ์ ์ถ๋ ฅ
2.1 ๋ณ์ (Variable)
๋ณ์(Variable): ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ํน์ ๋ฒ์ง์ ๋ถ์ด๋ ์ด๋ฆ
์๋ฐ์คํฌ๋ฆฝํธ์ฒ๋ผ ์ ์ ๋ฃ๊ณ ๋ฌธ์ ๋ฃ๋ ๊ฑฐ ์ ๋๋ค.
var a;
var: ๋ณ์์์ ์๋ฆฌ๋ ๊ฒ. ํ์
์ด ์๋๋ค.
1) ๋ณ์ ์ ์ธ
๋ณ์ ์ ์ธ: ๋ณ์์ ์ด๋ค ํ์
(type)์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ง, ๋ณ์ ์ด๋ฆ์ด ๋ฌด์์ธ์ง ๊ฒฐ์ ํ๋ ๊ฒ์ด๋ค.
ํ์
(type) = ํ, ์๋ฃํ
ex) int, double
int age;
double value;
int: ์ ์(์์์ ์์)๋ฅผ ์ ์ฅํ ์ ์๋ age ๋ณ์ ์ ์ธ
ex) ์์์ ์๋ ์ซ์๋ฅผ ๋ฃ์ผ๋ฉด ์์์ ์ซ์๋ ๋ค ์๋ฆฐ๋ค.
double: ์ค์(์์์ ์๋ ์ซ์)๋ฅผ ์ ์ฅํ ์ ์๋ value ๋ณ์ ์ ์ธ
ex) 3์ด ์๋ 3.0์ผ๋ก ์ ์ฅ๋๋ค.
int x;
int y;
int z;
์ ์๋์ ๋์ผํ๋ค. ๊ฐ์ ํ์ ์ด๋ฉด ,๋ฅผ ์ด์ฉํด์ ํ๊บผ๋ฒ์ ์ ์ธํ ์ ์๋ค.
int x, y, z;
๋ณ์ ์ด๋ฆ ๋ช ๋ช ๊ท์น์ ๋ฐ๋ผ์ผ ํ๋ค.
์์ฑ ๊ท์น | ์ |
์ฒซ ๋ฒ์งธ ๊ธ์๋ ๋ฌธ์์ด๊ฑฐ๋ '$', '_'์ด์ด์ผ ํ๊ณ ์ซ์๋ก ์์ํ ์ ์๋ค. | ๊ฐ๋ฅ: price, $price, _companyName ๋ถ๊ฐ๋ฅ: 1v, @speed, $#value |
์์ด ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ๋ค. (ํ์) | firstname๊ณผ firstName์ ๋ค๋ฅธ ๋ณ์์ด๋ค. age์ Age๋ ๋ค๋ฅธ ๋ณ์์ด๋ค. |
์ฒซ ๋ฌธ์๋ ์์ด ์๋ฌธ์๋ก ์์ํ๋, ๋ค๋ฅธ ๋จ์ด๊ฐ ๋ถ์ ๊ฒฝ์ฐ ์ฒซ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ํ๋ค.(๊ด๋ก) ํด๋์ค ์ด๋ฆ์ด ๋๋ฌธ์์ด๊ธฐ ๋๋ฌธ์ด๋ค. |
maxSpeed, firstName, carBodyColor |
๋ฌธ์ ์(๊ธธ์ด)์ ์ ํ์ ์๋ค. | |
์๋ฐ ์์ฝ์ด๋ ์ฌ์ฉํ ์ ์๋ค. (ํ์) |
์์ฝ์ด: ์ด๋ฏธ ํด๋น ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์๋ฏธ๋ฅผ ๊ฐ๊ณ ์ฌ์ฉ๋๊ณ ์๋ ๋จ์ด
๋ณ์ ์ด๋ฆ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค. ๋ณ์ ์ด๋ฆ์ ์ ์ธํ๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
๋ถ๋ฅ | ์์ฝ์ด |
๊ธฐ๋ณธ ํ์ | boolean, byte, char, short, int, long, float, double ex) Int(๋๋ฌธ์๋ก ์์)๋ ๋๋ค. |
์ ๊ทผ ์ ํ์ | private, protected, public |
ํด๋์ค์ ๊ด๋ จ | class, abstract, interface, extends, implements, enum enum์ enumeration์ด๋ผ๋ ์ , ๊ณ์ฐ, ์ด๊ฑฐ, ๋ชฉ๋ก์ด๋ผ๋ ์์ด๋จ์ด์ ์๋ถ๋ถ๋ง ๋ฐ์ ๋ง๋ ์์ฝ์ด enumeration: the action of mentioning a number of things one by one |
๊ฐ์ฒด์ ๊ด๋ จ | new, instanceof, this, super, null |
๋ฉ์๋์ ๊ด๋ จ | void, return |
์ ์ด๋ฌธ๊ณผ ๊ด๋ จ | if, else, switch, case, default, for, do, while, break, continue |
๋ ผ๋ฆฌ๊ฐ | true, false |
์์ธ์ฒ๋ฆฌ์ ๊ด๋ จ | try, catch, finally, throw, throws |
๊ธฐํ | package, import, synchronized, final, static |
2) ๊ฐ ์ ์ฅ
๋์
์ฐ์ฐ์(=)๋ฅผ ์ฌ์ฉํ๋ค. ์ค๋ฅธ์ชฝ์ ๊ฐ์ ์ผ์ชฝ์ ๋ณ์์ ์ ์ฅํ๋ค.
ํ์
๋ณ์๋ช
= ๊ฐ;
int a = 10;
int score; //score ๋ณ์ ์ ์ธ
score = 90; //์ ์ธ๋ score ๋ณ์์ ๊ฐ 90 ์ ์ฅ: 90 -> score
int score = 90; //score ๋ณ์๋ฅผ ์ ์ธํจ๊ณผ ๋์์ ๊ฐ 90์ ์ ์ฅํ๋ค.
๋ณ์ ์ด๊ธฐํ: ๋ณ์์ ์ต์ด๋ก ๊ฐ์ด ์ ์ฅ๋ ๋ ๋ณ์๊ฐ ์์ฑ๋๋ค.
์ด๊ธฐ๊ฐ: ์ฌ์ฉ๋ ๊ฐ
์์ ์์ ์์ ์ด๊ธฐ๊ฐ: 90
3) ๋ณ์ ์ฌ์ฉ
์์ )
println์ ์จ์ ์ํฐ ํจ๊ณผ๊ฐ ์๋ค.
public class VariableUseExample {
public static void main(String[] args) {
int hour = 3;
int minute = 5;
System.out.println(hour+"์๊ฐ "+minute+"๋ถ");
int totalMinute=(hour*60)+minute;
System.out.println("์ด "+totalMinute+"๋ถ");
}
}
๊ฒฐ๊ณผ)
3์๊ฐ 5๋ถ
์ด 185๋ถ
๊ฐ ๋ฐ๊ฟ ๋ int temp ์ด๋ค.
์์ )
public static void main(String[] args) {
int x = 3;
int y = 5;
System.out.println("x: "+x+", y:"+y);
int temp = x; // x๊ฐ์ temp์ ์ ์ฅ (3์ temp๋ณ์์ ์ ์ฅ)
x = y; //y๊ฐ์ x์ ์ ์ฅ(5์ x์ ์ ์ฅํ๋ฏ๋ก x๋ 3->5)
y = temp; //temp๊ฐ์ y์ ์ ์ฅ(3๋ฅผ y์ ์ ์ฅํ๋ฏ๋ก y๋ 5->3)
System.out.println("x: "+x+", y:"+y);
}
๊ฒฐ๊ณผ)
x: 3, y:5
x: 5, y:3
4) ๋ณ์ ์ฌ์ฉ ๋ฒ์ p. 55
๋ก์ปฌ (์ง์ญ) ๋ณ์(local variable): ๋ฉ์๋ ๋ธ๋ก ๋ด์์ ์ ์ธ๋ ๋ณ์
๋ฉ์๋ ์คํ์ด ๋๋๋ฉด ๋ฉ๋ชจ๋ฆฌ์์ ์๋์ผ๋ก ์์ด์ง๋ค.
์ง์ญ๋ณ์๋ ๋ฌด์กฐ๊ฑด ์ด๊ธฐํํด์ค์ผ ํ๋ค. (์ด๊ธฐ๊ฐ์ ์ค๋ค.)
์์ )
public class VariableScopeExample {
public static void main(String[] args) {
int v1 = 15;
int v2 = 0;
if (v1>10) {
v2 = v1 - 10;
//v1, v2 ์ฌ์ฉ ๊ฐ๋ฅ
}
int v3 = v1 + v2 + 5;
//v2๋ฅผ if ๋ธ๋ก ์์ ๋๋ฉด if ๋๋๊ณ ์๋ฉธ์ด๋ฏ๋ก ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
System.out.println(v3);
//25 = 15 + 5 + 5
}
}
๊ฒฐ๊ณผ) ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
public class A{
int var 4;//์ ์ญ๋ณ์
public static void main(String[] args){
int var1;
if(...){
int var2;
//var1, var2 ์ฌ์ฉ ๊ฐ๋ฅ
}
for(...){
int var3;
//var1, var3 ์ฌ์ฉ ๊ฐ๋ฅ
}
//var1 ์ฌ์ฉ ๊ฐ๋ฅ
}
}
๋ณ์๋ฅผ ์ ์ธํ ๋ ์ฃผ์ ์ฌํญ
1. ๋ณ์๊ฐ ์ด๋ค ๋ฒ์์์ ์ฌ์ฉ๋ ๊ฒ์ธ์ง๋ฅผ ์๊ฐํ๊ณ , ์ ์ธ ์์น๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค.
2. ๋ฉ์๋ ๋ธ๋ก ์ ์ฒด์์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด ๋ฉ์๋ ๋ธ๋ก ์ฒซ๋จธ๋ฆฌ์ ์ ์ธํ๋ค.
๋ฉ์๋ ๋ธ๋ก: public static void main(String[] args)
3. ํน์ ๋ธ๋ก ๋ด๋ถ์์๋ง ์ฌ์ฉ๋๋ค๋ฉด ํด๋น ๋ธ๋ก ๋ด์์ ์ ์ธํ๋ค.
๋ง๋ฌด๋ฆฌ p. 57
1) ๋ณ์: ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ(ram) ๋ฒ์ง์ ๋ถ์ธ ์ด๋ฆ.
๋ณ์๋ฅผ ํตํด ํ๋ก๊ทธ๋จ์ ๋ฉ๋ชจ๋ฆฌ ๋ฒ์ง์ ๊ฐ์ ์ ์ฅํ๊ณ ์ฝ์ ์ ์๋ค.
ํ๋์ ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ณต๊ฐ. ํ๋ก๊ทธ๋จ์ ์ํด์ ์์๋ก ๊ฐ์ด ๋ณ๋๋ ์ ์๋ค. ํ๋์ ๋ณ์์๋ ์ค์ง ํ๋์ ๊ฐ๋ง ์ ์ฅํ ์ ์๊ณ , ์๋ฐ์์๋ ์ ์ธ๋ ๋ณ์์ ํ ๊ฐ์ง ์ข
๋ฅ์ ๊ฐ๋ง ์ ์ฅํ ์ ์๋ค.
- ๋ก์ปฌ ๋ณ์(์ง์ญ ๋ณ์): ๋ฉ์๋ ๋ธ๋ก ๋ด์์ ์ ์ธ๋ ๋ณ์. ๋ก์ปฌ ๋ณ์๋ ๋ฉ์๋ ์คํ์ด ๋๋๋ฉด ๋ฉ๋ชจ๋ฆฌ์์ ์๋์ผ๋ก ์์ด์ง๋ค.
- ๋ณ์ ์ ์ธ: ์ด๋ค ์๋ณ์๋ฅผ ๊ฐ๊ณ , ์ด๋ค ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ํ๋ ๋ณ์๋ผ๋ ๊ฒ์ ์๋ฆฌ๋ ๊ฒ
- ํ ๋น: ๋ณ์์ ๊ฐ์ ๋ฃ๊ฑฐ๋ ์ ์ฅํ๋ ๊ฒ์ด๋ค. (๋ฉ๋ชจ๋ฆฌ์ ๋ณ์์ ๊ฐ์ด ๋ค์ด๊ฐ ๊ณต๊ฐ์ ํ ๋นํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.)
- ์ฐธ์กฐ: ๋ณ์์ ์ ๊ทผํ๋ ๊ฒ์ด๋ค.
2) ๋ณ์ ์ ์ธ: ๋ณ์์ ์ด๋ค ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ง, ๋ณ์ ์ด๋ฆ์ด ๋ฌด์์ธ์ง ๊ฒฐ์ ํ๋ ๊ฒ์ด๋ค.
3) ๋ณ์ ์ฌ์ฉ: ๋ณ์์ ๊ฐ์ ์ฝ๊ฑฐ๋ ๋ณ๊ฒฝํ๋ ๊ฒ์ด๋ค. ๋ณ์๋ ์ถ๋ ฅ๋ฌธ์ด๋ ์ฐ์ฐ์ ๋ด๋ถ์์ ์ฌ์ฉ๋์ด ๋ณ์์ ์ ์ฅ๋ ๊ฐ์ ์ถ๋ ฅํ๊ฑฐ๋ ์ฐ์ฐ์ ์ฌ์ฉํ๋ค.
4) ๋ณ์ ์ฌ์ฉ ๋ฒ์: ๋ณ์๋ ์์ ์ด ์ ์ธ๋ ์์น์์ ์์ ์ด ์ํ ๋ธ๋ก ๋ด๋ถ๊น์ง๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๊ณ ๋ฐ์์๋ ์ฌ์ฉํ ์ ์๋ค.
2.2 ๊ธฐ๋ณธ ํ์ p. 59
์๋ฐ๊ฐ ์ ๊ณตํ๋ ๊ธฐ๋ณธ (primitive) ํ์
์ ์ด 8๊ฐ์ด๋ค.
๊ตฌ๋ถ | ์ ์ฅ๋๋ ๊ฐ์ ๋ฐ๋ฅธ ๋ถ๋ฅ | ํ์ ์ ์ข ๋ฅ |
๊ธฐ๋ณธ ํ์ | ์ ์ ํ์ | byte, char, short, int, long |
์ค์ ํ์ | float, double | |
๋ ผ๋ฆฌ ํ์ | boolean |
1) ์ ์ ํ์ p. 60
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํฌ๊ธฐ ์ ๋๋ ์๊ณ ์์ด์ผ ํ๋ณํ์ด ์ดํด๋๋ค.
ํ์ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํฌ๊ธฐ | ์ ์ฅ๋๋ ๊ฐ์ ํ์ฉ ๋ฒ์ | ||
byte | 1 byte | 8 bit | -2^7 ~ (2^7-1) | -128 ~ 127 |
short | 2 byte | 16 bit | -2^15 ~ (2^15-1) | -32,768 ~ 32,767 |
char | 2 byte | 16 bit | 0 ~ (2^16 - 1) | 0 ~ 65535(์ ๋์ฝ๋) |
int | 4 byte | 32 bit | -2^31 ~ (2^31 - 1) | -2,147,483,648 ~ 2,147,483,647 |
long | 8 byte | 64 bit | -2^63 ~ (2^63 - 1) | -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 |
๋ณดํต int๋ฅผ ์ด๋ค. ex) ์ผํ๋ชฐ ๊ฐ๊ฒฉ์ ์๊ฐํด ๋ณธ๋ค.
The bit is the most basic unit of information in computing and digital communications. The name is a portmanteau of binary digit. The bit represents a logical state with one of two possible values.
ํผ์ฑ์ด: A portmanteau (pronounced port-MAN-toe) is a word made by blending at least two words.
์ธ๊ฐ ์ธ๊ณ: 10์ง์
: 10
์ง์ ์ปดํจํฐ(๊ธฐ๊ณ์ด): 2์ง์
0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
์ผ๋จ ๋ถํธ ๋นํธ๋ ์ ์ฅ๋ ์๊ฐ ์์์ธ์ง ์์์ธ์ง ๊ตฌ๋ถํ๋ ค๋ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉ๋๋ค. ์ ์ฅํ๋ ค๋ ๋ชฉ์ ์ ๋ฐ๋ผ ๋ถํธ ๋นํธ๊ฐ ์์ ์๋ ์๊ณ ์์ ์๋ ์๋ค. ๋ง์ฝ ๋ถํธ ๋นํธ๊ฐ ์์ ๊ฒฝ์ฐ์๋ ๊ฐ์ฅ ๋์ ๋นํธ (10000000์์๋ 1์ด ๊ฐ์ฅ ๋์ ๋นํธ๊ฐ ๋๊ฒ ์ง์. ๋นํธ๋ 2์ง์์ ์๋ฆฟ์๋๊น์.)๊ฐ ๋ถํธ ๋นํธ๊ฐ ๋๋ค.
์ฐธ๊ณ : https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=kmc7468&logNo=220842771599
1. ์ ์ ๋ฆฌํฐ๋ด int
์์ )
2์ง์: 0๊ณผ 1์ ์ฌ์ฉํ๋ ์์ ์ฒด๊ณ (๊ธฐ๊ณ์ด)
8์ง์: 0, 1, 2, 3, 4, 5, 6, 7์ ์ฌ์ฉํ๋ ์์ ์ฒด๊ณ
10์ง์: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9๋ฅผ ์ฌ์ฉํ๋ ์์ ์ฒด๊ณ (์ธ๊ฐ)
16์ง์: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F๋ฅผ ์ฌ์ฉํ๋ ์์ ์ฒด๊ณ
public class IntegerLiteralExample {
public static void main(String[] args) {
int var1 = 0b1011; //2์ง์ (๊ธฐ๊ณ์ด)
int var2 = 0206; //8์ง์
int var3 = 365; //10์ง์ (์ธ๊ฐ)
int var4 = 0xB3; //16์ง์
System.out.println("var1: "+var1);
System.out.println("var2: "+var2);
System.out.println("var3: "+var3);
System.out.println("var4: "+var4);
}
}
๊ฒฐ๊ณผ)
var1: 11
var2: 134
var3: 365
var4: 179
2. byte ํ์ ๋ณ์
์์ ) byte ํ์ ์ ๋ฒ์๋ -128~127์ด๋ค.
public class ByteExample {
public static void main(String[] args) {
byte var1 = -128;
byte var2 = -30;
byte var3 = 0;
byte var4 = 30;
byte var5 = 127;
//byte var6 = 128;
System.out.println("var1: "+var1);
System.out.println("var2: "+var2);
System.out.println("var3: "+var3);
System.out.println("var4: "+var4);
System.out.println("var5: "+var5);
//System.out.println("var6: "+var6);
}
}
๊ฒฐ๊ณผ)
var1: -128
var2: -30
var3: 0
var4: 30
var5: 127
3. long ํ์ ๋ณ์
์์ ) long ํ์
๋ณ์: ์ ์ ๋ฆฌํฐ๋ด์ด int ํ์
์ ํ์ฉ ๋ฒ์ (-2,147,483,648 ~ 2,147,483,647)๋ฅผ ์ด๊ณผํ ๊ฒฝ์ฐ
์ ์ ๋ฆฌํฐ๋ด ๋ค์ ์๋ฌธ์ l์ด๋ ๋๋ฌธ์ L์ ๋ถ์ธ๋ค.
public class LongExample {
public static void main(String[] args) {
long var1 = 10;
long var2 = 20L;
//long var3 = 1000000000000;
long var4 = 1000000000000L;
System.out.println("var1: "+var1);
System.out.println("var2: "+var2);
//System.out.println("var3: "+var3);
System.out.println("var4: "+var4);
}
}
๊ฒฐ๊ณผ)
var1: 10
var2: 20
var4: 1000000000000
- ์๋ฐ์คํฌ๋ฆฝํธ์ ๋ค๋ฅด๊ฒ ์๋ฐ๋ ๋ฌธ์์ ๋ฌธ์์ด์ ๊ตฌ๋ถํ๋ค.
4. char ํ์ p. 63
๋ฌธ์: ํ ๊ธ์, ' (์์ ๋ฐ์ดํ)๋ก ๊ฐ์ผ๋ค. (ex. ๊ฐ, ๋, A, B)
๋ฌธ์๋ ์ ์ฅํ๊ณ ์ซ์๋ ์ ์ฅํ๋ค.
char a = '์';
ex) ์ฑ๋ณ (๋จ, ๋
) (M, F)
char var1 = 'A';
char var2 = 'B';
char var3 = '๊ฐ';
char var4 = '๊ฐ';
char c = 65; //10์ง์
car c = 0x0041; //16์ง์
์ ๋์ฝ๋(unicode): ์ธ๊ณ ๊ฐ๊ตญ์ ๋ฌธ์๋ค์ ์ฝ๋๊ฐ์ผ๋ก ๋งคํํ ๊ตญ์ ํ์ค ๊ท์ฝ์ด๋ค.
์ ๋์ฝ๋๋ ํ๋์ ๋ฌธ์์ ๋ํด ํ๋์ ์ฝ๋๊ฐ์ ๋ถ์ฌํ๊ธฐ ๋๋ฌธ์ ์๋ฌธ 'A' ๋ฐ ํ๊ธ '๊ฐ'๋ ํ๋์ ์ฝ๋ ๊ฐ์ ๊ฐ์ง๋ค.
์๋ฐ๋ ๋ชจ๋ ๋ฌธ์๋ฅผ ์ ๋์ฝ๋๋ก ์ฒ๋ฆฌํ๋ค.
์์คํค ์ฝ๋ํ:
ASCII, abbreviated from American Standard Code for Information Interchange, is a character encoding standard for electronic communication. ASCII codes represent text in computers, telecommunications equipment, and other devices.
ex) ๋ฌธ์ 'A'๋ 65๋ผ๋ ์ ๋์ฝ๋๋ฅผ ๊ฐ์ง๋ค.
ํ๊ธ: UNICODE HANGUL SYLLABLES
์ฐธ๊ณ : https://blog.makebyhand.co.kr/227
https://en.wikipedia.org/wiki/Hangul_Syllables
์์ ) char ํ์
public class CharExample {
public static void main(String[] args) {
char c1 = 'A'; //๋ฌธ์๋ฅผ ์ง์ ์ ์ฅ
char c2 = 65; //10์ง์๋ก ์ ์ฅ
char c3 = '\u0041'; //16์ง์๋ก ์ ์ฅ
char c4 = '๊ฐ'; //๋ฌธ์๋ฅผ ์ง์ ์ ์ฅ
char c5 = 44032; //10์ง์๋ก ์ ์ฅ
char c6 = '\uac00'; //16์ง์๋ก ์ ์ฅ
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
}
}
๊ฒฐ๊ณผ) ์์ ์์คํค์ฝ๋ํ์์ ์ ์ ์๋ฏ์ด 65๋ A์ด๋ค. (10์ง์)
\u: 16์ง์ ์ ๋์ฝ๋์ ํด๋นํ๋ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ๋ค. 0041: A (16์ง์)
44032: ๊ฐ (UNICODE HANGUL SYLLABLES)
\uac00: ๊ฐ (Hangul Syllables is a Unicode block containing precomposed Hangul syllable blocks for modern Korean.)
A
A
A
๊ฐ
๊ฐ
๊ฐ
5. String ํ์ p. 64
์์๋ฐ์ดํ(')๋ก ๊ฐ์ผ ๋ฌธ์๋ char ํ์
๋ณ์์ ์ ์ฅ๋์ด ์ ๋์ฝ๋๋ก ์ ์ฅ๋์ง๋ง,
ํฐ๋ฐ์ดํ(")๋ก ๊ฐ์ผ ๋ฌธ์ ๋๋ ์ฌ๋ฌ ๊ฐ์ ๋ฌธ์๋ค์ ์ ๋์ฝ๋๋ก ๋ฐํ๋์ง ์๋๋ค.
์ฐธ์กฐํ ํ์
์ด๋ค. ๊ธฐ๋ณธํ ํ์
X. String์ด๋ผ๋ ๊ฐ์ฒด๋ก ์ ์ฅํ๋ค.
์ฐธ์กฐํ ๋ณ์๋ ๊ธฐ๋ณธํ ๋ณ์์๋ ๋ค๋ฅด๊ฒ ์ค์ ๊ฐ์ ๊ทธ๋๋ก ์ ์ฅํ๋ ๊ณต๊ฐ์ด ์๋๋ผ
Heap์์ญ์ ๊ฐ์ด ์ ์ฅ๋ ๊ณต๊ฐ์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๋ ๊ณต๊ฐ์ด๋ผ๋ ๊ฒ์ด๋ค.
์ฆ, ๊ธฐ๋ณธํ ๋ณ์๋ ์ค์ ๊ฐ์ ์ ์ฅํ๊ณ ์ฐธ์กฐํ ๋ณ์๋ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๊ณ ์๋ ๊ฒ์ด๋ค.
์ฐธ๊ณ : https://colossus-java-practice.tistory.com/7
๋ฌธ์์ด(๋ฌธ์ + ๋ฐฐ์ด): " (ํฐ ๋ฐ์ดํ)๋ก ๊ฐ์ผ๋ค. (ex. ์๋
, ์๋
ํ์ธ์)
๋ฌธ์ ํ๋ํ๋๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
String b = "์๋
ํ์ธ์";
ex) ์์ด๋, ๋น๋ฐ๋ฒํธ (๋ฌธ์, ์ฌ๋ฌ ๊ธ์์ด๋ฏ๋ก)
ex) ์ฑ๋ณ (๋จ์, ์ฌ์)๋ก ์ ์ฅ
ex) ์ ํ๋ฒํธ๋ฅผ ์ ์ ํ์
์ผ๋ก ์ ์ฅํ๋ฉด 010์ 0์ ์์ด์ง๋ค. (cf. ๋์ด๋ int)
- ์ด์ค์ผ์ดํ(escape) ๋ฌธ์: ๋ฌธ์์ด ๋ด๋ถ์ \(์ญ์ฌ๋์)๊ฐ ๋ถ์ ๋ฌธ์
\ + ์ฌ์ฉํ๊ณ ์ถ์ ํน์ ๋ฌธ์ (ex. \"์๋ฐ\")
์ด์ค์ผ์ดํ ๋ฌธ์ | ์ถ๋ ฅ ์ฉ๋ |
\t | ํญ๋งํผ ๋์ด๋ค. |
\n | ์ค ๋ฐ๊ฟ(๋ผ์ธ ํผ๋) ์์คํ : unix, window |
\r | ์บ๋ฆฌ์ง๋ฆฌํด ์์คํ : mac, window |
\" | " ์ถ๋ ฅ |
\' | ' ์ถ๋ ฅ |
\\ | \ ์ถ๋ ฅ |
\u16์ง์ | 16์ง์ ์ ๋์ฝ๋์ ํด๋นํ๋ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ๋ค. |
\n is specifically used to move to a new line,
while \r is used for a carriage return, which moves the cursor back to the beginning of the current line.
์์ )
public class EscapeExample {
public static void main(String[] args) {
System.out.println("๋ฒํธ\t์ด๋ฆ\t์ง์
");
System.out.println("ํ ๋จ์ ์ถ๋ ฅ\n");
System.out.println("ํ ๋จ์ ์ถ๋ ฅ\n");
System.out.println("์ฐ๋ฆฌ๋ \"๊ฐ๋ฐ์\"์
๋๋ค.");
System.out.println("๋ด\\์ฌ๋ฆ\\๊ฐ์\\๊ฒจ์ธ");
}
}
๊ฒฐ๊ณผ)
๋ฒํธ ์ด๋ฆ ์ง์
ํ ๋จ์ ์ถ๋ ฅ
ํ ๋จ์ ์ถ๋ ฅ
์ฐ๋ฆฌ๋ "๊ฐ๋ฐ์"์
๋๋ค.
๋ด\์ฌ๋ฆ\๊ฐ์\๊ฒจ์ธ
2) ์ค์ ํ์ p. 66
ํ์ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํฌ๊ธฐ | ์ ์ฅ๋๋ ๊ฐ์ ํ์ฉ ๋ฒ์(์์ ๊ธฐ์ค) | ์ ๋ฐ๋(์์์ ์ดํ ์๋ฆฌ) | |
float | 4byte | 32bit | (1.4*10^-45) ~ (3.4*10^38) | 7์๋ฆฌ |
double | 8byte | 64bit | (4.9*10^-324) ~ (1.8*10^308) | 15์๋ฆฌ |
์๋ฐ๋ ์ค์ ๋ฆฌํฐ๋ด์ ๊ธฐ๋ณธ์ ์ผ๋ก double ํ์
์ผ๋ก ํด์ํ๊ธฐ ๋๋ฌธ์ double ํ์
๋ณ์์ ์ ์ฅํด์ผ ํ๋ค.
์ค์ ๋ฆฌํฐ๋ด์ float ํ์
์ผ๋ก ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด ๋ฆฌํฐ๋ด ๋ค์ ์๋ฌธ์ f๋ ๋๋ฌธ์ F๋ฅผ ๋ถ์ฌ ์ปดํ์ผ๋ฌ๊ฐ FLOAT ํ์
์์ ์ ์ ์๋๋ก ํด์ผ ํ๋ค.
double ํ์ ์ float ํ์ ๋ณด๋ค 2๋ฐฐ ์ ๋ ์ ๋ฐ๋๊ฐ ๋๊ธฐ ๋๋ฌธ์ ์ข ๋ ์ ํํ ๋ฐ์ดํฐ ์ ์ฅ์ด ๊ฐ๋ฅํ๋ค.
์์ )
public class FloatDoubleExample {
public static void main(String[] args) {
float var2 = 3.14f;
double var3 = 3.14;
System.out.println("var2: "+var2);
System.out.println("var3: "+var3);
//๋ฐ์ดํฐ ์์ค ๋ฐฉ์ง๋ก float ํ์
์ด double ํ์
์ฒ๋ผ ์ฑ์ฐ๋ ค๊ณ ํ๋ฏ๋ก ๋์ ๊ฐ์ ๊ฐ์ง ์๋ค. (์ ๋ฐ๋๊ฐ ๋ค๋ฅด๋ค.)
float var4 = 0.123456789f;
double var5 = 0.123456789;
System.out.println(var4==var5);
//e ์ฌ์ฉํ๊ธฐ
double var6 = 3e6;
float var7 = 3e6F;
double var8 = 2e-3;
System.out.println("var6: "+var6);
System.out.println("var7: "+var7);
System.out.println("var8: "+var8);
}
}
๊ฒฐ๊ณผ) ๋ฐ์ดํฐ ์์ค ๋ฐฉ์ง๋ก float ํ์
์ด double ํ์
์ฒ๋ผ ์ฑ์ฐ๋ ค๊ณ ํ๋ฏ๋ก ๋์ ๊ฐ์ ๊ฐ์ง ์๋ค. (์ ๋ฐ๋๊ฐ ๋ค๋ฅด๋ค.)
var2: 3.14
var3: 3.14
false
var6: 3000000.0
var7: 3000000.0
var8: 0.002
e๋ ์ง์์ด๋ค. ex) 3e6 = 3*10^6, 2e-3 = 2*10^-3
3) ๋ ผ๋ฆฌ ํ์
์ฐธ๊ณผ ๊ฑฐ์ง์ ์๋ฏธํ๋ ๋ ผ๋ฆฌ ๋ฆฌํฐ๋ด๋ก true์ false๋ฅผ ์ฌ์ฉํ๋ค. 1byte ํฌ๊ธฐ์ boolean ํ์ ๋ณ์์ ์ ์ฅํ ์ ์๋ค.
boolean stop = true;
boolean state = false;
์์ ) boolean ํ์
public class BooleanExample {
public static void main(String[] args) {
boolean stop = true;
if(stop) {
System.out.println("์ค์งํฉ๋๋ค.");
}
else {
System.out.println("์์ํฉ๋๋ค.");
}
}
}
๊ฒฐ๊ณผ) stop ๋ณ์๊ฐ true ๊ฐ์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ if ๋ธ๋ก์ด ์คํ๋์ด "์ค์งํฉ๋๋ค."๊ฐ ์ถ๋ ฅ๋๋ค.
์ค์งํฉ๋๋ค.
๋ง๋ฌด๋ฆฌ p. 70
1) ์ ์ ํ์
: ์ ์๋ฅผ ์ ์ฅํ ์ ์๋ ํ์
ex) byte, short, int, long
2) char ํ์
: ์์๋ฐ์ดํ(')๋ก ๊ฐ์ผ ํ๋์ ๋ฌธ์ ๋ฆฌํฐ๋ด์ ์ ์ฅํ ์ ์๋ ํ์
๋ฆฌํฐ๋ด(literal): ์์ค ์ฝ๋์์ ํ๋ก๊ทธ๋๋จธ์ ์ํด ์ง์ ์
๋ ฅ๋ ๊ฐ
In computer science, a literal is a notation for representing a fixed value in source code.
3) String ํ์
: ํฐ๋ฐ์ดํ(")๋ก ๊ฐ์ผ ๋ฌธ์์ด์ ์ ์ฅํ ์ ์๋ ํ์
์ฐธ์กฐํ ํ์
์ด๋ค. ๊ธฐ๋ณธํ ํ์
X.
4) ์ค์ ํ์
: ์ค์(์์์ ์ด ์๋ค.)๋ฅผ ์ ์ฅํ ์ ์๋ ํ์
ex) float, double
5) boolean ํ์
: ์ฐธ๊ณผ ๊ฑฐ์ง์ ์๋ฏธํ๋ true์ false๋ฅผ ์ ์ฅํ ์ ์๋ ํ์