[ TIL - 220912 ]
โจ ๋ฐฐ์ด์
๐JAVA ๋ฌธ๋ฒ
# ์๋ฐ์ ํ์
- ๊ธฐ๋ณธํ์
primitive type
- ์ฐธ์กฐ ํ์
reference type : ๊ฐ์ฒด์ ๋ฒ์ง๋ฅผ ์ฐธ์กฐํ๋ ํ์
( ๋ฐฐ์ด, ์ด๊ฑฐ ํด๋์ค, ์ธํฐํ์ด์ค )
# ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ์์ญ Runtime Data Area
- ๋ฉ์๋ ์์ญ Method Area = data
: JVM์ด ์์ํ ๋ ์์ฑ๋๊ณ ๋ชจ๋ ์ค๋ ๋๊ฐ ๊ณต์ ํ๋ ์์ญ
ํด๋์ค ๋ก๋ -> ํด๋์ค๋ณ ์ ์ ํ๋์ ์์, ๋ฉ์๋ ์ฝ๋, ์์ฑ์ ์ฝ๋ ๋ฑ์ ๋ถ๋ฅํด ์ ์ฅ
- ํ ์์ญ Heap Area
: ๊ฐ์ฒด์ ๋ฐฐ์ด์ด ์์ฑ๋๋ ์์ญ ( JVM ์คํ ์์ญ์ ๋ณ์์ ๋ค๋ฅธ ๊ฐ์ฒด์ ํ๋์์ ์ฐธ์กฐ ) ๋์ ํ ๋น
-> ์ฐธ์กฐํ๋ ๋ณ์๋ ํ๋๊ฐ ์์ผ๋ฉด ์๋ฏธ ์๋ ๊ฐ์ฒด๊ฐ ๋์ด grabage collector ์คํ์์ผ ์๋ ์ ๊ฑฐ , ํด๋์ค์ ๋ฉค๋ฒ๋ณ์
- JVM ์คํ Stack
: ๋ฉ์๋ ํธ์ถํ ๋๋ง๋ค ํ๋ ์ ์ถ๊ฐpush , ๋ฉ์๋ ์ข
๋ฃ๋๋ฉด ํด๋น ํ๋ ์ ์ ๊ฑฐ pop
-> ํ๋ ์ ๋ด๋ถ ๋ก์ปฌ ๋ณ์ ์คํ์ด ์๋๋ฐ, ๊ธฐ๋ณธ ํ์
๋ณ์์ ์ฐจ๋ชพ ํ์
๋ณ์๊ฐ ์ถ๊ฐpush ๋๊ฑฐ๋ ์ ๊ฑฐ pop
-> ์คํ ์์ญ์ ๋ณ์๊ฐ ์์ฑ๋๋ ์์ ( ์ด๊ธฐํ : ์ต์ด๋ก ๋ณ์์ ๊ฐ์ด ์ ์ฅ๋ ๋ )
๋ณ์๋ ์ ์ธ๋ ๋ธ๋ก ์์์๋ง ์คํ ์กด์ฌ, ๋ธ๋ก ๋ฒ์ด๋๋ฉด ์คํ์์ ์ ๊ฑฐ ( if ๋ธ๋ก )

scores ๋ฐฐ์ด ๋ณ์๋ stack์์ญ์ ์์ฑ๋์ง๋ง ( ํ ์์ญ์ ์ฃผ์ ์ ์ฅ ) , ์ค์ 10,20,30โ์ ํ ์์ญ์ ์์ฑ
์๋ฐ๋ ๋ฐฐ์ด์ ๊ฐ์ฒด๋ก ์ทจ๊ธ

