# 객체지향 프로그래밍 (Objected Oriented Programming)

- OOP = Objected Oriented Programming = 객체지향 프로그래밍
- 여러가지 프로그래밍 패러다임 중 하나
- 목적 : 사람이 생각하는 방식과 유사하게 프로그래밍 할 수 있도록 하자!
- 절차지향 프로그래밍이 너무 어렵고 힘들어서 나온 개념
- 프로그램을 구성하는 기본 요소를 객체로 보고 하는 객체들이 서로 상호작용을 하여 프로그램이 돌아가게 만들려는 **노력**
- 노력인 이유 : 결과적으로 프로그램은 기계에서 돌기 때문에 어떤 프로그램이라도 최종적으로는 절차적으로 돌 수 밖에 없다
- 주요 특징은 캡슐화, 상속, 다형성, 추상화이다

> 절차지향 vs 객체지향
>
> 
>
> ---
>
> 

---

# 캡슐화


- 데이터 구조와 데이터를 다루는 방법들을 결합 시켜 묶는 것
- 변수와 함수를 하나로 묶는 것을 뜻함
- 내부의 데이터를 외부로부터 보호
- 접근제어자 (`private`, `default`, `protected`, `public`)
- 접근제어자를 통해 정보은닉을 활용 할 수도 있다
- 정보은닉 : 객체 안에 있는 데이터를 외부로부터 보호
- 보호된 정보에 대해서 `getter`, `setter` 메서드를 만들어 접근 가능하게 하곤 한다
- 사용자가 클래스 속을 알 필요가 없음
- 사용자가 함수 속을 알 필요가 없는 것과 마찬가지
- 이 개념은 추상화로 이어진다
- 함수를 분리할 때 적용했던 원칙을 클래스에서도 적용할 것
- 중복된 코드가 있다면 `private` 메서드로 분리
- 실용적인 용도 : 사용자측의 변경 없이 구현부를 변경할 수 있게 해준다

> **접근제어자**
> |접근 제어자|같은 클래스의 멤버|같은 패키지의 멤버|자식 클래스의 멤버| 그 외의 영역 |
> |---|---|---|---|---|
> |public|○|○|○|○|
> |protected|○|○|○|X|
> |default|○|○|X|X|
> |private|○|X|X|X|

---

> **getter/setter**
>
> 함수를 통한 데이터 접근의 객관적인 장범
>
> 1. 멤버 변수를 저장하지 않고 필요할 때마다 getter에서 계산 가능
> 2. setter에서 추가적인 로직을 실행할 수 있음
> 3. 상속을 통한 다형성 구현 가능

## 캡슐화 예시

public class Person {
    private String name; // private : 외부에서 접근 불가
    private int age;  // private : 외부에서 접근 불가

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);
        // person.age = 30; // 컴파일 에러
        System.out.println(person.getName() + " is " + person.getAge() + " years old.");
    }
}

# 상속


- 이미 존재하는 객체를 기반으로 확장된 객체를 만드는 방법
- 엄밀히 말하면 객체가 아니라 클래스
- 거의 모든 사람이 OOP 핵심이라 여기는 특성
- 특히, 재사용성이 궁극의 목적이라 신봉하던 시대에 특히
- 현재에도 상속을 지원하지 않으면 OO 언어라고 안 보는게 보통
- OOP의 또 다른 매우 중요한 특성인 **다형성의 기반**
- 한 번에 모든 구체적인 사항을 만들지 말고 점진적으로 기능을 확장시켜 나갈 수 있게 해준다
- 사람에게는 점진적 학습이 가장 효율적이다
- 확장된 객체
- 기존의 객체에 속한 데이터와 동작을 모두 물려받음 (유전)
- 여기에 다른 데이터나 동작을 추가할 수 있음 (진화)
- 물론 새클래스를 상속해서 또 다른 새 클래스를 만들 수 있음
- 실용적인 용도 : 코드 중복을 막음
- 여러 객체에는 공통되는 데이터와 동작을 부모 객체로 만듦
- 여러 객체는 각각 그 부모 객체를 상속 받음
- 그 후 자기에게만 필요한 데이터나 동작을 추가

## super 키워드

- super는 현 개체의 부모 부분을 가리킴
- super() 라고 코드를 작성하면 부모의 생성자를 호출
- 멤버 변수나 메서드를 호출할 때도 가능

| `this` | `super` |
|---|---|
|현재 객체를 가리킴|현재 객체의 부모를 가리킴|
|현재 객체의 멤버 변수나 메서드를 호출|현재 객체의 부모의 멤버 변수나 메서드를 호출|
|생성자에서 다른 생성자를 호출할 때 사용|생성자에서 부모의 생성자를 호출할 때 사용|

## 상속의 단점

