๐ ์ฑ
์๊ฐํ๊ธฐ
๋ด๊ฐ ์ฌ์ฉํ ์๋ฐ์์ ์ ๋ณต ์ฑ
๋งํฌ!
ใด ๊น๋ํ ์ง์, ์ด์ง์คํผ๋ธ๋ฆฌ์ฑ
์ด ์ฑ ์ ๊ณ ๋ฅด๊ฒ ๋ ์ด์ ๋ ์น๊ตฌ์ ์ถ์ฒ์ด์๋ค. ๊ต์ฅํ ๊ผผ๊ผผํ๊ฒ ์ ํ์์ด ์ดํดํ๊ธฐ ์ฝ๋ค๋ ์ด์ ๋ก ์น๊ตฌ๋ ์ด ์ฑ ์ ๊ณจ๋๋ค๊ณ ํ๋ค. ๋๋ ๊ทธ๋์ ๊ทธ๋ฅ ๋ฐ๋ผ์๋ค. ์ค์ ๋ก ์ฑ ์ ์ดํด๋ณด๋ ๊ต์ฅํ ๊ผผ๊ผผํ๊ฒ ์ ๋ฆฌ๋์ด์๋ค. ๋ค๋ฅธ ์ฑ ์ ๋ณธ ์ ์ด ์์ด ๋น๊ต๊ฐ ๋ถ๊ฐํ์ง๋ง, ๋ด ์๊ฐ์ผ๋ก ์ฒ์ ์๋ฐ๋ฅผ ๊ณต๋ถํ๋ค๋ฉด ์ด ์ฑ ์ ๊ฐ์ง๊ณ ์ถฉ๋ถํ ๋ฐ๋ผ๊ฐ ์ ์์ ๋ฏ ํ๋ค. ๋ชจ๋๋ค ํ์ดํ !!
๐ฐ
โ๏ธ 1์ฐจ์ ๋ฐฐ์ด_ 151p
๋์ผํ ์๋ฃํ์ ๋ฌถ์ด ์ ์ฅํ๋ ์ฐธ์กฐ ์๋ฃํ
• ์ฐธ์กฐ์๋ฃํ
: ์ค์ ๊ฐ์ ๊ฐ๋๊ฒ์ด ์๋ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ์ “์ฃผ์ ๊ฐ”์ ๊ฐ์ง๋ ์๋ฃํ์ด๋ฉฐ, ํด๋น ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๋ณ์ ํ์ ์ ์๋ฏธํ๋ค.
• ์๋ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
: ํด๋์ค-์ ์ -์์- ๋ฉ์๋ ์์ญ , ์คํ ์์ญ(๋ชจ๋ ์ง์ญ ๋ณ์ ์์น), ํ ์์ญ(๊ฐ์ฒด๊ฐ ์์นํ๋ ๊ณต๊ฐ)
Q. ์ ์ญ๋ณ์์ ์ง์ญ๋ณ์๋?
A. ์ ์ญ๋ณ์๋ ํ๋ก๊ทธ๋จ์ ๋ชจ๋ ์์ญ์์ ์ ๊ทผํ ์ ์๋ ๋ณ์๋ก, ํจ์ ์ธ๋ถ, ํนํ ๋ชจ๋์ ์ต์์ ๋ ๋ฒจ์์ ์ ์ธํ๋ค. ๊ทธ๋ ๋ค๋ฉด ์ง์ญ๋ณ์๋ ํ์ ๋ ์์ญ์ธ ๋ธ๋ก, ํจ์, ๋ฉ์๋ ๋ด๋ถ์์ ์ฌ์ฉ๋๋ ๋ณ์๋ฅผ ๋งํ๋ค.
Class example { int globalVar = 1; // ์ ์ญ๋ณ์ void method() { int localVat = 2; // ์ง์ญ๋ณ์ } }โ
- ์ ์ญ๋ณ์์ ์ง์ญ๋ณ์ ์์ ์ถ์ฒ
• ๊ธฐ๋ณธ ๋ฐฐ์ด๊ณผ ๊ฐ์ฒด ๋์ ๋ฐฐ์ด
// ๊ธฐ๋ณธ์ ์ธ ๋ฐฐ์ด ํํ
new int[3];
// ๋ฐฐ์ด ์๋ฃํ ๋ณ์์ ๊ฐ์ฒด ๋์
ํ๊ธฐ
int[] a = new int[3];
// ๊ฐ ์
๋ ฅํ๊ธฐ
a[1] = 3;
a[2] = 2;
a[3] = 1;
1. int๋ ๋ฐฐ์ด ์๋ฃํ์ด๋ค.
2. a๋ ์ฐธ์กฐ ๋ณ์๋ค.
3. new๋ ํ ๋ฉ๋ชจ๋ฆฌ์ ๋ฃ์ด๋ผ๋ฅผ ๋ปํ๋ค.
4. int[3]์ int ์๋ฃํ 3๊ฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๊ณต๊ฐ์ด๋ค.
a๋ ์ฐธ์กฐ๋ณ์๋ก ์ค์ ๋ฐ์ดํฐ ๊ฐ์ ์ ์ฅํ๋ ๊ฒ์ด ์๋๋ค. ์ค์ ๋ฐ์ดํฐ๊ฐ์ '์์น๊ฐ'์ ์ ์ฅํ๋ ๊ฒ์ด๋ค. ์คํ ์์ญ์ ์ฃผ์๊ฐ์ ๊ทธ๋ฆฌ๊ณ ์ด ์ฃผ์๊ฐ์ ๊ฐ์ง๊ณ ํ ์์ญ์ ์ ๊ทผํ๋ค. ์ฆ ํ ์์ญ์ ๋ฐฐ์ด์ด ์ ์ฅ๋์ด์๋ค.
• 1์ฐจ์ ๋ฐฐ์ด์ ๋ค์ํจ
// ์์ฑ ํ ๊ฐ ๋์
int[] a = new int[3]; // ๊ฐ์ ์ด๊ธฐํ
a[0] = 3;
a[1] = 4;
a[2] = 5;
// ์์ฑ๊ณผ ํจ๊ป ๊ฐ ๋์
int[] a = new int[]{3, 4, 5} // ๊ฐ์ ์ด๊ธฐํ ์๋ต
// ๋์
ํ ๊ฐ๋ง ์
๋ ฅ (๋ถ๋ฆฌ ๋ถ๊ฐ๋ฅ)
int[] a = {3, 4, 5}
// ์ ์ธ๊ณผ ๊ฐ์ฒด ๋ถ๋ฆฌ ๊ฐ๋ฅ
int[] a;
a = new int[]{3, 4, 5}
Q. ๋ฐฐ์ด์ ์ด๋ป๊ฒ ์ ์ธํ๋์ง์ ๋ฐ๋ผ ์ฌ์ํ ๊ธฐ๋ฅ์ ์ธ ์ฐจ์ด๊ฐ ์๋๊ฐ?
A. ๋ ๋ฐฐ์ด์ ์ด๋ป๊ฒ ์ ์ธํ๋์ง์ ๋ฐ๋ฅธ ๊ธฐ๋ฅ์ ์ฐจ์ด์ ์ ์๋ค. ์ฝ๋์ ๊ฐ๋ ์ฑ, ์ ์ฐ์ฑ, ๋ช ํ์ฑ์ ๋์ด๊ธฐ ์ํด ๋ค๋ฅธ ํํ์ ๋ฐฐ์ด์ด ์กด์ฌํ๋ค.
• ์ฐธ์กฐ ๋ณ์์ ๋ฐฐ์ด ๊ฐ์ฒด์ ๊ฐ ์ด๊ธฐํ
: ๋ชจ๋ ๋ณ์๋ ์ด๊ธฐํ ์ดํ์ ์ถ๋ ฅ ๊ฐ๋ฅํ๋ค.
int a;
int[]b;
System.out.println(a);
System.out.println(b);
๊ฐ ๊ฐ์ ์ด๊ธฐํํ์ง ์์๊ธฐ์ ์ถ๋ ฅ์ด ๋ถ๊ฐ๋ฅํ๋ค. (์ค๋ฅ ๋ฐ์)
int a = 0; int[ ]b = null;
๊ธฐ๋ณธ ์๋ฃํ์ ์ด๊น๊ฐ์ผ๋ก๋ '๊ฐ', ์ฐธ์กฐ ์๋ฃํ์ ์ด๊น๊ฐ์ผ๋ก๋ 'null' ์ ์ฌ์ฉํ๋ค.
๊ธฐ๋ณธ์๋ฃํ์ ๊ธฐ๋ณธ๊ฐ
- boolean : false
- ์ ์ : 0
- ์ค์ : 0.0
์ฐธ์กฐ์๋ฃํ์ ๊ธฐ๋ณธ๊ฐ
- ํด๋์ค, ๋ฐฐ์ด ๋ฑ : null
โ๏ธ ์ฐธ์กฐ์๋ฃํ ๋ฐฐ์ด์ ํน์ง_ 151p
์ฐธ์กฐ์๋ฃํ์ ๊ธฐ๋ณธ์๋ฃํ๊ณผ ๋ค๋ฅด๊ฒ ๋ณต์ฌ ๊ฐ์ ์์ ํ๋ฉด ๋ณธ๋ ๊ฐ๋ ๋ณ๊ฒฝ๋๋ค.
• ์ฐธ์กฐ์๋ฃํ ๋ณ์ ๋ณต์ฌ
int[] a = {3, 4, 5}
int[] b = a;
b[0] = 7;
System.out.println(a[0]);
System.out.println(b[0]);
๊ฒฐ๊ณผ๊ฐ์ a[0]๊ณผ b[0]์ด 7๋ก ๋์ผํ๋ค.
Q. ์ ๋ณต์ฌ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด ๋ณธ๋๊ฐ๋ ๋ณ๊ฒฝ๋๋๊ฑธ๊น?
A. ์ฐธ์กฐ ์๋ฃํ ๋ณ์๋ฅผ ๋ณต์ฌํ๋ฉด ์ค์ ๋ฐ์ดํฐ๊ฐ ๋ณต์ฌ๋๋ ๊ฒ์ด ์๋๋ผ, ์ค์ ๋ฐ์ดํฐ์ ์์น๊ฐ์ ๋ณต์ฌ(์คํ ๋ฉ๋ชจ๋ฆฌ์ ์๋)ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ ๊ธฐ์ ํ๋์ ์ฐธ์กฐ ๋ณ์๋ฅผ ์ด์ฉํด ๋ฐ์ดํฐ๋ฅผ ์์ ํ๋ฉด ๋ค๋ฅธ ์ฐธ์กฐ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฐ์ดํฐ๋ ๋ณํ๊ฒ ๋๋ ๊ฒ์ด๋ค.
Q. ๊ธฐ๋ณธ์๋ฃํ์?
A. ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์ค์ ๋ฐ์ดํฐ๊ฐ์ ์ ์ฅํ๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ณธ ์๋ฃํ ๋ณ์๋ฅผ ๋ณต์ฌํ๋ฉด ์ค์ ๋ฐ์ดํฐ๊ฐ 1๊ฐ๊ฐ ๋ณต์ฌ๋๋ค. ๊ทธ๋ ๊ธฐ์ ์๋ฌด๋ฆฌ ๋ณ๊ฒฝํด๋ ์๋ณธ ๊ฐ์ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
int a = 3; int b = a; b = 7;
a๋ ์ฌ์ ํ 3์ด ๋์ค๊ณ b๋ 7์ด ๋๋ค.
โ๏ธ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด ๋ฐฐ์ด ๋ฐ์ดํฐ ์ฝ๊ธฐ_ 165p
ํฌ์ธํธ ์ฐ์ฐ์๋ฅผ ์ด์ฉ
• ํฌ์ธํธ์ฐ์ฐ์
int[] a = new int[100]
a[0] = 1, a[1] = 2, ... , a[99] = 100;
for(int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
ํฌ์ธํธ์ฐ์ฐ์๋ 'ํด๋น ์ฐธ์กฐ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ผ๋ก ๊ฐ๋ผ'๋ ์๋ฏธ์ด๋ค.
๋ฐฐ์ด์ฐธ์กฐ๋ณ์.length๋ '๋ฐฐ์ด ์ฐธ์กฐ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ ๊ฐ๋ฉด ๋ฐฐ์ด ๊ฐ์ฒด๊ฐ ์๋๋ฐ, ๊ทธ ๋ฐฐ์ด์ ๋ฐฉ์ ๊ฐ์๋ฅผ ๊ฐ์ ธ์ค๋ผ'๋ ์๋ฏธ์ด๋ค.
• for-each๋ฌธ
int[] a = new int[100];
a[0] = 1, a[1] = 2, ... , a[99] = 100;
for(int k: a) {
System.out.println(k);
}
for-each๋ฌธ์ ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์ ์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋๋ฐ ์ฌ์ฉ๋๋ ๊ฐ๊ฒฐํ ๋ฐ๋ชฉ๋ฌธ์ด๋ค.
for(int k: a)๋ for(์์ ์๋ฃํ ๋ณ์๋ช : ์งํฉ๊ฐ์ฒด)๋ก ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์ ๊ฐ์ฒด๋ฅผ ํตํด ์๋์ผ๋ก ์ธ๋ฑ์ค๋ฅผ ์ฒ๋ฆฌํ๊ณ , ์์๋ฅผ ์์ฐจ์ ์ผ๋ก ๊ฐ์ ธ์ ๋ณ์์ ํ ๋นํ๋ค.
โ๏ธ 2์ฐจ์ ์ ๋ฐฉ ํ๋ ฌ ๋ฐฐ์ด_ 169p
• 1์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ค๋ฅธ์
: ๋ฉ๋ชจ๋ฆฌ๋ 2์ฐจ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ก ์ ์ฅํ ์ ์๋ค. ์๋ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฐ์์ ์ธ ์ฃผ์ ๊ณต๊ฐ์ผ๋ก ๊ตฌ์ฑ๋ 1์ฐจ์ ๋ฐฐ์ด์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ ๊ธฐ์ 1์ฐจ์ ๋ฐ์ดํฐ๋ค๋ก ๋๋ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ฉฐ 2์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด์ ์์๋ก ํฌํจํ๊ณ ์๋ 1์ฐจ์ธ ๋ฐฐ์ด์ด๋ผ๊ณ ์๊ฐํ ์ ์๋ค.
Q. ๊ทธ๋ ๋ค๋ฉด 3์ฐจ์ ๋ฐฐ์ด์?
A. 3์ฐจ์ ๋ฐฐ์ด์ 2์ฐจ์ ๋ฐฐ์ด์ ์์๋ก ํฌํจํ๋ 1์ฐจ์ ๋ฐฐ์ด์ด๋ค. ํ๊ณผ ์ด ๊ทธ๋ฆฌ๊ณ ๋ฉด์ ํฌํจํ์ฌ 3์ฐจ์์ ์์ฑํ๋ค.
• 2์ฐจ์ ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
// ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ๊ฐ ๋์
int[][] a = new int[2][3];
a[0][0] = 1; a[0][1] = 2; a[0][2] = 3;
a[1][0] = 4; a[1][1] = 5; a[1][2] = 6;
a.length์ 2์ด๋ค. a์ธ 100๋ฒ์ง๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ 200๊ณผ 300์ด ์์ผ๋ 2๊ฐ ์ถ๋ ฅ๋๋ค.
a[0]์ 200๋ฒ์ง์ด๋ฉฐ 200๋ฒ์ง๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ผ๋ก ๊ฐ๋ 1๊ณผ 2, 3์ด ์๋ค. ๊ทธ๋ ๊ธฐ์ a[0].length๋ 3์ด ์ถ๋ ฅ๋๋ค.
๊ฐ ์ฃผ์๊ฐ์ด ๊ฐ๋ฆฌํค๋ ๊ณณ์ ๊ฐฏ์๋ฅผ ์๋ฉด ๋๋ค.
• ํ ์ฑ๋ถ๋ถํฐ ์์ฑํ๊ณ ์ด ์ฑ๋ถ ์์ฑ
// ํ ์ฑ๋ถ๋ถํฐ ์์ฑํ๊ณ ์ด ์ฑ๋ถ ์์ฑ
int[][] a = new int[2][]
a[0] = new int[]{1,2,3};
a[1] = new int[]{4,5,6};
ํ์ ๋จผ์ ์์ฑํ์ฌ 100๋ฒ์ง์ ์์ ํ์ ๊ฐฏ์๋ฅผ ๋ฏธ๋ฆฌ ์ ํด์ฃผ๋ ๊ฒ์ด๋ค. ์ด์ ๊ฐ์๋ ์ด์ฐจํผ 1์ฐจ์ ๋ฐฐ์ด๋ก ์ด์ด์ง๊ธฐ ๋๋ฌธ์ ๋ฏธ๋ฆฌ ์ ํด์ฃผ์ง ์์๋ ๋๋ค.
• ๋ฐฐ์ด์ ์๋ฃํ๊ณผ ํจ๊ป ๋์ ํ ๊ฐ ์ ๋ ฅ
: ๋๊ดํธ ์์ ๋ฐ๋์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ง ์๋๋ค.
int[][] a = new int[][] {{1, 2, 3}, {4, 5, 6}}
• ๋์ ํ ๊ฐ๋ง ์ ๋ ฅํ๊ธฐ
// ๋์
ํ ๊ฐ๋ง ์
๋ ฅ
int[][] a = {{1,2,3} , {4,5,6}};
โ๏ธ 2์ฐจ์ ๋น์ ๋ฐฉ ํ๋ ฌ ๋ฐฐ์ด_ 178p
ํ๋ง๋ค ์ด์ ๊ธธ์ด๊ฐ ๋ค๋ฅธ 2์ฐจ์ ๋ฐฐ์ด
• ์ด์ค for๋ฌธ์ ์ด์ฉํ 2์ฐจ์ ๋ฐฐ์ด ์์ ์ถ๋ ฅ
int[][] a = {{1, 2}, {3, 4, 5}}
for(int i = 0; i < a.length; i++) {
for(int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j]);
}
}
์ด์ ๊ธธ์ด๊ฐ ๋ค๋ฅด๋ ์ด์ ์ถ๋ ฅํ ๋ j < a[i].length;๋ฅผ ์จ์ค๋ค.
• ์ด์ค for-each๋ฌธ์ ์ด์ฉํ 2์ฐจ์ ๋ฐฐ์ด ์์ ์ถ๋ ฅ
int[][] a = {{1, 2, 3}, {4, 5, 6}};
for(int[] m: a) {
for(int n: m) {
System.out.println(n);
}
}
m์ ๋ฐฐ์ด a์ ๊ฐ ํ์ ์ฐธ์กฐํ๋ 1์ฐจ์ ๋ฐฐ์ด์ด ๋๋ค. ( a[0]๊ณผ a[1] )
n์ ๊ฐ ํ ์์ ์๋ ์์๋ค์ด ๋๋ค. a[0]์ ์๋ 1,2,3์ด ๊ฐ n์ด ๋๋ค.
'๐ Java > ์๋ฐ์์ ์ ๋ณต' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์๋ฐ ์์ ์ ๋ณต _6์ฅ ํด๋์ค์ ๊ฐ์ฒด์ ๊ฐ๋ (0) | 2024.11.13 |
---|---|
[Java] ์๋ฐ ์์ ์ ๋ณต_ 5์ฅ ์ฐธ์กฐ์๋ฃํ (๋ฌธ์์ด) (0) | 2024.10.31 |
[Java] ์๋ฐ ์์ ์ ๋ณต_ 4์ฅ ์ ์ด๋ฌธ (0) | 2024.08.05 |
[Java] ์๋ฐ ์์ ์ ๋ณต_ 3์ฅ ์ฐ์ฐ์ (0) | 2024.07.09 |
[Java] ์๋ฐ ์์ ์ ๋ณต_ 2์ฅ ์๋ฃํ (0) | 2024.07.02 |