int [ ] scores = { 10,20,30 }
* ์ฐธ์กฐ ๋ณ์์ == , != ์ฐ์ฐ
- ๋์ผํ ๋ฒ์ง = ๋์ผํ ๊ฐ์ฒด ์ฐธ์กฐ
* null / NullPointerException
* String
String ๋ณ์ = โ ๋ฌธ์์ด โ ;
String name;
name = โ์ ์ฉ๊ถโ;
String hobby = โ์๋ฐโ;
>> ์ฌ์ค ๋ฌธ์์ด์ String ๋ณ์์ ์ ์ฅํ๋ค๋ ๋งโ์ ์๋ฐํ ๋งํด ํ๋ฆฐ ํํ
String name1= โ๋ฐ์คโ;
String name2= โ๋ฐ์คโ;
name1๊ณผ name2๋ ๋์ผํ String ๊ฐ์ฒด ์ฐธ์กฐ
์ผ๋ฐ์ ์ผ๋ก ๋ณ์์ ๋ฌธ์์ด ์ ์ฅ : ๋ฌธ์์ด ๋ฆฌํฐ๋ด ์ฌ์ฉ
String name1= new String(โ๋ฐ์คโ);
String name2= new String(โ๋ฐ์คโ);
ํด๋์ค (๊ฐ์ฒด) ์์ฑ : ํด๋์ค ์ค์ ์ฌ์ฉํ ์ ์๋๋ก ๋ฉ๋ชจ๋ฆฌ๊ณต๊ฐ(ํ๋ฉ๋ชจ๋ฆฌ) ํ ๋น
ํด๋์คํ ๋ณ์์ด๋ฆ = new ์์ฑ์ ; String(); ์ด ์์ฑ์ ์ธ ๊ฒ
new ์ฐ์ฐ์ : ํ ์์ญ์ ์๋ก์ด ๊ฐ์ฒด ๋ง๋ค ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์ ( ๊ฐ์ฒด ์์ฑ ์ฐ์ฐ์ )
์ด ๊ฒฝ์ฐ name1๊ณผ name2๋ ๋ค๋ฅธ string ๊ฐ์ฒด ์ฐธ์กฐ
* ์์ฑ์ : ํด๋์ค ์ฒ์ ๋ง๋ค ๋ ๋ฉค๋ฒ ๋ณ์๋ ์์ ์ด๊ธฐํ ( Person() ๊ฐ์ ํจ์ )
** ์์ฑ์ ์ด๋ฆ = class ์ด๋ฆ
** ์์ฑ์๋ ๋ฐํ๊ฐ ์์
** ๊ฐ์ String๊ฐ์ฒด์ธ์ง ์๊ด์์ด ๋ด๋ถ ๋ฌธ์์ด ๋น๊ตํ๊ณ ์ถ์ ใธใ
-> equals () ๋ฉ์๋ ์ฌ์ฉ : boolean result = str1.equals(str2); //str1 ๊ณผ str2๋ ์ฐจ๋ก๋ก ์๋ณธ ๋ฌธ์์ด๊ณผ ๋น๊ต ๋ฌธ์์ด
๋ฐฐ์ด
: ๊ฐ์ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ฐ์๋ ๊ณต๊ฐ์ ๋์ดํ๊ณ ๊ฐ ๋ฐ์ดํฐ์ ์ธ๋ฑ์ค ๋ถ์ฌํด๋์ ์๋ฃ๊ตฌ์กฐ
์ธ๋ฑ์ค๋ 0๋ถํฐ ์์
- ๊ฐ์ ํ์
์ ๋ฐ์ดํฐ๋ง ์ ์ฅ ( Type mismatch . error )
- ํ ๋ฒ ์์ฑ๋ ๋ฐฐ์ด์ ๊ธธ์ด ๋๋ฆฌ๊ฑฐ๋ ์ค์ผ ์ ์์
๋ฐฐ์ด ์ ์ธ
ํ์ 1.
ํ์
[ ] = ๋ณ์ ;
ex ) int [ ] = intArray ;
ํ์ 2.
ํ์
๋ณ์ [ ] ;
ex ) int intArray [ ] ;
๋ฐฐ์ด์ ๊ฐ์ฒด์ด๋ฏ๋ก ํ ์์ญ์ ์์ฑ, ๋ฐฐ์ด ๋ณ์๋ ํ ์์ญ์ ๋ฐฐ์ด ๊ฐ์ฒด ์ฐธ์กฐ, ์ฐธ์กฐํ ๋ฐฐ์ด ๊ฐ์ฒด ์๋ค๋ฉด ๋ฐฐ์ด๋ณ์๋ null๊ฐ์ผ๋ก ์ด๊ธฐํ๋ ์ ์์
ํ์
[ ] = ๋ณ์ null;
๋ฐฐ์ด ๊ฐ์ฒด ์์ฑ
-> ๊ฐ ๋ชฉ๋ก ์ด์ฉ
ํ์
[ ] ๋ณ์ = { 1, 2, 3, 4, 5 }; // ์ค๊ดํธ { } ๋ ์ฃผ์ด์ง ๊ฐ๋ค์ ํญ๋ชฉ์ผ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ํ์ ์์ฑํ๊ณ , ๋ฐฐ์ด ๊ฐ์ฒด์ ๋ฒ์ง๋ฅผ ๋ฆฌํด!
-> new ์ฐ์ฐ์ ์ด์ฉ
package sec02.exam01;
public class ArrayCreateByValueListExample {
public static void main ( String [ ] args ) {
int[] scores = {83, 90, 87};
System.out.println("scores[0] : " + scores[0]);
System.out.println("scroes[1] : " + scores[1]);
System.out.println("scores[2] : " + scores[2]);
int sum= 0;
for(int i=0; i<3; i++) {
sum += scores[i];
}
System.out.println("์ดํฉ" + sum);
double avg = (double) sum / 3;
System.out.println("ํ๊ท :"+avg);
}
}
- > ์ฃผ์ํ ์ : ๊ฐ์ ๋ชฉ๋ก์ผ๋ก ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ ๋ฐฐ์ด ๋ณ์๋ฅผ ์ด๋ฏธ ์ ์ธํ ํ์๋ ๋ค๋ฅธ ์คํ๋ฌธ์์ ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ ๋ฐฐ์ด ์์ฑ์ด ํ์ฉ๋์ง ์์, ์ด๋ฏธ ์ ์ธ๋ ๋ฐฐ์ด ๋ณ์์ ์ค๊ดํธ ์ด์ฉํ ๋ฐฐ์ด ์์ฑํ๋ ค๋ฉด new ์ฐ์ฐ์ ์ด์ฉ
๋ฐฐ์ด ๋ณ์ ๋ฏธ๋ฆฌ ์ ์ธํ ํ ๊ฐ ๋ชฉ๋ก๋ค์ด ๋์ค์ ๊ฒฐ์ ๋๋ ์ํฉ์ด๋ผ๋ฉด new ์ฐ์ฐ์ ์ฌ์ฉํด ๊ฐ ๋ชฉ๋ก ์ง์ ํด์ฃผ๋ฉด ๋จ
๋ณ์ = new ํ์
[ ] { 1, 2, 3, 4, 5 };
ex) String [ ] names = null ;
names = new String [ ] { " ์ ์ฉ๊ถ ", " ํ๊ธธ๋ " , " ๊น์๋ฐ " };
๋ฉ์๋์ ๋งค๊ฐ๊ฐ์ด ๋ฐฐ์ด์ผ ๊ฒฝ์ฐ๋ ๋ง์ฐฌ๊ฐ์ง
์์
int add(int[] scores) {...}
int result = add ( new int[] {95, 85, 90} ); // ๊ผญ ์ด๋ ๊ฒ new์ฐ์ฐ์ ์จ์ฃผ์ด์ผํจ
-> new ์ฐ์ฐ์ ์ด์ฉ
: ๊ฐ์ ๋ชฉ๋ก์ ๊ฐ์ง๊ณ ์์ง ์์ง๋ง, ํฅํ ๊ฐ๋ค์ ์ ์ฅํ ๋ฐฐ์ด์ ๋ฏธ๋ฆฌ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด new์ฐ์ฐ์๋ก ๋ฐฐ์ด ๊ฐ์ฒด ์์ฑ
ํ์
[ ] ๋ณ์ = new ํ์
[ ๊ธธ์ด ] ;
์ด๋ฏธ ๋ฐฐ์ด ๋ณ์๊ฐ ์ ์ธ๋ ๊ฒฝ์ฐ์๋ new ์ฐ์ฐ์๋ก ๋ฐฐ์ด ์์ฑ ๊ฐ๋ฅ
//์์
int[] intArray = new int[5];
๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด ์์ฑ ์์ ๊ธฐ๋ณธ๊ฐ
int, short, byte : 0
char : \u0000
long : 0L
float : 0.0F
double : 0.0
boolean : false
class interface String : null
๋ฐฐ์ด ๊ธธ์ด : ๋ฐฐ์ด์ ์ ์ฅํ ์ ์๋ ์ ์ฒด ํญ๋ชฉ์ ๊ฐ์ , ๋ฐฐ์ด ๊ฐ์ฒด์ length ํ๋๋ฅผ ์ฝ์ด ๊ธธ์ด ์ป์ ์ ์์
** ํ๋๋ ๊ฐ์ฒด ๋ด๋ถ์ ๋ฐ์ดํฐ
lengthํ๋ : ๋ฐฐ์ด ๋ณ์์ ๋ํธ ์ฐ์ฐ์ ๋ถ์ด๊ณ length
length ํ๋๋ ์ฝ๊ธฐ ์ ์ฉ ํ๋์ด๊ธฐ ๋๋ฌธ์ ๊ฐ ๋ณ๊ฒฝ X
* ๋ฐฐ์ด์ length ํ๋๋ for๋ฌธ์ ์ฌ์ฉํด์ ๋ฐฐ์ด ์ ์ฒด๋ฅผ ๋ฃจํํ ๋ ๋งค์ฐ ์ ์ฉํ๊ฒ ์ฌ์ฉ
ex ) for ( int i=o; i<scores.length; i++ ) { }
ํ๋ก๊ทธ๋จ ์คํ์ ์ํด์ main () ๋ฉ์๋๊ฐ ํ์, main ๋ฉ์๋์ ๋งค๊ฐ๊ฐ String[ ] args๋?
public static void main ( String [ ] args ) { ... }
๋ช
๋ น ๋ผ์ธ ( ๋ช
๋ น ํ๋กฌํํธ ) ์์ ์ ์ฝ๋๋ฅผ java ๋ช
๋ น์ด๋ก ์คํํ๋ฉด JVM ์ ๊ธธ์ด๊ฐ String ๋ฐฐ์ด์ ๋จผ์ ์์ฑํ๊ณ main () ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋งค๊ฐ๊ฐ์ผ๋ก ์ ๋ฌ
๐ < ์ด๊ฒ์ด ์ฝ๋ฉํ
์คํธ๋ค > ๋ถ๋ก Python ๋ฌธ๋ฒ
๐cs ๊ฐ๋
# ์ธ์
: ํต์ ์ ์์ํด์ ๋๋ผ ๋๊น์ง์ ํ ๋ฌถ์
- ํต์ ์๋ ์์๊ณผ ๋์ด ์๋๋ฐ, ๊ทธ๊ฒ์ ๊ด๋ฆฌํ๋ ๋จ์
- ๋ค์ํ ํต์ ์ ์ฐจ(ํ๋กํ ์ฝ)๋ณ ์ธ์
์ด ์์
- ์ฌ์ฉ์๊ฐ ์น ์ฌ์ดํธ ๋ฐฉ๋ฌธํด ๋๊ฐ๋ ๊ฒ๊น์ง๋ ์ธ์
ex ๋ธ๋ผ์ฐ์ ์์ ๊ฒ์ํ ๋ ๊ฒ์์ด๋ฅผ ์
๋ ฅํด์ ๊ฒ์ ๊ฒฐ๊ณผ๊ฐ ํ์๋๊ธฐ๊น์ง PPPoE์ธ์
, HTTP ์ธ์
๋ฑ ์ฌ๋ฌ ๋ฒ์ ์ธ์
์ด ๋ฐ์ํ๋ฉฐ, ๊ฐ๊ฐ์ ๋จ์๋ก ํต์ ๊ด๋ฆฌํจ. SEO ์ฉ์ด์์๋ ์ฌ์ฉ์๊ฐ ์น ์ฌ์ดํธ ๋ฐฉ๋ฌธํด์ ๋๊ฐ๊ธฐ๊น์ง์ ๊ณผ์ ์๋ฏธ, ๋ฐฉ๋ฌธ ํ์๋ก ์ฌ์ฉ
> ๋ธ๋ผ์ฐ์ ์ http ์ธ์
๊ด๋ฆฌ : ์ฟ ํค ์ฌ์ฉํด ์ฌ์ฉ์์ ์น ์ฌ์ดํธ ์ ์ ์ํฉ์ ๊ด๋ฆฌํ๋ ๊ฒ
์ฌ์ฉ์์ ๋ก๊ทธ์ธ ์ํ, ์ฅ๋ฐ๊ตฌ๋์ ์ํ๋ฃ์๋์ง ๋ฑ์ ์ ๋ณด ์ ์ฅ ๋ฐ ๊ด๋ฆฌ
> ์ปค๋ฅ์
: ํต์ ํ๋ ๋ ์ ์ ์ฐ๊ฒฐ ( ์ธ์
๊ณผ ๋น์ทํ ์ฉ์ด, ์ ์ )
๐ ํ๋์ฝ๋ฉ ํ์ต
ํ๋ ์ฝ๋ฉ : ์์๋ ๋ณ์์ ๋ค์ด๊ฐ๋ ๊ฐ์ ์์ค์ฝ๋์ ์ง์ ์ฐ๋ ๋ฐฉ์
๋ชจ๋ฐ์ผ ์ฑ ์คํ ์ ์ฌ์ฉ์์๊ฒ ์ ๋ ฅ๋ฐ์์ผ ํ ์ ๋ณด๋ฅผ ์์ค์ฝ๋์ ์ ๋ ฅํ๊ฑฐ๋ ๋ณ์, ์์ด๋, ๋น๋ฐ๋ฒํธ, ๋์นญํค ๋ฑ ์ค์ ์ ๋ณด๋ฅผ ์ฃผ์์ฒ๋ฆฌํ๋ ๊ฒ๋ ํ๋์ฝ๋ฉ. ์ฃผ๋ก ํ์ผ ๊ฒฝ๋ก, url ๋๋ ip์ฃผ์, ๋น๋ฐ๋ฒํธ, ํ๋ฉด์ ์ถ๋ ฅ๋ ๋ฌธ์์ด ๋ฑ์ด ๋์์ด ๋๋ค.
<-> ๋ก๋ฉ : ์์ค์ฝ๋์ ์ง์ ์ฐ์ง ์๊ณ ๋ฐ์ดํฐ๋ฅผ ์ธ๋ถ ํ์ผ๋ก ๋นผ์ ๋ฐ๋ก ๊ด๋ฆฌํ๋ ๊ฒ
ํ๋์ฝ๋ฉ
- ์ฅ์
- ๊ฐ ๋ฐ๋ก ํ์ธ ๊ฐ๋ฅ
- ๋ณ๋์ ๋ก๋ฉ ์ ์ฐจ ์์ด ์๋ ๋น ๋ฆ
- ๋ฐ์ดํฐ ์์ ์ ์ฝ๋ ์์ ์ด ๋ถ๊ฐํผํ๋ฉด ์ฌ์ปดํ์ผ ํด์ผ ํ๋ฏ๋ก ๊ตณ์ด ๋ก๋ฉ์ํ ํ์๊ฐ ์์
- ๋จ์
- ์ธ๋ถ ์
๋ ฅ์ ๋ํ ์ ์ฐ์ฑ ์๊ณ ํ์ฅ์ฑ ๋ฎ์
- ์ฝ๋ ๋ณ๊ฒฝ์ ์๋ ๋ฐ์ ์๋๊ธฐ ๋๋ฌธ์ ๋ฒ๊ทธ ๋ฐ์ ์ํ ์์
- DB์ ์ ์ํด ์๋ฃ ์กฐํํ๋ ํ๋ก๊ทธ๋จ์ ๋น๋ฐ๋ฒํธ ํ๋์ฝ๋ฉ๋ ๊ฒฝ์ฐ, ๋ฆฌ๋ฒ์ค ์์ง๋์ด๋ง์ผ๋ก ๋น๋ฐ๋ฒํธ๊ฐ ๊ทธ๋๋ก ์ ์ถ๋ ์ ์์
์ฆ ๋ณด์์ ์ทจ์ฝํด์ง ์ ์์
- ๊ฐ์ด ์์๋ก ๋ฐ๋๋ ๋ฐ์ดํฐ๋ฅผ ํ๋์ฝ๋ฉํ๋ฉด ์์ ํ ๋๋ง๋ค ์ฌ์ปดํ์ผ, ์ฌ๋ฐฐํฌ๋ฅผ ํด์ผํ๊ธฐ ๋๋ฌธ์ ํฐ ์์คํ
์ ๊ฒฝ์ฐ ์ด์ฉ์ด๋ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์
์์
Number.java
public final class Number {
public static final String greeting = "Hello World";
}
Hello World.java
public class Hello World{
public static void main(String args[]) {
System.out.println(Number.greeting);
}
}
ํ๋์ฝ๋ฉ๋ณด๋ค๋ ์์ ํ์ฉ
or ์์๋ฅผ ENUM์ผ๋ก ๊ด๋ฆฌํ๊ฑฐ๋ ์ธ๋ถ์ ๋ฐ์ดํฐ ์ ์ฅํ๋ ๋ฑ
https://youtu.be/VzsXPR25pYw
๋ด ์ฃผ์ฅ์ ๋ฐ๋๋ฅผ ๊ณ์ ํผ์ณ์ค ์ฌ๋
ํ ๋ก ์ด ๋๋ ์ฌ๋์ด ์์ด์ผ ํ๋ค : ๋ ๋ฌธ์ฅ ๋ด์ฉ < ํ์ดํ์ ๋๊ตฌ๋ค > ์ด ๋ฌธ๋ ๋ ์ค๋ฆ
- ์ข์ ํ์ฌ : ์ฝ๋๋ฅผ ๋ฆฌ๋ทฐํ๊ณ , ๋ฆฌ๋ทฐ๋ฅผ ๊ฐ์ ํ ์ ์๋ ์์ด๋์ด๋ฅผ ์ ์ฉํด์ ๋ฆฌํฉํ ๋งํ๊ณ ์๋น์ค์ ์ ์ฉํ๊ณ , ๋ฆฌ๋ทฐ๋ฅผ ํตํ ํ์ต๊ณผ ์ค๋ ฅ์ฆ์ง์ด ๋ณด์ฅ๋๋ ํ์ฌ๊ฐ ๊ฐ์ฅ ์ข์ ํ์ฌ
๋์ ์ด์ต = ํ์ฌ์ ์ด์ต best
ํ๋ก๊ทธ๋จ์ ๋ํด์ BM๋น์ง๋์ค ๋ชจ๋ธ์ด ๋ฌด์์ ํจ์ถํ๋ ๊ฒ์ธ๊ฐ, ๋ฌด์์ ๋ชฉ์ , ์ด๋ป๊ฒ ์์ต์ ๋ด๋์ง ๋ฑ์ ์ฌ์
๊ณผ ์๋น์ค์ ๋ํ ์๋ชฉ์ ๊ธฐ๋ฅด๋ ๊ฒ ์ค์, ๊ฐ๋ฐํ๋ฉด์ ์ด๋ฌํ ๊ธฐํ์ด ํ์ค์ ์ผ๋ก ์๋ง๋ ๊ฒ ๊ฐ์์, ์ด ๋ชจ๋ธ๋ณด๋ค๋ ์ด๋ ๊ฒ ๊ธฐํ์ ํด๋ณด๋ ๊ฒ ์ด๋ค๊ฐ์? ๋ฑ ๊ฐ๋ฐ์๊ฐ ์ฌ์
์ ๋ถ๋ถ์์ ~๊ฐ ์ข์ ๊ฒ ๊ฐ์ต๋๋ค ๋ฑ ์ ์๊ฒฌ์ ๋ด๋ ๊ฒ ์ข์
์ด๋ ๊ฒ ๊ฐ๋ฐํ๋ ๊ฒ ์ข๋ค๋ ํ์คํ ๊ฐ๋ฐ ์ฒ ํ์ด ์๋ ๊ฒ์ด ์ค์!