- 상속은 부모 클래스와 자식 클래스 사이의 결합도를 높인다
- 자식 클래스가 부모 클래스의 내부 구현에 의존하게 만든다
- 부모 클래스의 내부 구현을 바꾸면 자식 클래스도 함께 바꿔야 한다

## 상속 예시

public class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

public class Korean extends Person {
    public Korean(String name, int age) {
        super(name, age);
    }

    public void setName(String name) {
        if (name.length() < 2) {
            System.out.println("잘못된 이름입니다.");
            return;
        }
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age > 200) {
            System.out.println("잘못된 나이입니다.");
            return;
        }
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Korean korean = new Korean("홍길동", 30);
        System.out.println(korean.getName() + " is " + korean.getAge() + " years old."); // 기능 상속
        korean.setName("김철수"); // 기능 확장
        System.out.println(korean.getName() + " is " + korean.getAge() + " years old.");
    }
}

## Object 클래스

- Java의 클래스는 모두 Object로부터 상속을 받는다
- 따라서 Object에 있는 메서드들은 어떤 클래스에서도 오버라이딩이 가능하다. 대표적으로 `toString()`이 있다.

- **`toString()`**
- 사람이 읽기 편하게 해당 개체를 문자열로 표현
- Object클래스 안의 기본 구현
- `getClass().getName() + "@" + Integer.toHexString(hashCode())`
- Java 공식 문서는 모든 클래스에서 이 메서드를 오버라이딩 하라고 권장한다 (하지만 잘 하지 않는 편이다)

- **`hashCode()`**
- 어떤 개체를 비교하는 해시값을 32 비트 정수로 반환한다
- 동치인 두 개체는 해시값이 같다
- 동치가 아닌 두 개체도 해시값이 같을 수 있다 (해시 충돌)
- Java의 Object클래스 안의 기본 구현은 개체의 주소를 반환하도록 되어있다.
- 주 목적은 Java가 자체 제공하는 HashMap클래스에서 사용하기 위함이다
- 키(key) 로 사용하는 개체의 해시값이 필요하기 때문
- 덕분에 빠른 비교용으로 사용 가능하다
- 단 두 개체가 같지 않다는 것만 빠르게 판단 가능하다 (해시코드가 같아도 두 개체는 다를 수 있기 때문)

- **`equals()`**
- 동치 비교를 위한 메서드
- 아무런 구현이 없다면 단순한 주소를 비교한다
- 일일이 데이터를 비교하지 않는다
- 클래스마다 같다는 의미가 다를 수 있기 때문이다.
- 클래스 속 데이터를 비교해야한다면 오버라이딩이 필요하다
- 이때 hashCode()도 반드시 같이 오버라이딩 해야 한다
- **equals 와 hashCode 메서드는 재정의를 같이 하거나 둘 다 하지 않거나 해야한다**
- 둘 중 하나만 오버라이딩 하면 동치성 비교에 문제가 생긴다
- equals는 같다고 판단하고 hashCode는 다르다고 판단할 수 있기 때문

# 다형성


- 많은 사람들이 OOP의 핵심이라고 여기는 특징
- 같은 지시를 내렸는데 다른 종류의 객체가 동작을 달리 하는 것
- 같은 지시 : 동일한 함수 시그내처 호출
- 달리 동작 : 객체의 종류에 따라 실제로 실행되는 함수 구현 코드가 다름
- 절차적 언어에서 이런 일을 하려면 `if`문을 사용해야 했음
- 어떤 함수 구현이 실행될지는 실행 중에 결정됨
- 이를 늦은 바인딩이라고 함 (late binding)
- 일반적인 함수 호출은 이른 바인딩 (컴파일 중에 결정됨)
- 다형성의 혜택을 받으려면 상속 관계가 필요
- 부모 객체에서 함수 시그내처를 선언
- 자식 객체에서 그 함수를 다르게 구현 (overriding)
- 실용적인 용도
- 다른 종류의 객체를 편하게 저장 및 처리 가능

## 다형성의 장점

- 각 자료형의 코드가 클래스 안에 들어가서 캡슐화
- 유지 보수성 높아짐
- 새로운 클래스를 추가할 때 클래스 코드만 추가하면 됨
- 클라이언트가 작성할 코드가 줄어듦


다형성을 통해 조건문의 사용 없이 코드 구현이 가능하다. 그렇기 때문에 조건문을 사용하면 OO가 아니라고 주장하는 사람이 있다. (조건문 대신 모든 것을 다형성으로 바꿔야 한다고 한다) 하지만 다형성이 조건문을 모두 대체하기는 어렵고, 설사 가능하더라고 그렇게 해야할 이유가 없다.

## 이른 바인딩 / 늦은 바인딩

