객체지향 프로그래밍

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 프로그램을 객체들의 모임으로 보는 프로그래밍 패러다임입니다.

객체지향이란?

실세계의 사물이나 개념을 객체로 모델링하고, 이러한 객체들 간의 상호작용을 통해 프로그램을 구현하는 방식입니다.

주요 특징

•

코드의 재사용성이 높음

•

유지보수가 용이함

•

대규모 소프트웨어 개발에 적합

•

신뢰성 있는 소프트웨어를 개발하기 쉬움

객체지향 4대 특징

캡슐화

상속

다형성

추상화

1. 캡슐화 (Encapsulation)

데이터와 코드를 하나의 단위로 묶어 외부에서의 접근을 제한하는 것입니다. 객체의 속성과 행위를 하나로 묶고, 실제 구현 내용 일부를 외부에 감추어 은닉합니다.

자바에서의 캡슐화 구현

•

접근 제어자 (Access Modifier): private, protected, public, default를 사용하여 클래스 멤버에 대한 접근 범위를 제한합니다.

•

private 멤버 변수: 클래스의 속성(필드)을 private으로 선언하여 외부에서 직접 접근을 막습니다.

•

Getter 메서드: private 멤버 변수의 값을 읽을 수 있게 해주는 public 메서드입니다.

public String getName() {
    return this.name;
}
Java
복사

•

Setter 메서드: private 멤버 변수의 값을 설정할 수 있게 해주는 public 메서드입니다.

public void setName(String name) {
    this.name = name;
}
Java
복사

이러한 방식으로 데이터를 보호하고, 잘못된 값이 설정되는 것을 방지할 수 있으며, 클래스의 내부 구현을 숨길 수 있습니다.

2. 상속 (Inheritance)

기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것입니다. 상위 클래스의 특성을 하위 클래스가 물려받아 재사용하거나 추가, 확장하는 것을 말합니다.

자바에서의 상속 구현

자바에서는 extends 키워드를 사용하여 클래스 상속을 구현합니다.

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("barking...");
    }
}
Java
복사

단일 상속과 다중 상속

•

단일 상속: 자바는 클래스의 다중 상속을 지원하지 않습니다. 한 클래스는 오직 하나의 클래스만 상속받을 수 있습니다.

•

인터페이스를 통한 다중 상속: 하나의 클래스는 여러 개의 인터페이스를 구현(implement)할 수 있습니다.

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("flying...");
    }
    
    public void swim() {
        System.out.println("swimming...");
    }
}
Java
복사

이러한 방식으로 자바는 클래스 상속의 단순성을 유지하면서도 인터페이스를 통해 다중 상속의 이점을 제공합니다.

3. 다형성 (Polymorphism)

하나의 메서드나 클래스가 다양한 방법으로 동작하는 것을 말합니다. 오버로딩과 오버라이딩을 통해 구현됩니다.

메소드 오버로딩 (Method Overloading)

같은 이름의 메소드를 매개변수의 타입이나 개수를 다르게 하여 여러 개 정의하는 것입니다.

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
}
Java
복사

메소드 오버라이딩 (Method Overriding)

상위 클래스에서 정의한 메소드를 하위 클래스에서 재정의하는 것입니다.

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof woof!");
    }
}
Java
복사

오버라이딩된 메소드는 상위 클래스의 메소드와 동일한 이름, 매개변수, 반환 타입을 가져야 하며, @Override 어노테이션을 사용하여 명시적으로 표시할 수 있습니다.

4. 추상화 (Abstraction)

복잡한 자료, 모듈, 시스템 등으로부터 핵심적인 개념 또는 기능을 간추려 내는 것을 말합니다.

자바에서의 추상화 구현

•

추상 클래스 (Abstract Class): abstract 키워드를 사용하여 선언하며, 구현부가 없는 추상 메소드를 포함할 수 있습니다.

abstract class Animal {
    abstract void makeSound(); // 추상 메소드
    
    void eat() { // 일반 메소드
        System.out.println("eating...");
    }
}
Java
복사

•

인터페이스 (Interface): 완전한 추상화를 구현하는 방법으로, 모든 메소드가 추상 메소드입니다.

interface Vehicle {
    void start();
    void stop();
    void accelerate();
}
Java
복사

인터페이스를 구현하는 클래스는 반드시 모든 추상 메소드를 구현해야 합니다:

class Car implements Vehicle {
    public void start() {
        System.out.println("Car starting");
    }
    
    public void stop() {
        System.out.println("Car stopping");
    }
    
    public void accelerate() {
        System.out.println("Car accelerating");
    }
}
Java
복사

•

추상화의 장점:

•

공통된 특성을 하나로 묶어 복잡성을 줄일 수 있습니다.

•

코드의 재사용성과 유지보수성이 향상됩니다.

•

구현의 독립성을 보장합니다.

객체지향 5대 원칙 (SOLID)

원칙	원칙 이름	핵심 개념
SRP	단일 책임 원칙 (Single Responsibility Principle)	한 클래스는 하나의 책임만 가져야 함
OCP	개방-폐쇄 원칙 (Open-Closed Principle)	확장에는 열려있고, 수정에는 닫혀있어야 함
LSP	리스코프 치환 원칙 (Liskov Substitution Principle)	하위 타입은 상위 타입으로 대체 가능해야 함
ISP	인터페이스 분리 원칙 (Interface Segregation Principle)	클라이언트는 사용하지 않는 메서드에 의존하지 않아야 함
DIP	의존관계 역전 원칙 (Dependency Inversion Principle)	추상화에 의존해야 하며, 구체화에 의존하면 안됨

