1. ๋คํธ์ํฌ ์ฅ์น๋ฅผ ํ์๋กํ์ง ์๊ณ ๋คํธ์ํฌ ํ ํด๋ก์ง๊ฐ ๋์ ์ผ๋ก ๋ณํ๋๋ ํน์ง์ด ์์ผ๋ฉฐ ์์ฉ ๋ถ์ผ๋ก๋ ๊ธด๊ธ ๊ตฌ์กฐ, ๊ธด๊ธ ํ์, ์ ์ํฐ์์์ ๊ตฐ์ฌ ๋คํธ์ํฌ์ ํ์ฉ๋๋ ๋คํธ์ํฌ๋?
์ ๋ํน ๋คํธ์ํฌ(ad hoc network)
์ ๋ํน ๋คํธ์ํฌ๋ ์ธํ๋ผ๊ฐ ์๋ ํ๊ฒฝ์์ ์์๋ก ๊ตฌ์ฑ๋๋ ์์จ์ ์ธ ๋คํธ์ํฌ๋ก,
๊ฐ ๋ ธ๋๋ค์ด ์๋ก ์ง์ ํต์ ํ์ฌ ์ ๋ณด๋ฅผ ์ ์กํ๊ณ ๋ผ์ฐํ ์ ์ํํฉ๋๋ค.
์ด๋ฌํ ํน์ฑ ๋๋ฌธ์ ๋คํธ์ํฌ ์ฅ์น๊ฐ ํ์ํ์ง ์๊ณ , ๋คํธ์ํฌ ํ ํด๋ก์ง๊ฐ ๋์ ์ผ๋ก ๋ณํ๋ ์ ์์ต๋๋ค.
2. ๋ค์ (1), (2)์ ์๋ง๋ ๋ต์์ ์ฐ์์ค.
(1) ์ฌ๋์ ๊ฐ์ ์ด๋ ๊ฒฝํ์ ๋ํ๋ด๋ ๊ฐ๋
(2) ์ฌ์ฉ์ ์ธํฐํ์ด์ค. ์๋ก๋ CLI์ด ์๋ค.
3. ํธ๋์ญ์ ์ ํน์ง ์ค, ์์์ฑ์ ๋ํด ์ฝ์ ํ์ญ์์ค.
ํธ๋์ญ์ (Transaction)์ ์์์ฑ(Atomicity)์ด๋,
ํ ํธ๋์ญ์ ๋ด์ ๋ชจ๋ ์์ ์ด ์ ๋ถ ์ฑ๊ณตํ๊ฑฐ๋ ์ ๋ถ ์คํจํ๋ ๊ฒ์ ๋ณด์ฅํ๋ ํน์ฑ์ ๋๋ค.
์ฆ, ํธ๋์ญ์ ์ ๋ชจ๋ ์์ ์ด ์ผ์ด๋๊ฑฐ๋ ์ ํ ์ผ์ด๋์ง ์๋ ๊ฒ์ ๋๋ค.
4. ๋ค์์ ์ ( ) ์ ๊ทํ์ผ๋ก์จ, ๋ถ๋ถ ํจ์์ ์ข ์์ฑ์ ์ ๊ฑฐํ์ฌ, ์์ ํจ์์ ์ข ์์ ๋ง์กฑํ๋ ์ ๊ทํ์?
์ 2์ ๊ทํ
์ 1์ ๊ทํ : ๋๋ฉ์ธ์ด ์์๊ฐ
์ 2์ ๊ทํ : ๋ถ๋ถ ํจ์์ ์ข
์ ์ ๊ฑฐ
์ 3์ ๊ทํ : ์ดํ์ ํจ์ ์ข
์ ์ ๊ฑฐ
BCNF : ๊ฒฐ์ ์์ด๋ฉด์ ํ๋ณดํค๊ฐ ์๋ ๊ฒ ์ ๊ฑฐ
์ 4์ ๊ทํ : ๋ค์น ์ข
์ ์ ๊ฑฐ
์ 5์ ๊ทํ : ์กฐ์ธ ์ข
์ ์ ๊ฑฐ
5. ๋ค์์ ํ ์ด๋ธ์ ์์ ํ ๋์ ์ํฉ์ ๋๋ค. SQL ๋ณด๊ธฐ์์ ๊ดํธ์์ ์๋ง๋ ๋ฌธ์ฅ์ ์์ฑํ์์ค.
( 1 ) ํ ์ด๋ธ๋ช ( 2 ) ์ปฌ๋ผ = ๊ฐ WHRE ์ ์ >= 90;
- UPDATE
- SET
6. ๋ค์ SQL ๋ณด๊ธฐ์์ JOINํ ๊ฒฝ์ฐ ๊ดํธ์์ ์๋ง๋ ๋ฌธ์ฅ์ ์์ฑํ์์ค.
SELECT .... FROM ํ์์ ๋ณด a JOIN ํ๊ณผ์ ๋ณด b ( 1 ) a.ํ๊ณผ = b.( 2 )
- ON
- ํ๊ณผ
JOIN์ ๋ ์ด์์ ํ ์ด๋ธ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ฌ ๋ ์ฌ์ฉํ๋ SQL ๊ตฌ๋ฌธ์ ๋๋ค.
JOIN ๊ตฌ๋ฌธ์ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ ๊ฐ ์ด์์ ํ ์ด๋ธ์ ๋ ์ฝ๋๋ฅผ ์ฐ๊ฒฐํ์ฌ ํ๋์ ๊ฒฐ๊ณผ ํ ์ด๋ธ์ ์์ฑํฉ๋๋ค.
์ด๋ JOIN ๊ตฌ๋ฌธ์์ ํ ์ด๋ธ ๊ฐ์ ์ฐ๊ฒฐ ์กฐ๊ฑด์ ๋ช ์ํ๊ธฐ ์ํด ON ์ ์ ์ฌ์ฉํฉ๋๋ค.
ON ์ ์ ๋ ๊ฐ ์ด์์ ํ ์ด๋ธ ๊ฐ์ ์ฐ๊ฒฐ ์กฐ๊ฑด์ ์ง์ ํ๋ ๊ตฌ๋ฌธ์ ๋๋ค.
ON ์ ๋ค์๋ ์ฐ๊ฒฐํ๋ ค๋ ๋ ํ ์ด๋ธ ๊ฐ์ ๊ณตํต ์ปฌ๋ผ์ด๋ ์กฐ๊ฑด์ ๋ช ์ํฉ๋๋ค.
ON ์ ์์ ์ง์ ํ ์กฐ๊ฑด์ด ์ฐธ(True)์ธ ๋ ์ฝ๋๋ง JOIN ๊ฒฐ๊ณผ์ ํฌํจ๋ฉ๋๋ค.
7. ํ์ด์ฌ ๋นํธ ์ฐ์ฐ์ ์ฝ๋ ๊ฒฐ๊ณผ
a = 100
result = 0
for i in range(1, 3):
result = a >> i
result = result + 1
print(result)
26
์ด ์ฝ๋๋ ๋ณ์ a์ 100์ ํ ๋นํ๊ณ , ๋ณ์ result๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ ํ,
for ๋ฐ๋ณต๋ฌธ์ ํตํด 1๋ถํฐ 2๊น์ง์ ์ซ์์ ๋ํด ์๋ ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
- a๋ฅผ i๋งํผ ๋นํธ ์ค๋ฅธ์ชฝ ์ํํธํ ๊ฒฐ๊ณผ๋ฅผ result์ ํ ๋นํฉ๋๋ค.
- result์ 1์ ๋ํฉ๋๋ค.
๋ฐ๋ณต๋ฌธ์ด ์ข ๋ฃ๋ ํ, result์ ์ต์ข ๊ฐ์ธ 26์ด ์ถ๋ ฅ๋ฉ๋๋ค. ์ด๋ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐ๋ฉ๋๋ค.
- i๊ฐ 1์ผ ๋, a๋ 100์ด๋ฏ๋ก a >> i๋ 50์ด ๋ฉ๋๋ค. ์ด๋ result๋ 51์ด ๋ฉ๋๋ค.
- i๊ฐ 2์ผ ๋, a๋ 100์ด๋ฏ๋ก a >> i๋ 25๊ฐ ๋ฉ๋๋ค. ์ด๋ result๋ 26์ด ๋ฉ๋๋ค.
8. ๋ฏธ๊ตญ ๊ตญ๋ฆฝ ํ์ค ๊ธฐ์ ์ฐ๊ตฌ์ (NIST), DES๋ฅผ ๋์ฒดํ๋ฉฐ, 128 ๋นํธ ๋ธ๋ก ํฌ๊ธฐ์ 128,192,256๋นํธ ํค ํฌ๊ธฐ์ ๋์นญ ํค ์ํธํ ๋ฐฉ์์?
AES(Advanced Encryption Standard)
9. ํ์ดํธ๋ฐ์ค ํ ์คํธ ๊ฒ์ค ์ค์, ๊ฐ ๋ฒํธ์ ํด๋นํ๋ ๋จ์ด ์ ํํด์ฃผ์์ค. (์ค์ ์ํ๋ฌธ์ ์์๋ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.)
1. ์ต์ ํ๋ฒ์ ๋ชจ๋ ๋ฌธ์ฅ ์ํ
2. ๊ฒฐ์ (Decision) ๊ฒ์ฆ๊ธฐ์ค์ด๋ผ๊ณ ๋ ํ๋ฉฐ, ์กฐ๊ฑด๋ณ ์ฐธ / ๊ฑฐ์ง
3. 2๋ฒ๊ณผ ๋ฌ๋ฆฌ ์ ์ฒด ์กฐ๊ฑด์์ ๋ฌด์ํ๋ฉฐ, ์กฐ๊ฑด ์๊ด์์ด ๊ฐ๋ณ ์กฐ๊ฑด ์ฐธ / ๊ฑฐ์ง
1. ๋ฌธ์ฅ
2. ๊ฒฐ์
3. ์กฐ๊ฑด
10. SQL๋ฌธ์์ ๊ดํธ์์ ์๋ง์ ๋ต์์ ์์ฑํ์์ค. (์ค์ ์ํ์๋ ๊ฒฐ๊ณผ ์ด๋ฏธ์ง๊ฐ ์์ต๋๋ค.)
('์ด๋ฆ'์ด๋ ์ปฌ๋ผ์ '์ด'๋ก ์์ํ๋ ๋ฌธ์์ด์ '๋ด๋ฆผ์ฐจ์'ํ๋ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ ๋ด์ฉ์ ๋๋ค.)
SELECT .... FROM ... WHERE ์ด๋ฆ LIKE ( 1 ) ORDER BY ( 2 )
SELECT * FROM ํ
์ด๋ธ๋ช
WHERE ์ด๋ฆ LIKE '์ด%' ORDER BY ์ด๋ฆ DESC
์ด ์ฟผ๋ฆฌ๋ '์ด'๋ก ์์ํ๋ ์ด๋ฆ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ๊ฐ์ ธ์ค๋ ์ฟผ๋ฆฌ์ ๋๋ค.
%๋ ์์ผ๋์นด๋ ๋ฌธ์๋ก, ์ด ์์น์๋ ์ด๋ค ๋ฌธ์์ด์ด๋ ์ฌ ์ ์์ต๋๋ค.
์ด๋ฆ LIKE '์ด%'์ '์ด'๋ก ์์ํ๋ ๋ชจ๋ ๋ฌธ์์ด์ ๊ฐ์ ธ์จ๋ค๋ ์๋ฏธ์ ๋๋ค.
ORDER BY ์ด๋ฆ DESC๋ ์ด๋ฆ ์ปฌ๋ผ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
11. ์์ง๋ ๋ฌธ์ ๋ก์จ, ๊ฐ ๋ฒํธ์ ํด๋นํ๋ ์์ง๋๋ฅผ ์ฐ์์ค. (์ค์ ์ํ๋ฌธ์ ์์๋ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.)
1. ์ ์ถ๋ ฅ ๊ฐ ์ฐ๊ด์ฑ์ ์์ผ๋, ์์์ ๋ฐ๋ผ ์ํ๋๋ ๊ฒ
2. ๋์ผํ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ ์ฌ์ฉ
3. ํ๋์ ๊ธฐ๋ฅ์ ๋ชจ๋ ๊ธฐ์ดํ๊ณ ๋ฐ์ ํ๊ฒ ์ฐ๊ด๋์ด ์๋ ๊ฒ (๊ทธ๋ฃนํ)
1. ์ ์ฐจ์ ์์ง๋
2. ๊ตํ์ ์์ง๋
3. ๊ธฐ๋ฅ์ ์์ง๋
์์ง๋ ์์ (๋ฎ์๊ฒ๋ถํฐ ๋์ ์์)
์ฐ์ฐ์ > ๋
ผ๋ฆฌ์ > ์๊ฐ์ > ์ ์ฐจ์ > ๊ตํ์ > ์์ฐจ์ > ๊ธฐ๋ฅ์
์ฐ์ฐ์ ์์ง๋ : ๋ชจ๋ ๋ด๋ถ์ ๊ฐ ๊ตฌ์ฑ์์๋ค์ด ์ฐ๊ด์ด ์์ ๊ฒฝ์ฐ
๋
ผ๋ฆฌ์ ์์ง๋ : ์ ์ฌํ ์ฑ๊ฒฉ์ ๊ฐ๊ฑฐ๋ ํน์ ํํ๋ก ๋ถ๋ฅ๋๋ ์ฒ๋ฆฌ ์์๋ค์ด ํ ๋ชจ๋์์ ์ฒ๋ฆฌ๋๋ ๊ฒฝ์ฐ
์๊ฐ์ ์์ง๋ : ์ฐ๊ด๋ ๊ธฐ๋ฅ์ด๋ผ๊ธฐ๋ณด๋จ ํน์ ์๊ฐ์ ์ฒ๋ฆฌ๋์ด์ผ ํ๋ ํ๋๋ค์ ํ ๋ชจ๋์์ ์ฒ๋ฆฌํ ๊ฒฝ์ฐ
์์ฐจ์ ์์ง๋ : ๋ชจ๋ ๋ด์์ ํ ํ๋์ผ๋ก๋ถํฐ ๋์จ ์ถ๋ ฅ๊ฐ์ ๋ค๋ฅธ ํ๋์ด ์ฌ์ฉํ ๊ฒฝ์ฐ
๊ฒฐํฉ๋๋ ๋ฎ์ ์๋ก
์์ง๋๋ ๋์ ์๋ก
์ด์์ ์ธ ๋ชจ๋ํ์ด๋ค.
12. ํจํท๊ตํ๋ฐฉ์ ์ค์์, ๋ฒํธ์ ํด๋นํ๋ ๋ฐฉ์์ ์ ์ผ์์ค.
1. ๋ชฉ์ ์ง ํธ์คํธ์ ๋ฏธ๋ฆฌ ์ฐ๊ฒฐํ ํ, ํต์ ํ๋ ์ฐ๊ฒฐํ ๊ตํ ๋ฐฉ์
2. ํค๋์ ๋ถ์ด์ ๊ฐ๋ณ์ ์ผ๋ก ์ ๋ฌํ๋ ๋น์ฐ๊ฒฐํ ๊ตํ ๋ฐฉ์
1. ๊ฐ์ ํ์ ๋ฐฉ์
2. ๋ฐ์ดํฐ๊ทธ๋จ ๋ฐฉ์
๊ฐ์ ํ์ ๋ฐฉ์(Virtual Circuit Switching)์ ์ ์ก ๊ฒฝ๋ก๋ฅผ ๋ฏธ๋ฆฌ ์์ฝํด ๋๊ณ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ๋ฐฉ์์ ๋๋ค.
๋ฐ์ดํฐ๋ฅผ ์ ์กํ๊ธฐ ์ ์ ๊ฒฝ๋ก๋ฅผ ์์ฝํ๋ฏ๋ก ํจํท ์์ค์ด๋ ์ง์ฐ์ด ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์ ์ต๋๋ค.
๋ฐ์ดํฐ๊ทธ๋จ ๋ฐฉ์(Datagram Switching)์ ๋ฐ์ดํฐ ํจํท์ ์ ์กํ๋๋ฐ ์์ด์ ๊ฒฝ๋ก๋ฅผ ๋ฏธ๋ฆฌ ์์ฝํ์ง ์๊ณ ,
๊ฐ ํจํท์ ๋ ๋ฆฝ์ ์ธ ๋จ์๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ ๋๋ค.
๋ฐ์ดํฐ๊ทธ๋จ ๋ฐฉ์์ ์ฌ์ฉํ๋ ๋คํธ์ํฌ๋ ์ธํฐ๋ท์ ๋น๋กฏํ์ฌ IP(Internet Protocol) ๊ธฐ๋ฐ์ ๋คํธ์ํฌ์์ ์ฌ์ฉ๋ฉ๋๋ค.
ํจํท ์์ค์ด๋ ์ง์ฐ์ด ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋์์ง๋ ๋จ์ ์ด ์์ง๋ง,
์ ์กํ ๋ฐ์ดํฐ ํฌ๊ธฐ๋ ๋์ญํญ ๋ฑ์ ๋ํ ์ ํ์ด ์๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
13. ๊ดํธ ( ) ์์ ์๋ง๋ ๋จ์ด๋ฅผ ์ฐ์์ค.
๋์์ธ ํจํด ์ค์์ ( )ํจํด์ ๋ฐ๋ณต์ ์ผ๋ก ์ฌ์ฉ๋๋ ๊ฐ์ฒด๋ค์ ์ํธ์์ฉ์ ํจํดํ ํ ๊ฒ์ผ๋ก, ํด๋์ค๋ ๊ฐ์ฒด๋ค์ด ์ํธ์์ฉํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์๊ณ ๋ฆฌ์ฆ์ ํจํด์๋ Interpreter, Observer, Command ๊ฐ ์๋ค.
ํ์(behavioral)
๋์์ธ ํจํด ์ค Behavioral ํจํด์ ๊ฐ์ฒด๋ค ๊ฐ์ ์ฑ ์์ ๋ถ์ฐ์ํค๋ ํจํด์ผ๋ก,
๊ฐ์ฒด ๊ฐ์ ์ํธ์์ฉ ๋ฐฉ๋ฒ์ ํ ํ๋ฆฟํํ์ฌ ์ฌ์ฌ์ฉ์ฑ์ ๋์ด๋ ๊ฒ์ ๋ชฉ์ ์ผ๋ก ํฉ๋๋ค.
14. ๋ณํ์ ์ด๊ธฐ๋ฒ ์ค, ์ ๊ทผํ ๋ฐ์ดํฐ์ ๋ํ ์ฐ์ฐ์ ๋ชจ๋ ๋ง์น ๋๊น์ง ์ํธ๋ฐฐ์ ํ๋ ๊ธฐ๋ฒ์ ๋ฌด์์ด๋ผ ํ๋์ง ์์ฑํ์์ค.
๋กํน(Locking)
๋กํน(Locking)์ ๋ณํ ์ฒ๋ฆฌ์์ ๊ณต์ ์์์ ๋ํ ์ ๊ทผ์ ์ ์ดํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ๊ธฐ์ ๋ก,
ํ๋์ ํ๋ก์ธ์ค๋ ์ค๋ ๋๊ฐ ๊ณต์ ์์์ ์ฌ์ฉํ ๋ ๋ค๋ฅธ ํ๋ก์ธ์ค๋ ์ค๋ ๋๊ฐ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ์ ๊ทธ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
๋กํน์ ์ํธ๋ฐฐ์ (Mutual Exclusion)๋ฅผ ์ํ ๊ฒ์ผ๋ก, ํ๋์ ํ๋ก์ธ์ค๋ ์ค๋ ๋๊ฐ ๊ณต์ ์์์ ์ฌ์ฉํ๋ ๋์
๋ค๋ฅธ ํ๋ก์ธ์ค๋ ์ค๋ ๋๋ ํด๋น ์์์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ํ๋ ๊ฒ์ ๋๋ค.
15. ๋ผ๋ฐ์ฐ ๋ฐ์ดํฐ ๋ชจ๋ธ๋ง์ ๊ดํ ์ค๋ช ์ผ๋ก์จ, ๋ณด๊ธฐ์ ํด๋นํ๋ ๋ต์์ ์์ฑํ์์ค.
(์ค์ ์ํ๋ฌธ์ ์์๋ ๋ณด๊ธฐ๊ฐ ์ฃผ์ด์ง๋๋ค.)
1. ์ ๋ ฅ๊ฐ์ด ์ถ๋ ฅ๊ฐ์ผ ๋ ex) ์๋ฃ ํ๋ฆ๋(DFD)
2. ์๊ฐ์ ๋ฐ๋ผ ๋ณํ๋ ๊ฒ ex) ์ํ ๋ค์ด์ด๊ทธ๋จ(์ํ๋)
3. ๊ฐ์ฒด๋ค ๊ฐ์ ๊ด๊ณ๋ฅผ ์ ์ ex) ER๋ค์ด์ด๊ทธ๋จ(ERD)
1. ๊ธฐ๋ฅ ๋ชจ๋ธ๋ง(Functional Modeling)
2. ๋์ ๋ชจ๋ธ๋ง(Dynamic Modeling)
3. ๊ฐ์ฒด ๋ชจ๋ธ๋ง(Object Modeling)
๋ผ๋ฐ์ฐ ๊ฐ์ฒด์งํฅ ๋ถ์ ๊ธฐ๋ฒ์ ์ํํธ์จ์ด ๊ตฌ์ฑ ์์๋ฅผ ๊ทธ๋ํฝ ํ๊ธฐ๋ฒ์ ์ด์ฉํ์ฌ ๋ชจ๋ธ๋งํ๋ ๋ถ์ ๊ธฐ๋ฒ์
๋๋ค.
๋ผ๋ฐ์ฐ ๊ฐ์ฒด์งํฅ ๋ถ์ ๊ธฐ๋ฒ์ ์ ์ฐจ :
๊ฐ์ฒด ๋ชจ๋ธ๋ง > ๋์ ๋ชจ๋ธ๋ง > ๊ธฐ๋ฅ ๋ชจ๋ธ๋ง
๊ธฐ๋ฅ ๋ชจ๋ธ๋ง(Functional Modeling): ์์คํ ์ด ์ํํ๋ ๊ธฐ๋ฅ๊ณผ ํ๋ก์ธ์ค ๊ฐ์ ์ํธ์์ฉ์ ๋ชจ๋ธ๋งํ๋ ๋ฐฉ๋ฒ์ผ๋ก,
์์คํ ๋ด์ ๊ธฐ๋ฅ์ ์๊ตฌ์ฌํญ์ ํ์ ํ๊ณ ๋ถ์ํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
๋ํ์ ์ธ ์์๋ก DFD(Data Flow Diagram)๊ฐ ์๋ค.
๋์ ๋ชจ๋ธ๋ง(Dynamic Modeling): ์์คํ ์ ๋์ ๊ณผ์ ์ ๋ชจ๋ธ๋งํ๋ ๋ฐฉ๋ฒ์ผ๋ก,
์์คํ ๋ด์ ๋์ ์ธ ์๊ตฌ์ฌํญ์ ํ์ ํ๊ณ ๋ถ์ํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
์ํ ์ ์ด๋(State Transition Diagram)๋ ์ํ์ค ๋ค์ด์ด๊ทธ๋จ(Sequence Diagram)์ด ์ด์ ํด๋นํ๋ค.
๊ฐ์ฒด ๋ชจ๋ธ๋ง(Object Modeling): ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์์ ์ฌ์ฉ๋๋ ๊ฐ์ฒด์ ์์ฑ, ๊ธฐ๋ฅ, ๊ด๊ณ ๋ฑ์ ๋ชจ๋ธ๋งํ๋ ๋ฐฉ๋ฒ์ผ๋ก,
๊ฐ์ฒด์งํฅ ๊ฐ๋ฐ ํ๋ก์ธ์ค์์ ๊ฐ์ฅ ์ค์ํ ๊ธฐ์ด ๋จ๊ณ์ด๋ค.
UML(Unified Modeling Language)์์ ์ฌ์ฉ๋๋ ํด๋์ค ๋ค์ด์ด๊ทธ๋จ(Class Diagram)์ด ๋ํ์ ์ธ ์์์ด๋ค.
16. ๋ค์์ C์ธ์ด์ ๊ดํ ์์ค์ฝ๋์ด๋ค. ์คํ ๊ฒฐ๊ณผ๊ฐ์ ์์ฑํ์์ค.
int main(){
int res;
res = mp(2,10);
printf("%d",res);
return 0;
}
int mp(int base, int exp) {
int res = 1;
for(int i=0; i < exp; i++){
res = res * base;
}
return res;
}
1024
17. ํด๋์ค ๋ด์์ ๊ฐ์ฒด ์์ฑ ์์ด ์ฌ์ฉํ ์ ์๋ ๋ฉ์๋๋ก์จ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ์์ฑํ์์ค.
public class Test {
public static void main(String[] args){
system.out.print(test.check(1));
}
( ) String check (int num) {
return (num >= 0) ? "positive" : "negative";
}
}
[์ถ๋ ฅ๊ฒฐ๊ณผ]
positive
static
static ํค์๋๋ ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์ ๋๋ ๋ฉ์๋์ ์ฌ์ฉ๋ฉ๋๋ค.
static ๋ฉค๋ฒ๋ ํด๋์ค ์ธ์คํด์คํ ์์ด ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก ํด๋์ค ์์ค์์ ์กด์ฌํฉ๋๋ค.
static ๋ณ์๋ ํด๋น ํด๋์ค์ ๋ชจ๋ ์ธ์คํด์ค๊ฐ ๊ณต์ ํ๋ฉฐ, ํด๋์ค ์ด๋ฆ์ผ๋ก ์ฐธ์กฐ๋ฉ๋๋ค.
static ๋ฉ์๋๋ ์ธ์คํด์ค ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ํด๋์ค ์ด๋ฆ์ผ๋ก ํธ์ถ๋ฉ๋๋ค.
์ฆ, static ๋ฉค๋ฒ๋ ์ธ์คํด์ค์ ์ข ์๋์ง ์๊ณ ํด๋์ค์ ์ข ์๋ฉ๋๋ค. ๋ฐ๋ผ์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์ค์ผ ์ ์์ต๋๋ค.
๋ํ, static ๋ฉค๋ฒ๋ ํด๋์ค ๋ก๋ฉ ์์ ์์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ฏ๋ก, ์ธ์คํด์คํ ์ ์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
18. ๋ค์์ C์ธ์ด ๋ฌธ์ ์ด๋ค. ์ถ๋ ฅ๊ฐ์ ์์ฑํ์์ค.
#include <stdio.h>
int main() {
int ary[3];
int s = 0;
*(ary+0) = 1;
ary[1] = *(ary+0) + 2;
ary[2] = *ary + 3;
for (int i = 0; i < 3; i++) {
s = s + ary[i];
}
printf("%d", s);
return 0;
}
8
์ฝ๋์์๋ ์ ์ํ ๋ฐฐ์ด ary๋ฅผ ์ ์ธํ๊ณ , ๊ฐ ์์์ ๊ฐ์ ํ ๋นํ ํ,
for๋ฌธ์ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ๊ฐ์ ๋ชจ๋ ๋ํ ํ ๋ณ์ s์ ์ ์ฅํ๊ณ ,
printf ํจ์๋ฅผ ์ฌ์ฉํ์ฌ s์ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
์ด๊ธฐ๊ฐ์ผ๋ก ary[0]๊ณผ *(ary+0)์ ๊ฐ๊ฐ 1์ ํ ๋นํฉ๋๋ค.
๋ค์์ผ๋ก ary[1]์ ary[0]๊ณผ 2๋ฅผ ๋ํ ๊ฐ, ์ฆ 3์ด ๋ฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก ary[2]๋ *ary์ 3์ ๋ํ ๊ฐ, ์ฆ 4๊ฐ ๋ฉ๋๋ค.
๋ฐ๋ผ์ s๋ 1+3+4, ์ฆ 8์ด ๋ฉ๋๋ค.
19. ๋ค์์ JAVA ๊ดํ ๋ฌธ์ ์ด๋ค. ์๋ง๋ ์ถ๋ ฅ๊ฐ์ ์์ฑํ์์ค.
public class ovr1 {
public static void main(String[] args){
ovr a1 = new ovr1();
ovr a2 = new ovr2();
System.out.println(a1.sun(3,2) + a2.sun(3,2));
}
int sun(int x, int y){
return x + y;
}
}
class ovr2 extends ovr1 {
int sun(int x, int y){
return x - y + super.sun(x,y);
}
}
11
์ ์ฝ๋์์๋ ๋ฉ์ธ ํด๋์ค์ธ ovr1๊ณผ ์ด๋ฅผ ์์๋ฐ๋ ์์ ํด๋์ค์ธ ovr2๊ฐ ์ ์๋์ด ์์ต๋๋ค.
๋ ํด๋์ค ๋ชจ๋ sun ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ,
ovr2 ํด๋์ค์์๋ sun ๋ฉ์๋๊ฐ ์ค๋ฒ๋ผ์ด๋ฉ(overriding)๋์ด ๋ถ๋ชจ ํด๋์ค์ธ ovr1์ sun ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๊ณ ์์ต๋๋ค.
main ๋ฉ์๋์์๋ ovr1๊ณผ ovr2 ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ , ์ด๋ค์ sun ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๊ณ ์์ต๋๋ค.
a1.sun(3,2) ํธ์ถ ๊ฒฐ๊ณผ์ธ 5์ a2.sun(3,2) ํธ์ถ ๊ฒฐ๊ณผ์ธ 1 + a1.sun(3,2) ๊ฐ์ธ 6๋ฅผ ๋ํ ๊ฒฐ๊ณผ์ธ 11๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
20. ๋ค์ ๊ดํธ ์์ ์๋ง์ ๋ต์์ ์์ฑํ์์ค.
- ํ ์คํธ ํ๋ค์ค์ ๋๊ตฌ ๊ตฌ์ฑ ์์ ์ค, ์ํฅ์ ํ ์คํธ์, ์์ ๋ชจ๋ ์ญํ ์ ๋์ ํ๋ ํ ์คํธ ๋๋ผ์ด๋ฒ์ ํํฅ์ ํ ์คํธ ์, ํ์ ๋ชจ๋ ์ญํ ์ ๋์ ํ๋ ํ ์คํธ ( ) ์ด ์๋ค.
์คํ (Stub)
'์๊ฒฉ์ฆ > ์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2022๋ 1ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.17 |
---|---|
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 3ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.16 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2021๋ 1ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.14 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2020๋ 4ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.11 |
[์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ] 2020๋ 3ํ ๊ธฐ์ถ๋ฌธ์ (0) | 2023.04.08 |