23.01.05 - ๊ฐ์ฒด์งํฅ์ ์ฐจ/Class๋?/Instance๋?/Field/Method
๊ฐ์ฒด ์งํฅ Object Oriented Programming
๐ก ๊ฐ์ฒด ⇒ ์ถ์ํ(abstraction)⇒ํด๋์ค ์์ฑ+๊ด๊ณ(relationship)⇒์บก์ํ(encapsulation)⇒๊ณ์ธตํ,์์(Hierarchy)⇒๋คํ์ฑ(polymorphism)
๊ฐ์ฒด์งํฅ ์ค๊ณ์ 3๋จ๊ณ
1.๊ฐ์ฒด ๋ชจ๋ธ๋ง(Object Modeling) :๊ฐ์ฒด์ ์์ฑ๊ณผ ๊ธฐ๋ฅ์ ์ ๋ฆฌํ๋ค.
object : ํ๊ธธ๋
attribute(์์ฑ๊ฐ,ํน์ฑ)
- ์ด๋ฆ: ํ๊ธธ๋
- ์ง์ : ์์
- ์ ํ ํํ ํ์: …
behavior(๊ธฐ๋ฅ)
- ๋ฌผ๊ฑด์ ํ์น๋ค.
- ํ์น ๋ฌผ๊ฑด์ ๋๋์ด์ค๋ค.
- ํ๊ด ์ค๋ฆฌ๋ฅผ ํผ๋ธ๋ค…
2.ํด๋์ค ์ ์: ๋ชจ๋ธ๋ง ๊ณผ์ ์์์ attribute๋ Field(์ ์ญ๋ณ์member variable)๋ก ์ ์ํ๊ณ , behavior๊ธฐ๋ฅ ๋ฐ ํ์๋ Method๋ก ์ ์ํ๋ค.
Field
String name = “ํ๊ธธ๋”;
String job = “์์ ”;
int help = 0;
Method
public void rent() {
}
public void service() {
}
~~bean
application~~
3.์ธ์คํด์ ์์ฑ๊ณผ ์ฌ์ฉ : main Method ๋ด๋ถ์์ new๋ผ๋ keyword๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด์ Field, Method์ ์ ๊ทผํ๋ค. ⇒class์ ์ค์ฒดํ
Java์ class ์ข ๋ฅ
Application class
⇒ Main method๋ฅผ ๊ฐ์ง๋ฉด์ ์คํ์ํจ๋ค. (์คํ์ ์ํ ์๋จ)
bean class๋ฅผ ์คํ์ํค๊ธฐ ์ํ ๊ฒ!
Bean class
⇒ Real world๋ฅผ ํํํ๋ค. = Object Modeling
์ํ, ์์ฑ์ ๋ด๊ณ ์๋ Field
ํ์๋ฅผ ๋ํ๋ด๋ method ๋ฅผ ํฌํจํ๋ค.
bean class ์์ฒด๋ก๋ ์คํ๋์ง ์๋๋ค !
Class๋
ํ๋์์ ์ง์ ๋ชจ๋ ๊ฐ์ ๊ตฌ์ฒดํ ํ๋ฉด ๊ฐ์ฒด๊ฐ ์๊ฒจ๋ ๋๋ง๋ค ์์ ํ๊ฑฐ๋ ๋ง๋ค์ด์ค์ผํ๋ค.
๋ฐ๋ผ์ ํ๋ ๊ฐ์ ๊ตฌ์ฒดํ ์ํค์ง ์๊ณ Setter method๋ฅผ ์ฌ์ฉ ํ๋ค.
๊ณตํต๋ ํน์ฑ, ์์ฑ, ํ์์ ์๋ฏธ๋ฅผ ๊ฐ๋ ๋ชจ์์ด๋ค.
ํด๋์ค → ์ธ์คํด์คํ → ๊ฐ์ฒด ์์ฑ
ํด๋์ค๋ก๋ถํฐ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๊ณผ์ ์ ‘์ธ์คํด์คํ’ ํ๋ค๊ณ ๋งํ๋ค. (๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ๋ค.)
ํด๋์ค๋ก๋ถํฐ ๋ง๋ค์ด์ง ‘๊ฐ์ฒด’๋ฅผ ‘์ธ์คํด์ค’๋ผ ํ๋ค.
ํด๋์ค๋ก๋ถํฐ ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ
'ํด๋์ค๋ช ๋ณ์๋ช = new ํด๋์ค๋ช ();'⇒ ํด๋์ค ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ธฐ ์ํ ๋ณ์ ์ ์ธ
User user = new User();⇒ new :์๋ก์ด ์ธ์คํด์ค ์์ฑ ⇒ ํด๋์ค๋ช ();: ์์ฑ์ ์์ฑ
์ธ์คํด์ค๋ฅผ ๋ณ์์ ์ฐธ์กฐํ์ฌ ์ ์ฅํ๋ค.
Method
behavior ⇒ Method ํ์, ๋์, ๊ธฐ๋ฅ
ํ์ํ Data๋ฅผ ๋๊ธฐ๊ณ ๊ฒฐ๊ณผ Data๋ฅผ ๋ฐ์ ์ ์๋ค. ๊ฐ์ฒด ๊ฐ Data๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์๋ ์๋จ์ด๋ค.
Incomeup(){
Income++
System.out.println("์์
์ด ์ฆ๊ฐํ์์ต๋๋ค.");
}
method๋ ์ผ์ข ์ ํจ์์ ๊ฐ๋ค !
*getter Method: ์ํ๊ฐ์ return ํ๋ ๋ฉ์๋์ด๋ค. encapsulation ๋ ์ํ๊ฐ์ ์ ๊ทผํ ์ ์๊ฒ ํด์ค๋ค.
instance๊น์ง์ ๊ณผ์
๋ณด๋๋ง์นด๋ผ๋ ๊ฐ์ฒด๋ฅผ ์ถ์ํ ํ์ฌ ๊ฒ์์๋ณด๋๋ง์นด ๋ผ๋ ํด๋์ค๋ฅผ(Bean) ๋ง๋ ๋ค.
์ํ, ์์ฑ ์ ๋ณด ⇒ Field
ํ์ ⇒ method
์ํ๋ ์์ฑ ์ ๋ณด๊ฐ ๋ด๊ธด ๊ฒ์์๋ณด๋๋ง์นด ๋ผ๋ ํด๋์ค๋ฅผ ์คํํ๊ธฐ ์ํด์
main method๋ฅผ ๋ฃ์ด ๊ฒ์์๋ณด๋๋ง์ปค์ฌ์ฉ์ดํ๋ฆฌ์ผ์ด์ ์ด๋ผ๋ ํด๋์ค๋ฅผ(application)์ ๋ง๋ค์ด๋ธ๋ค.
๋ง์ฝ ‘์ฒญ์๋ณด๋๋ง์นด’๋ ๋ง๋ค์ด์ผํ๋ฉด bean ํด๋์ค๋ฅผ ๋ ๋ง๋ค์ด์ฃผ์ด์ผํ๋ค.
ํ๋ ๊ฐ์ ๋งค๋ฒ ์ง์ ๊ตฌ์ฒดํ ์ํค์ง ์๊ณ Setter method๋ฅผ ์ฌ์ฉํ๋ค.
์ถ์ํ ์์
๊ณตํต๋ ํน์ฑ์ด๋ ํ์๋ฅผ ์ถ์ถํด์ ํด๋์ค๋ฅผ ๋ง๋๋ ๊ฒ
์ถ์ํ ์์ค์ด ๋๋ค = ์ผ๋ฐํ๊ฐ ์๋๋ค
object =====⇒ | ์ถ์ํ ์์ | class ===⇒ | instance(์ค์ฒดํ) |
(๊ฐ์ฒด) | Field(attribute) method(behavior) ๊ณตํต์ ์ธ ์์ฑ์ด๋ ํน์ฑ ๋ฐ ํ์๋ฅผ ์ถ์ถํด๋ธ๋ค. |
class๋ฅผ ์ฌ์ฉํ๋ ๋จ๊ณ |
๊ฒ์์๋ณด๋๋ง์นด → ๊ฒ์์๋ณด๋๋ง์นด์ฌ์ฉ → ์ฒญ์๋ณด๋๋ง์นด → ๋ณด๋๋ง์นด / ์์ผ๋ก ์ ์ฐจ ์ดํดํ ๊ฒ .
Encapsulation ์บก์ํ
๊ณต๊ฐ์ ์ธ interface๋๋ก ๊ตฌํ์ ์จ๊ธด๋ค.
๊ตฌํ์ ์จ๊ธฐ๋ ์ ์ฐจ ์๋ ⇒ ์ฌ์ฉ์์๊ฒ๋ ์ฌ์ฉ ๋ฐฉ๋ฒ๋ง open
๊ฐ์ฒด์ ์ ๋ณด๋ฅผ ์จ๊ธฐ๋ information hiding ⇒ ๊ฐ์ฒด์ ์ค์ํ ์ ๋ณด(์ํ์ ๋ณด) openํ์ง ์๋๋ค.
๊ฐ์ฒด์งํฅ์ reference
๋๋ฌผ(์์)
๋๋ฌผ a = new ๋๋ฌผ
์ฌ๋(ํ์)
์ฌ๋ b = new ์ฌ๋
- ๋๋ฌผ a = new ์ฌ๋ ⇒ ๊ฐ๋ฅ ํ์๋ ์์๋ฅผ ์ฐธ์กฐํ ์ ์๋ค. (ํฌ๊ธฐ๊ฐ ์์ ๊ฒ์ ํฌ๊ธฐ๊ฐ ํฐ๊ฒ์ ๋ค์ด๊ฐ ์ ์์)
- ์ฌ๋ b = new ๋๋ฌผ ⇒ ๋ถ๊ฐ๋ฅ ์์๋ ํ์๋ฅผ ์ฐธ์กฐํ ์ ์๋ค. (ํฌ๊ธฐ๊ฐ ํฐ ๊ฒ์ ์์ ๊ฒ์ ๋ค์ด๊ฐ ์ ์์!)
๐ก ๊ฐ์ฒด์งํฅ์์๋ ์๋ฌต์ casting์ ๊ฐ๋ ์ ํฌ๊ธฐ๊ฐ ์์ ๊ฒ์์ ํฐ ๊ฒ์ผ๋ก ๋ณํ์ด ๋๋ค !
Polymorphism ๋คํ์ฑ
๋์ผํ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก ํ๋ค.
Method Overloading / Method Overriding
A ๊ธฐ๋ฅ ————————————
-a ๊ธฐ๋ฅ
-b ๊ธฐ
-c๊ธฐ๋ฅ
a, b, c ๋ชจ๋ A ๊ธฐ๋ฅ ์ ํ์ด๋ค. ⇒ ~is a ~ ๊ด๊ณ ์ฑ๋ฆฝ ⇒ ์์๋ ํ์ ๋์ ์ฌ์ฉํ ์ ์๋ค !
A
๊ธฐ๋ฅ c
a
๊ธฐ๋ฅc
b
๊ธฐ๋ฅ c
c
๊ธฐ๋ฅ c
⇒ A = new a / new b / new c ๋ชจ๋ ๊ฐ๋ฅํ๋ค. ํ์๋ ์์๋ฅผ ์ฐธ์กฐํ ์ ์๋ค!
Method syntax
method = behavior = message
- getter method
- getname()
- getAdd()
- getAllInformation() ←๋ฐฐ์ด
๊ธฐํ
ex) ์ฌ๋ด์์คํ ๋ชจ๋ธ๋ง
- Field ์ด๋ฆ, ์ง๊ธ, ์๊ธ, ์ฌ๋ฒ… ⇒ Static
- Method ์ผํ๋ค, ์ถ์ฅ๊ฐ๋ค… ⇒ Dynamic
⇒ Object Modeling
๋ณ์์ ์ธ๋ง ํด์ฃผ๊ณ ๊ฐ์ ์ง์ ์ํด์ค๋ค๋ฉด?
- boolean a; ⇒ default ๊ฐ์ด false์ด๋ค.
- int a; ⇒ default ๊ฐ์ด 0์ด๋ค.