์ด๋ ๊ฐ๋ฐ์๋ผ๋ ๋ง์ ํ์ชฝ์ ์ฐฝ์
์ ํ๊ณ ์ด์์์?
โจ ์ํ์
- ์ํฉ : ์นดํ์์ ๊ณต๋ถ๋ฅผ ํ๊ธฐ๋ก ํ์ผ๋, ๋๊ณ ์ถ์ ์๊ตฌ๊ฐ ์ปธ์
- ์ก์
: ์ฐธ๊ณ ์นดํ์๊ฐ์ ๊ณต๋ถํจ
- ์นญ์ฐฌ : ์ด๋ ๊ฒ ๋ด ์๊ตฌ๋๋ก ํ์ง ์๋ ์ต๊ด์ ๋ค์ด๊ธฐ ์์ํ์ ์ํ์ด~!
โจ ๊ฐ์ ์
- ๋ฌธ์ : ์ ๋
๋ฆ๊ฒ ์ ํ๋ธ๋ฅผ ๋ณด๋ฉด์ ์๋ฏธ์์ด ์๊ฐ์ ๋ ๋ฆผ
- ์์ธ : ์ ์ด์ ํฐ์ ์ก์ ๊ฒ, ์๊ฐ ๊ณํ์ ํํ์ด ์ง์ง ์์ ๊ฒ, ์นจ๋์ ๋์ด ๊ฒ
- ์ก์
ํ๋ : ํฐ์ ์ ๊ถ ๋๊ธฐ, ์๊ฐ ๊ณํ ํํ์ด ์ง๊ธฐ, ์นจ๋์ ๋์ธ ๋ ํ์ด๋จธ๋ฅผ ๋๊ณ ๋๊ธฐ ( ๊ฐ๋ฅํ ๋์ง ์๊ธฐ )
โจ๊ณ ๋ฏผ์
- ๋ฐฑ์๋๋ฅผ ์ค๋นํ ์ง ํ๋ก ํธ๋ฅผ ์ค๋นํ ์ง ๊ทธ ๋ค๋ฅธ ๋ถ์ผ๋ฅผ ๊ณ์ํด์ ๋์ ํด๋ด์ผ ํ ์ง ๊ทธ ๊ธธ์ ๋ช
ํํ ์ฐพ์ง ๋ชปํ๊ฒ ๋ค
์๋๋ ํ๋ก ํธ๋ฅผ ์ค๋นํ๋ คํ์ผ๋, ์ ๋๋ก ๋ค๋ฃฐ ์ค ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ํ๋๊ฐ ์์ด์ผํ๋ค๋ ๊ต์๋์ ๋ง์์ ๋ฐ๋ผ ์์ํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด JAVA์ Python. ๊ทธ๋ฆฌ๊ณ ์ธ์ด ๊ณต๋ถ๋ ํ๋ก์ ํธ๋ฅผ ํตํด์ ๊ณต๋ถํด์ผ ์ข๋ค๋ ์๋ง์ ๋ง๋ค. ํ๋ก ํธ๋ณด๋ค ๋ ๋์ ์ฐ๋ด์ ์๋ํ๋ค๋ ๋ฐฑ์๋ ์ด ์ธ๊ฐ๊ฐ ์์ฌ ๋ฐฑ์๋๋ก ๋์ด๊ฐ๋ณผ๊น? ํ๋ฉฐ ์ธ์ด๊ณต๋ถ๋ฅผ ํ๊ณ ๋ค์ ๋จ๊ณ๋ฅผ ์ฐพ๊ณ ์๋ค. ํด๋ณด๊ณ ์ถ์ ๊ณต๋ถ์ ์ข์ ๊ฐ์๋ ๋๋ฌด๋ ๋ง์ ๊ฒ์ด ๋ฌธ์ ์ด๋ค. ํ์ฌ ๊ฐ์ง๊ณ ์๋ ๋ฆฌ์กํธ ๊ต์ฌ. ๋
ธ๋ง๋์ฝ๋ ๋ฆฌ์กํธ. ์ ๋ก์ด์ ๋ฆฌ์กํธ, ์ฝ๋ฉ์ ํ์ ๋ฆฌ์กํธ, ์ธํ๋ฐ์ ๋ฆฌ์กํธ, ๋๋ฆผ์ฝ๋ฉ ์๋ฆฌ์ ๋ฆฌ์กํธ / ๊น์ํ ์คํ๋ง ์ปค๋ฆฌํ๋ผ / ์ธํ๋ฐ ํ์ด์ฌ ์ฅ๊ณ ๋ฆฌ์กํธ ๊ฐ์ / ์ฝ๋๋ผ์ด์ธ ํ์ด์ฌ ์ฌํ์ ์ฅ๊ณ / ์ธํ๋ฐ ์๋ฐ ์คํ๋ง๋ถํธ ํ์ฉ ์น๊ฐ๋ฐ ์ค๋ฌด์ฉ / ๋ถ์คํธ์ฝ์ค ์น ํ๋ก๊ทธ๋๋ฐ (ํ์คํ)