- 이른 바인딩
- 정적 바인딩(static binding)이라도 한다
- 어떤 함수 구현을 호출해야 할지가 빌드 중에 결정된다
- 따라서 함수 호출문을 바로 jmp 명령어로 교체 가능하다
- jmp하는 주소는 그 함수의 어셈블리어 코드가 시장되는 메모리 주소
- C에서 이게 가능한 이유는 다형성을 지원하지 않기 때문
- 늦은 바인딩
- 동적 바인딩(dynamic binding)이라고도 한다.
- 호출되는 메서드 구현이 프로그램 실행 중에 결정된다
- 다형성은 늦은 바인딩이다

> 사실 C에 없는 기능은 하드웨어에 없다. 그렇기 때문에 사실 C에도 늦은 바인딩이 있다. 바로 **함수 포인터**다. 함수 포인터를 직접 전달하는 방식으로 늦은 바인딩을 구현할 수 있다.
>
> Java는 이 함수포인터 같은 기능을 편하게 사용할 수 있도록 해준것이다. Java에만 있는 기능은 C의 기능들을 조합해서 만든 것이기 때문에 C에서 이 기능이 아주 없다고 단정짓지 않아야 한다. (마찬가지로 Java도 final을 사용하여 이른바인딩이 가능하다.)
>
> 

## 오버라이딩(Overriding)

- 하위 클래스가 이미 상위 클래스에 정의된 메서드의 자체 구현을 제공할 수 있도록 하는 기능
- 오버라이딩 된 메서드를 호출 시 부모 클래스 구현 대신 자식 클래스 구현이 실행된다
- 하위 클래스 메서드에서 `@Override` 어노테이션을 명시적으로 사용하여 오버라이딩 메서드임을 명시할 수 있다

> 어노테이션 (Annotation)
>
> - Java 5부터 추가된 기능
> - 클래스, 메서드, 변수 등에 부가적인 정보를 제공하는 기능
> - 컴파일러에게 코드 문법 에러를 체크하도록 정보를 제공
> - 실행 시 특정 기능을 실행하도록 정보를 제공
> - `@Override`, `@Deprecated`, `@SuppressWarnings` 등이 있다

### 오버라이딩 vs 오버로딩

- 오버라이딩 : 부모 클래스의 함수를 재정의 하는 기능
- 오버로딩 : 동일한 이름을 가진 여러 메서드를 클래스에 정의할 수 있는 기능
- 이름은 같지만 매개변수가 다른 여러 메소드를 가질 수 있도록 하는 기능
- 자바는 매개변수 타입, 개수, 순서가 다르면 다른 메서드로 인식한다
- 메서드가 오버로드되면 Java는 전달된 인수의 수와 유형에 따라 실행할 메서드를 결정한다
- 입력에 따라 다른 작업을 수행할 수 있는 보다 유연하고 재사용 가능한 코드를 만들 수 있게 하는 기능

| 오버라이딩 | 오버로딩 |
|---|---|
|상속 관계에 있는 클래스 사이에서 발생|상속 관계에 있는 클래스 사이에서 발생하지 않음|
|하위 클래스에서 상위 클래스의 메서드를 재정의|하나의 클래스 안에서 같은 이름의 메서드가 여러 개 존재|
|하위 클래스에서 오버라이딩된 메서드를 호출하면 오버라이딩된 메서드가 실행|오버로딩된 메서드를 호출하면 인자의 타입에 따라 다른 메서드가 실행|

## 타입 캐스트 (Type Cast)

- 타입 캐스트는 객체의 타입을 변환하는 것을 의미한다
- 객체를 다른 타입으로 취급한다는 것을 의미
- 상속 관계에 있는 클래스들 사이에서는 타입 캐스트가 가능하다
- 묵시적 타입 캐스트 : 자식 클래스를 부모 클래스로 변환
- 범위가 더 넓은 타입으로 변환
- 명시적 타입 캐스트 : 부모 클래스를 자식 클래스로 변환
- 범위가 더 좁은 타입으로 변환

## 다형성 예시

