[정리] 객체지향의 4가지 특징

객체지향에는 4가지 특징이 있다.

 

1. 캡슐화

캡슐화는 캡슐처럼 감싼다고 해서 캡슐화이다.

우리가 먹는 알약을 떠올리면 알약안에 있는 성분은 모르지만 그 효과는 알고 있다.

이처럼 안의 내용을 숨기면서 동작하는 것이 캡슐화이다.

public class Main {
    public static void main(String[] args) {
        Capsule capsule = new Capsule();
        String randomString = capsule.getRandomString();
    }
}

나는 getRandomString이라는 메소드 이름을 보고 랜덤으로 문자열을 주는구나 생각하고 메소드를 실행시켰다.

여기서 나는 어떻게 랜덤으로 값을 뽑아주는지 모르고 결과값만을 받게 된다.

설령 아래와 같이 임의로 값을 뽑아줄수도 있지만 private으로 설정이 되어있기 때문에 안을 들여다 볼 수 없다.

public class Capsule{
    public String getRandomString(){
        String a = randomString();
        String b = randomString2();
        return superRandomString(a,b);
    }
    private String randomString() {
        return "A";
    }
    private String randomString2() {
        return "B";
    }
    private String superRandomString(String a, String b) {
        return "C";
    }
}

 

이처럼 캡슐화는 서로 연관있는 기능을 하나의 캡슐로 만들어 외부로부터 데이터를 보호하는 것이다.

 

 

 

2. 추상화

추상화는 여러 객체들이 공통적으로 사용하는 기능을 하나에 정의하고 돌려쓰는것이다.

예를 들어 나는 사람이라는 객체와 원숭이라는 객체를 만들었다.

Person person =  new Person();
Monkey monkey = new Monkey();

사람과 원숭이는 둘다 숨을 쉬고 걸어다닐 수 있다.

그래서 숨쉬기, 걸어다니기를 하나의 인터페이스로 만들어 준 후 이를 참조하려고 한다.

public interface action{
    void breath();
    void walking();
}

사람과 원숭이는 위 인터페이스를 구현하여 숨쉬기와 걷기를 할 수 있다.

class Person implements action{
    @Override
    public void breath() {
        System.out.println("사람이 숨쉰다");
    }
    @Override
    public void walking(){
        System.out.println("사람이 걷는다");
    }
}

위와 같이 한번 정의한 기능을 Override로 덮어써서 사람의 특성에 맞게 재정의 할 수 있다.

 

이처럼 추상화는 여러 객체를 고려하여 기능을 정의하고 각 특성에 맞게 사용하는 것이다.

3. 다형성

다형성이란 하나의 부모로부터 많은 자식이 있는 것이다.

예를 들면 나는 ArrayList로 로직을 다 짜놓았다.

ArrayList<String> list = new ArrayList<>();
ArrayList<String> list2 = (ArrayList<String>) list.clone();

위와 같은 코드를  신나게 다 짜놓았더니 갑자기 정책이 바뀌었다면서  ArrayList를 Stack으로 바꿔야 한단다.

Stack은 clone이라는 메소드를 가지고 있지 않다.

그래서 처음부터 코드를 뒤집어 엎어야 한다.

 

이와 같은 상황을 유연하게 대처하기 위해 다형성이라는 특징이 있다.

만약 내가 ArrayList를 List 객체로 만들었다면 코드를 엎을일은 없을것이다.

List<String> list = new ArrayList<>();

왜냐하면 이렇게 선언을 하면 ArrayList가 가지고 있는 메소드를 이용하는게 아니라 List가 가지고 있는 메소드를 이용하기 때문이다.

위 ArrayList 부분만 Stack으로 바꿔주면 자연스러운 교체가 가능하다.

List<String> list = new Stack<>();

 

List 타입의 객체로 유연함을 얻은 대신 List는 가지고 있지 않고 ArrayList, Stack 만이 가지고 있는 메소드는 사용하지 못하게 된다.

 

이처럼 다형성은 한 타입의 참조변수를 통해 여러 타입의 객체를 참조할 수 있도록 만든것 이다.

4. 상속성

상속성이란 상속을 통해 다른 객체의 특성을 물려받는 것이다.

예를 들어 친구가 나에게 콜라를 사줬고 나는 마시는 방법을 알지 못하지만 친구는 알고 있다.

class Friend {
    int coke = 100;
    public void drinkingCoke(int quantity){
        coke -= quantity;
    }
}

친구가 옆에서 콜라를 마시자 나도 그 행동을 똑같이 따라했다.

class Me extends Friend{}

이를 상속이라고 한다.

나는 가진것도 없었고 마실수도 없었지만 친구의 속성을 물려받아 콜라를 마실수 있게 되었다.

public class Main {
    public static void main(String[] args) {
        Friend friend = new Friend();
        friend.drinkingCoke(50);
        Me me = new Me();
        me.drinkingCoke(50);
    }
}

이처럼 상속은 부모 객체의 속성과 메소드를 물려받아 사용할 수 있게 되는 것이다.

 

참고

https://www.codestates.com/blog/content/%EA%B0%9D%EC%B2%B4-%EC%A7%80%ED%96%A5-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-%ED%8A%B9%EC%A7%95