- ์๋์ฐ, ๋งฅOS, ๋ฆฌ๋ ์ค ๋ฑ ๋ชจ๋ ์ด์์ฒด์ ์์ ์คํ ๊ฐ๋ฅ
- ๋ฉ๋ชจ๋ฆฌ(RAM)๋ฅผ ์๋ ์ ๋ฆฌํด ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ์ฉ์ด
- ๋ฌด๋ฃ๋ก ๋ค์ด๋ก๋ํด์ ์ฌ์ฉํ ์ ์๋ ์คํ ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ(Open source Library)๊ฐ ํ๋ถ
- ๋จผ์ ๊ฐ์ฒด(๋ถํ)๋ฅผ ๋ง๋ค๊ณ , ๊ฐ์ฒด๋ค์ ์๋ก ์ฐ๊ฒฐํด์ ๋ ํฐ ํ๋ก๊ทธ๋จ์ ์์ฑ์ํค๋ ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ (OOP)์ ์ต์ ํ๋ ์ธ์ด
1) ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ(Object-Oriented Programming, OOP)์ด๋
- ๊ฐ์ฒด๋ฅผ ๋จผ์ ๋ง๋ค๊ณ ์ด๋ ๊ฒ ๋ง๋ค์ด์ง ์ฌ๋ฌ ๊ฐ์ฒด๋ค์ ์กฐ๋ฆฝํด์ ํ๋์ ์์ฑ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋๋ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ๋ฒ๋ก
- ์ฌ๋ฌ ๋ ๋ฆฝ์ ์ธ ๋ถํ๋ค์ ์กฐํฉ, ์ฆ ๊ฐ์ฒด๋ค์ ์ ๊ธฐ์ ์ธ ํ๋ ฅ๊ณผ ๊ฒฐํฉ์ผ๋ก ํ์ ํ๊ณ ์ ํ๋ ์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ์ ํจ๋ฌ๋ค์
(1) ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ฅ์
- ๊ฐ์ฒด ์งํฅ์ ์ค๊ณ๋ฅผ ํตํด ํ๋ก๊ทธ๋จ์ ๋ณด๋ค ์ ์ฐํ๊ณ ๋ณ๊ฒฝ์ด ์ฉ์ดํ๊ฒ ๋ง๋ค ์ ์๋ค
์ ) ์ปดํจํฐ ๋ถํ์ ๊ฐ์ ๋ผ์ธ ๋, ํด๋นํ๋ ๋ถํ๋ง ์ฝ๊ฒ ๊ต์ฒดํ๊ณ ๋๋จธ์ง ๋ถํ๋ค์ ๊ฑด๋๋ฆฌ์ง ์์๋ ๋๋ ๊ฒ์ฒ๋ผ ์ํํธ์จ์ด๋ฅผ ์ค๊ณํ ๋ ๊ฐ์ฒด ์งํฅ์ ์๋ฆฌ๋ฅผ ์ ์ ์ฉํด ๋ ํ๋ก๊ทธ๋จ์ ๊ฐ๊ฐ์ ๋ถํ๋ค์ด ๊ฐ์์ ๋ ๋ฆฝ์ ์ธ ์ญํ ์ ๊ฐ์ง๊ธฐ ๋๋ฌธ์ ์ฝ๋์ ๋ณ๊ฒฝ์ ์ต์ํํ๊ณ ์ ์ง๋ณด์๋ฅผ ํ๋ ๋ฐ ์ ๋ฆฌํ๋ค.
- ๋ ๋ฆฝ์ ์ธ ์ญํ ์ ๊ฐ๊ฐ์ ๋ถํ์ ์ฌ์ฌ์ฉํด ๋ฐ๋ณต์ ์ฝ๋๋ฅผ ์ต์ํํด ์ฝ๋๋ฅผ ์ต๋ํ ๊ฐ๊ฒฐํ๊ฒ ํํํ ์ ์๋ค.
- ์ค์ ์ฐ๋ฆฌ๊ฐ ๋ณด๊ณ ๊ฒฝํํ๋ ์ธ๊ณ๋ฅผ ์ต๋ํ ํ๋ก๊ทธ๋จ ์ค๊ณ์ ๋ฐ์ํ๊ธฐ ์ํ ๋ ธ๋ ฅ์ ํตํด ๋ฐ์ ํด์๊ธฐ ๋๋ฌธ์, ๋ณด๋ค ์ธ๊ฐ ์นํ์ ์ด๊ณ ์ง๊ด์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ์ ์ฉ์ดํ๋ค.
(2) ๊ฐ์ฒด (Object)
- ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋จ์์ด์ ์์์
- ์ค์ ์ธ๊ณ๋ ๊ฐ์ฒด๋ค๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ ๋ณด์ฌ์ง๋ ํ์๊ณผ ์ฌ๊ฑด์ ๊ฐ์ฒด๋ค๊ฐ์ ์ํธ์์ฉ์ ํตํด ๋ฐ์ํ๋ค๋ ์ ์ ์์ ์ถ๋ฐ
- ๋ชจ๋ ์ค์ฌํ๋ ๋์ ( ์ฐ๋ฆฌ ๋์ ๋ณด์ด๋ ์ ํ์ ๋์๊ณผ ๋์ ๋ณด์ด์ง ์๋ ์ด๋ค ๋ ผ๋ฆฌ, ์ฌ์, ์ฒ ํ, ๊ฐ๋ , ๊ณต์ ๋ฑ๊ณผ ๊ฐ์ ๋ฌดํ์ ๋์๋ค๋ ํฌํจ )
- ์ฐ๋ฆฌ๊ฐ ๋ณด๊ณ ๋๋ผ๊ณ ์ธ์งํ ์ ์๋ ๊ทธ ๋ชจ๋ ๊ฒ
class Car {
// ์์ฑ ์ ์
String company;
String model;
String color;
int wheels;
boolean isConvertible;
// ๊ธฐ๋ฅ ์ ์
void startEngine() {
System.out.println("์ฒด์ธ์ ์ ๊ธ์ ํผ๋ค");
}
void moveForward() {
System.out.println("์์ ๊ฑฐ๊ฐ ์์ผ๋ก ์์ง์ธ๋ค");
}
void moveBackward() {
System.out.println("์์ ๊ฑฐ๊ฐ ๋ค๋ก ์์ง์ธ๋ค");
}
}
- ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์์๋ ๊ฐ์ฒด๋ฅผ ์ถ์ํ์์ผ ์์ฑ(state)๊ณผ ๊ธฐ๋ฅ(behavior)์ผ๋ก ๋ถ๋ฅํ ํ, ๊ฐ๊ฐ ๋ณ์(variable)์ ํจ์(function)๋ก ์ ์ํ๊ณ ์๋ค.
(3) ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ 4๊ฐ์ง ํน์ง
1. ์ถ์ํ(Abstration) : ๊ฐ์ฒด์ ๋ถํ์ํ ์ธ๋ถ ์ฌํญ์ ์ ๊ฑฐํ๊ณ ๊ณตํต์ฑ๊ณผ ๋ณธ์ง์ ์ธ ๋ถ๋ถ์ ๋ชจ์ ์ถ์ถ
2. ์์ (Inheritance) : ๊ธฐ์กด์ ํด๋์ค๋ฅผ ์ฌํ์ฉํ์ฌ ์๋ก์ด ํด๋์ค๋ฅผ ์์ฑํ๋ ๋ฌธ๋ฒ ์์.
์ค๋ณต๋๋ ์ฝ๋์ ๋ฐ๋ณต์ ์ค์ผ ์ ์๋ค.
์์ ํด๋์ค์ extends ํค์๋๋ฅผ ์ด์ฉํด ํ์ฅ ์ํฌ ์ ์์. ์์ ๊ด๊ณ์์๋
๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ (method overriding)์ ์ด์ฉ, ๋ถ๋ชจ ์์์ ์ฝ๋ ์คํ ๋ด์ฉ์ ์ฌ์ ์ ํ ์ ์๋ค.
์์ ๊ด๊ณ์ ๊ฒฝ์ฐ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ๊ตฌํ์ ๋นํด ์ถ์ํ์ ์ ๋๊ฐ ๋ฎ๋ค๊ณ ํ ์ ์๋ค.
โ ์ํฉ์ ๋ฐ๋ผ ๋ชจ๋ ๊ตฌ์ฒด์ ๋ด์ฉ๋ค์ ์ ์ํด๋๊ณ ํ์ ํด๋์ค์์ ๊ทธ๊ฒ์ ๊ฐ์ ธ๋ค ์ฌ์ฌ์ฉ
3. ๋คํ์ฑ : ์ด๋ค ๊ฐ์ฒด์ ์์ฑ์ด๋ ๊ธฐ๋ฅ์ด ๋งฅ๋ฝ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ญํ ์ ์ํํ ์ ์๋ ํน์ฑ (๊ฐ์ฒด ์งํฅ์ ๊ฝ)
์ ) ์ด๋ค ์ค๋ ์ ๋จ์ฑ ... ํ์ฌ์์๋ ๊ณผ์ฅ, ๋์๋ฆฌ์์ ์ด๋ฌด, ๋ถ๋ชจ๋์๊ฒ๋ ์์, ์์์๊ฒ๋ ์๋ฒ์ง ๋ฑ...
๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ๊ณผ ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ด ๋ํ์ ์ธ ์.
man ์ธํฐํ์ด์ค
public interface man {
public abstract void start()
void part(); // public abstract ํค์๋ ์๋ต ๊ฐ๋ฅ
}
man ์ธํฐํ์ด์ค๋ฅผ ์์ ๋ฐ์ atHome ํด๋์ค
public class atHome implements man{ // man์ ๊ตฌ์ฒดํํ ์๋ฐ ํด๋์ค
// implements ์ extends์ ์ฐจ์ด์
// implements๋ ๋ถ๋ชจ์ ๋ฉ์๋๋ฅผ ๋ฐ๋์ ์ค๋ฒ๋ผ์ด๋ฉ(์ฌ์ ์) ํด์ผ ํจ. ๋ค์ค์์ ๊ฐ๋ฅ
// ๋ณดํต implements -> interface ์์ / extends -> class ์์
@Override // ์ด๋
ธํ
์ด์
- ํด๋น ๋ฉ์๋๊ฐ ๋ถ๋ชจ ํด๋์ค์ ์๋ ๋ฉ์๋๋ฅผ override ํ๋ค๋ ๊ฒ์ ์ ์ธ
public void part() { // swTech์์ ์ ์๋ ๋ฉ์๋ ์ฌ์ ์
System.out.println("๊ฐ์ฅ");
System.out.println("์๋น ");
System.out.println("๋จํธ");
}
}
- ๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ, ์ค๋ฒ๋ก๋ฉ๋ ์ค์ํ ์์์ด๋ ๋ ์ค์ํ ๋คํ์ฑ์ ์ ์๋ ํ ํ์ ์ ์ฐธ์กฐ๋ณ์๋ฅผ ํตํด ์ฌ๋ฌ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ ์ ์๋๋ก ๋ง๋ ๊ฒ์ด๋ผ๋ ์๋ฏธ.
(์์ ํด๋์ค ํ์ ์ ์ฐธ์กฐ๋ณ์๋ก ํ์ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ ์ ์๋๋ก ํ๋ ๊ฒ)
4. ์บก์ํ(Encapsulation) : ํด๋์ค ์์ ์๋ก ์ฐ๊ด ์๋ ์์ฑ๊ณผ ๊ธฐ๋ฅ๋ค์ ํ๋์ ์บก์(capsule)๋ก ๋ง๋ค์ด ๋ฐ์ดํฐ๋ฅผ ์ธ๋ถ๋ก๋ถํฐ ๋ณดํธํด ์ธ๋ถ์์ ์ง์ ์ ์ผ๋ก ์ ๊ทผํ๋ ๊ฒ์ ๋ง์๋๊ธฐ ์ํจ. ์ธ๋ถ์์ ๋ง์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ๋ณ๊ฒฝํ๊ฒ ๋๋ฉด ๋ฌด๊ฒฐ์ฑ์ด ๊นจ์ง ์ ์๊ธฐ ๋๋ฌธ์ ์บก์ํ ์์ ์ ํ๋ค. ์๋ฐ ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์์ ์บก์ํ๋ฅผ ํ๋ ์ด์ ๋ ๋ ๊ฐ์ง๋ก ๋๋๋ค.
- ๋ฐ์ดํฐ ๋ณดํธ(data protection) : ์ธ๋ถ๋ก๋ถํฐ ํด๋์ค์ ์ ์๋ ์์ฑ๊ณผ ๊ธฐ๋ฅ๋ค์ ๋ณดํธ
- ๋ฐ์ดํฐ ์๋(data hiding) : ๋ด๋ถ์ ๋์์ ๊ฐ์ถ๊ณ ์ธ๋ถ์๋ ํ์ํ ๋ถ๋ถ๋ง ๋ ธ์ถ
์ธ๋ถ๋ก๋ถํฐ ํด๋์ค์ ์ ์๋ ์์ฑ๊ณผ ๊ธฐ๋ฅ๋ค์ ๋ณดํธํ๊ณ ํ์ํ ๋ถ๋ถ๋ง ์ธ๋ถ๋ก ๋ ธ์ถ๋ ์ ์๋๋ก ํ์ฌ ๊ฐ ๊ฐ์ฒด ๊ณ ์ ์ ๋ ๋ฆฝ์ฑ๊ณผ ์ฑ ์ ์์ญ์ ์์ ํ๊ฒ ์งํค๊ณ ์ ํ๋ ๋ชฉ์ ์ด๋ค.
์บก์ํ ๋ฐฉ๋ฒ 1. ์ ๊ทผ ์ ์ด์(access modifiers)๋ฅผ ํ์ฉํ๋ค.
- ํด๋์ค ๋๋ ํด๋์ค์ ๋ด๋ถ์ ๋ฉค๋ฒ๋ค(๋ฉค๋ฒ๋ณ์, ๋ฉ์๋, ์์ฑ์) ์ ์ฌ์ฉ๋์ด ํด๋น ํด๋์ค๋ ๋ฉค๋ฒ๋ค์ ์ธ๋ถ์์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ์ ํํ๋ค.
- public, default, protected, private ์ ์ด์๋ฅผ ์ด์ฉํด ์ฌ์ฉ (์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ ์๋ก ๋ ์ข์ ์ ๊ทผ ๋ฒ์)
์ ๊ทผ ์ ์ด์ | ํด๋์ค ๋ด | ํจํค์ง ๋ด | ๋ค๋ฅธ ํจํค์ง์ ํ์ ํด๋์ค | ํจํค์ง ์ธ | ์ค๋ช |
private | O | X | X | X | ๋์ผ ํด๋์ค ๋ด์์๋ง ์ ๊ทผ ๊ฐ๋ฅ |
default | O | O | X | X | ๋์ผ ํจํค์ง ๋ด์์๋ง ์ ๊ทผ ๊ฐ๋ฅ |
protected | O | O | O | X | ๋์ผ ํจํค์ง + ๋ค๋ฅธ ํจํค์ง์ ํ์ํด๋์ค์์ ์ ๊ทผ ๊ฐ๋ฅ |
public | O | O | O | O | ์ ๊ทผ ์ ํ ์์ |
packege package1; // ํจํค์ง๋ช
package1
class Test { // Test ํด๋์ค์ ์ ๊ทผ ์ ์ด์๋ default
public static void main(String[] args) {
SuperClass superClass = new SuperClass();
// System.out.println(parent.a); // ๋์ผ ํด๋์ค๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์๋ฌ ๋ฐ์
System.out.println(superClass.b);
System.out.println(superClass.c);
System.out.println(superClass.d);
}
}
public class SuperClass { // SuperClass ํด๋์ค๋ public์ด ์ ๊ทผ ์ ์ด์๋ก ์ฌ์ฉ๋จ
private int a = 1; // private ์ ๊ทผ์ ์ด์
int b = 2;
protected int c = 3; // protected ์ ๊ทผ์ ์ด์
public int d = 4; // public ์ ๊ทผ ์ ์ด์
public void printEach() {
System.out.println(a); // ์ ๊ทผ์ ์ด์ private๊ฐ ๋์ผ ํด๋์ค ๋ด์์๋ง ์ ๊ทผ ๊ฐ๋ฅ
System.out.println(b);
System.out.println(c);
System.out.pringln(d);
}
}
// ์ถ๋ ฅ๊ฐ
2
3
4
์บก์ํ ๋ฐฉ๋ฒ 2. getter/setter ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
- ์ ํ์ ์ผ๋ก ์ธ๋ถ์ ์ ๊ทผ์ ํ์ฉํ ์์ฑ๊ณผ ๊ทธ๋ ์ง ์์ ์์ฑ์ getter/setter๋ฉ์๋๋ฅผ ํตํด ์ค์ ํด์ค๋ค.
- ํ๋ ์ ๋์ฌ๋ก get- , set-์ ์ฌ์ฉํ๋๋ฐ bin ๊ท์ฝ์ด๋ผ๊ณ ํ๋ค.
- getter : ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ค๋ ์ญํ ์ ์ฃผ๋ก ์ํํ๋ฉฐ ์ธ๋ถ์์ ๊ฐ์ฒด์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ ๋๋ ์์ ํ๊ฒ ๊ฐ์ ์ ์งํ ์ ์๋๋ก ์ฌ์ฉํ๋ค.
- setter : private๋ก ์ ์ธ๋ ํ๋์ ๊ฐ์ ์์ ํ๊ณ ์ ํ ๋ ์ฌ์ฉ. ๊ฐ์ฒด๋ ์ ๋ ฅ ๊ฐ์ setter ๋ฉ์๋์ ๋งค๊ฐ ๊ฐ์ผ๋ก ๋๊ฒจ์ฃผ๊ณ ๊ฐ์ ๊ฒ์ฌํ๊ณ ๋์ ๊ทธ ๊ฐ์ด ํ๋์ ๊ฐ์ผ๋ก ์ ์ ํ ๊ฒฝ์ฐ์๋ง ์ ์ฅํ๋ค.
์ฃผ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ๋ ์ญํ ์ ํ๋ค.
1. getter
- ์ ๊ทผ ์ ํ์ : public
- ๋ฆฌํด ํ์ : ํ๋์ ๋ฆฌํด ํ์
- ๋ฉ์๋ ์ด๋ฆ : get + ํ๋ ์ด๋ฆ (์ฒซ ๋ฌธ์๋ ๋๋ฌธ์)
- ๋ฆฌํด๊ฐ : ํ๋ ๊ฐ
2. setter
- ์ ๊ทผ ์ ํ์ : public
- ๋ฆฌํด ํ์ : void
- ๋ฉ์๋ ์ด๋ฆ : set + ํ๋ ์ด๋ฆ(์ฒซ ๋ฌธ์๋ ๋๋ฌธ์)
- ๋งค๊ฐ ๋ณ์ ํ์ : ํ๋ ํ์
public class Car {
private String model; // ํ๋ ์ ๊ทผ ์ ํ์ : private
private String color;
private int int wheels;
public String getModel() { // getter
return model;
}
public void setModel(String model) { // setter
this.model = model;
}
public String getColor() { // getter
return color;
}
public void setColor(String color) { // setter
this.color = color;
}
public int getWheels() { // getter
return wheels;
}
public void setWheels(int wheels) { // setter
this.wheels = wheels;
}
}
- ๋ง์ฝ ํ๋ ํ์ ์ด boolean์ผ ๊ฒฝ์ฐ, getter๋ get์ผ๋ก ์์ํ์ง ์๊ณ is๋ก ์์
1. getter
- ์ ๊ทผ ์ ํ์ : public
- ๋ฆฌํด ํ์ : ํ๋ ํ์
- ๋ฉ์๋ ์ด๋ฆ : is + ํ๋์ด๋ฆ (์ฒซ ๋ฌธ์๋ ๋๋ฌธ์)
- ๋ฆฌํด ๊ฐ : ํ๋ ๊ฐ
2. setter
- ์ ๊ทผ ์ ํ์ : public
- ๋ฆฌํด ํ์ : void
- ๋ฉ์๋ ์ด๋ฆ : set + ํ๋์ด๋ฆ(์ฒซ ๋ฌธ์๋ ๋๋ฌธ์) (boolean ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์์ฑ)
- ๋งค๊ฐ ๋ณ์ ํ์ : ํ๋ ํ์
private boolean stop; // ํ๋ ์ ๊ทผ ์ ํ์ : private
// getter
public boolean inStop() {
return stop;
}
// setter
public void setStop(boolean stop) {
this.stop = stop;
}
'๊ฐ๋ฐ ์ด์ผ๊ธฐ > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java - ๋ณ์ (variable) (0) | 2023.06.29 |
---|---|
Java - System.out.println() (0) | 2023.06.29 |
Java - ๋ค์ด๋ก๋ ๋ฐ ํ๊ฒฝ ๋ณ์ ์ค์ ํ๊ธฐ (0) | 2023.06.28 |
Java - ๊ธฐ๋ณธ ๊ตฌ์กฐ (0) | 2023.06.28 |
Java - ์๋ฐ ํ๋ก๊ทธ๋๋ฐ (0) | 2023.06.28 |