public class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    public void setName(String name) {
        if (name.length() < 2) {
            System.out.println("잘못된 이름입니다.");
            return;
        }
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age > 200) {
            System.out.println("잘못된 나이입니다.");
            return;
        }
        this.age = age;
    }

    // 오버라이딩
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Korean extends Person {
    public Korean(String name, int age) {
        super(name, age);
    }

    // 오버라이딩
    @Override
    public String toString() {
        return "Korean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

> 만 나이를 사용하지 않는다고 가정하고, Korean 클래스에서는 나이를 한 살 더 먹은 것처럼 보이게 하고 싶다면?
>
> ```java
> //
> public class Korean extends Person {
> int age; // Person 클래스의 age와 다른 변수
>
> public Korean(String name, int age) {
> super(name, age);
> this.age = super.age + 1; // 부모 클래스의 age와 자식 클래스의 age를 구분하기 위해 this, super 키워드 사용
> }
>
> // 오버라이딩
> @Override
> public String toString() {
> return "Korean{" +
> "name='" + name + '\'' +
> ", age=" + age +
> '}';
> }
>
> @Override
> public void setAge(int age) {
> if (age < 1 || age > 200) {
> System.out.println("잘못된 나이입니다.");
> return;
> }
> this.age = age + 1;
> }
>
> @Override
> public int getAge() { return age; }
> }
> ```

public class American extends Person {
    public American(String name, int age) {
        super(name, age);
    }

    // 오버라이딩
    @Override
    public String toString() {
        return "American{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Korean korean = new Korean("홍길동", 30);
        American american = new American("John", 25); // 묵시적 타입 캐스트 (자식 -> 부모)

        Person[] people = new Person[2];
        people[0] = korean; // 묵시적 타입 캐스트 (자식 -> 부모)
        people[1] = american;

        for (Person person : people) {
            String str = person.toString(); // toString() 오버라이딩 (늦은 바인딩)
            System.out.println(str);
        }

        // 명시적 타입 캐스트 (부모 -> 자식)
        Korean korean2 = (Korean) people[0];
        American american2 = (American) people[1];

        System.out.println(korean2);
        System.out.println(american2);
    }
}

---

# 추상화


- OOP에서 추상화란 어떤 구체적인 것에 직접 손대지 않겠다는 것을 의미
- 객체 속에 있는 실제 데이터나 함수 구현 방법에 종속되지 않겠다는 뜻
- 데이터 추상화
- 객체 사용 시 그 안에 정확히 어떤 데이터가 있는지 알 필요 없음
- 객체 안에 있는 데이터에 접근 불가
- 그 대신 객체의 함수를 통해 접근
- 즉, 캡슐화는 추상화를 이루는 방법 중 하나
- 실용적인 용도 : 설계와 구현의 분리
- 추상 자료형쪽 관점
- 사용자는 클래스를 자료형으로 사용할 수 있음
- 그 클래스 안에 들어있는 멤버 변수가 정확히 뭔지 몰라도 됨
- 절차적 데이터 추상화쪽 관점
- 데이터를 직접 조작하는 대신 메서드를 호출

## 추상 클래스

- 구체적이지 않은 클래스
- 미완성 설계도
- '추상화'를 클래스에 접목시켜, 추상화의 기능을 강제하는 클래스
- 특징
- 공통 멤버의 통합으로 중복 제거
- 구현의 강제성을 통한 기능 보장
- 설계와 구현의 분리
- 추상 클래스는 클래스의 일종이라고 하지만 `new` 생성자를 통해 인스턴스 객체로 직접 만들 수 없다
- 하지만, 추상 클래스의 생성자를 전혀 이용 못하는 것은 아니다. 직접적인 인스턴스화가 불가능 하다 뿐이지, `super()` 메소드를 이용해 추상 클래스 생성자 호출이 가능하다

### 추상 클래스 기본 문법


- 자바에서는 `abstract` 키워드를 클래스명과 메서드명 옆에 붙임으로서 컴파일러에게 추상 클래스와 추상 메서드임을 알려주게 된다.
- 추상 메서드 : 구현 내용은 없고 이름만 껍데기만 있는 메서드라고
- 일반적으로 하나 이상의 추상 메소드를 포함하는 클래스를 가리켜 추상 클래스라고 정의하곤 한다.
- 추상 클래스 안의 메서드를 미완성으로 남겨놓는 이유는 추상 클래스를 상속받는 자식 클래스의 주제에 따라서 상속 받는 메서드의 내용이 달라질 수 있기 때문
- 상속을 통해서 자식 클래스에서 완성하도록 유도

## 추상화의 단점

- 동작 없이 데이터만 있는 클래스는 쓸데없는 코드만 늘어남
- 어떻게 추상화를 해야할 지 뚜렷한 객관적 기준이 없음

---

## 예시 코드

public abstract class Person { // 추상 클래스
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }

    public abstract void speak(); // 추상 메서드 (미완성 메서드)

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Korean extends Person {
    public Korean(String name, int age) {
        super(name, age);
    }

    @Override
    public void speak() {
        System.out.println("안녕하세요! 저는 한국인입니다.");
    }

    @Override
    public String toString() {
        return "Korean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class American extends Person {
    public American(String name, int age) {
        super(name, age);
    }

    @Override
    public void speak() {
        System.out.println("Hello! I am an American.");
    }

    @Override
    public String toString() {
        return "American{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        // Person person = new Person("John", 25); // 컴파일 에러. 추상 클래스는 직접 인스턴스화 불가능
        Person korean = new Korean("홍길동", 30);
        Person american = new American("John", 25);

        Person[] people = new Person[2];
        people[0] = korean;
        people[1] = american;

        for (Person person : people) {
            System.out.println(person);
            person.speak();
        }
    }
}