1. 단일 책임 원칙 (Single Responsibility Principle)

한 클래스는 하나의 책임만 가져야 합니다.

2. 개방-폐쇄 원칙 (Open-Closed Principle)

소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 합니다.

3. 리스코프 치환 원칙 (Liskov Substitution Principle)

프로그램의 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야 합니다.

4. 인터페이스 분리 원칙 (Interface Segregation Principle)

특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫습니다.

5. 의존관계 역전 원칙 (Dependency Inversion Principle)

추상화에 의존해야지, 구체화에 의존하면 안됩니다.

SOLID 원칙의 중요성

SOLID 원칙이란 객체지향 설계에서 지켜줘야 할 5개의 소프트웨어 개발 원칙(SRP, OCP, LSP, ISP, DIP)을 말합니다. 이 원칙들은 객체 지향 프로그래밍의 단골 면접 질문 중 하나일 뿐만 아니라, 앞으로 배우게 될 여러 디자인 패턴(Design Pattern)들의 근간이 됩니다.

좋은 설계란 무엇인가?

본래 좋은 소프트웨어란 변화에 대응을 잘 하는 것을 말합니다. 좋은 설계란 시스템에 새로운 요구사항이나 변경사항이 있을 때, 영향을 받는 범위가 적은 구조를 말합니다.

예를 들어 갑자기 고객사가 기획에 없는 추가적인 요청을 하면, 비록 어려움이 있더라도 결국 구현을 해야 합니다. 이러한 변화에 큰 애로사항 없이 잘 대응하기 위해선 소프트웨어 설계의 근간이 탄탄해야 합니다.

SOLID 원칙의 이점

•

코드 확장성 향상: 새로운 기능을 추가할 때 기존 코드를 수정하지 않고도 확장할 수 있습니다.

•

유지 보수 용이성: 코드가 명확하게 분리되어 있어 특정 부분을 수정할 때 다른 부분에 영향을 미치지 않습니다.

•

복잡성 감소: 불필요한 복잡성을 제거해 코드를 더 이해하기 쉽게 만듭니다.

•

개발 생산성 향상: 리팩토링에 소요되는 시간을 줄임으로써 프로젝트 개발의 생산성을 높입니다.

각 원칙 상세 설명

1. 단일 책임 원칙 (SRP)

클래스는 단 하나의 책임만 가져야 하며, 클래스를 변경하는 이유는 오직 하나뿐이어야 합니다.

예: 사용자 클래스가 있다면, 사용자 정보 관리만 담당해야 하며 로깅이나 네트워크 통신 같은 다른 책임은 별도의 클래스로 분리해야 합니다.

2. 개방-폐쇄 원칙 (OCP)

소프트웨어 엔티티(클래스, 모듈, 함수 등)는 확장에 대해서는 열려 있어야 하지만, 수정에 대해서는 닫혀 있어야 합니다.

새로운 기능을 추가할 때 기존 코드를 수정하지 않고도 시스템을 확장할 수 있어야 합니다. 이는 주로 추상화와 다형성을 통해 구현됩니다.

3. 리스코프 치환 원칙 (LSP)

상위 타입의 객체를 하위 타입의 객체로 치환해도 프로그램의 정확성이 깨지지 않아야 합니다.

하위 클래스는 상위 클래스의 행동 규약을 모두 지켜야 합니다. 예를 들어, 직사각형을 상속받은 정사각형 클래스가 있다면, 직사각형의 모든 메서드가 정사각형에서도 동일하게 작동해야 합니다.

4. 인터페이스 분리 원칙 (ISP)

클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 합니다.

큰 인터페이스 하나보다는 여러 개의 작은 인터페이스가 더 좋습니다. 이를 통해 클라이언트는 필요한 메서드만 구현하면 됩니다.

5. 의존관계 역전 원칙 (DIP)

고수준 모듈은 저수준 모듈에 의존하지 않아야 합니다. 둘 다 추상화에 의존해야 합니다.

구체적인 클래스보다는 인터페이스나 추상 클래스와 같은 추상화에 의존해야 합니다. 이는 시스템의 결합도를 낮추고 유연성을 높입니다.

실제 적용 사례

// 나쁜 예: 단일 책임 원칙 위반
class User {
    private String name;
    private String email;
    
    // 사용자 정보 관련 메소드
    public void saveUser() { /* 데이터베이스에 저장 */ }
    
    // 이메일 관련 메소드 (다른 책임)
    public void sendEmail(String message) { /* 이메일 전송 */ }
}

// 좋은 예: 단일 책임 원칙 준수
class User {
    private String name;
    private String email;
    
    // 사용자 정보 관련 메소드만 포함
    public void saveUser() { /* 데이터베이스에 저장 */ }
}

class EmailService {
    // 이메일 관련 기능만 담당
    public void sendEmail(User user, String message) { /* 이메일 전송 */ }
}
Java
복사

SOLID 원칙은 코드의 품질을 높이고, 유지보수성과 확장성을 향상시키는 핵심 가이드라인입니다. 이 원칙들을 잘 이해하고 적용하면 더 나은 객체지향 소프트웨어를 설계할 수 있습니다.