객체 지향 프로그래밍의 4가지 특징과 5가지 원칙

🎯 객체 지향 프로그래밍(OOP)

객체 지향 프로그래밍(Object-Oriented Programming, OOP)은 소프트웨어를 객체 단위로 구성하고, 객체 간의 관계를 정의하여 프로그래밍하는 방식으로, 유지보수성과 확장성을 높이고 코드를 더 직관적이고 재사용 가능하게 만든다.

 

클래스 : 객체를 생성하기 위한 틀(설계도)

객체: 클래스에서 생성된 실체(Instance)로, 메모리에 할당되어 실제 동작하는 단위

	클래스	객체
정의	객체를 만들기 위한 틀	클래스에서 생성된 실체
메모리	메모리에 할당되지 않음	메모리에 할당됨
역할	속성과 동작을 정의	속성과 동작을 실제로 가짐
예제	Car 클래스	myCar = new Car("Hyundai", 100);

 

그리고 객체와 클래스는 다음과 같은 관계를 만족한다.

 

• 클래스를 먼저 정의한 후 객체를 생성해야 함
• 클래스 하나로 여러 개의 객체를 생성할 수 있음
• 객체는 클래스에서 정의한 속성과 메서드를 가짐

class Dog {
    String name;
    
    Dog(String name) {
        this.name = name;
    }
    
    void bark() {
        System.out.println(name + "가 멍멍 짖는다");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("바둑이");
        Dog dog2 = new Dog("코코");

        dog1.bark(); // 바둑이가 멍멍 짖는다
        dog2.bark(); // 코코가 멍멍 짖는다
    }
}

 

 

 

🎯 객체 지향 프로그래밍의 4가지 특징 

1️⃣ 캡슐화(Encapsulation)

객체의 속성과 행동을 하나로 묶고 외부에서 직접 접근하지 못하도록 보호하는 기법으로, 데이터 무결성을 유지하고, 코드 변경 시 영향을 최소화할 수 있다.

private 접근 제어자를 사용하여 데이터 은닉 후, getter/setter를 제공한다.

 

다음 코드에서는 데이터를 보호하면서, deposit()과 withdraw() 메서드를 통해서만 접근할 수 있도록 한다.

class BankAccount {
    private double balance; // 계좌 잔액 (private으로 보호)

    public BankAccount(double balance) {
        this.balance = balance;
    }

    // getter
    public double getBalance() {
        return balance;
    }

    // setter (안전한 입출금을 위해)
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
        account.withdraw(300);
        System.out.println(account.getBalance()); // 1200.0
    }
}

 

 

2️⃣ 상속(Inheritance)

부모 클래스의 속성과 메서드를 자식 클래스가 물려받아 사용할 수 있도록 하는 기능이다.

extends 키워드를 사용하여 부모 클래스를 상속할 수 있다.

 

다음 코드에서는 Dog 클래스가 Animal 클래스를 상속받아 makeSound()를 사용할 수 있다.

class Animal {
    void makeSound() {
        System.out.println("강쥐가 소리를 냅니다.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("멍멍!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 부모 클래스의 메서드 사용
        dog.bark(); // 자식 클래스의 메서드 사용
    }
}

 

 

3️⃣ 다형성(Polymorphism)

하나의 메서드나 객체가 다양한 형태로 동작할 수 있도록 하는 기능이다.

코드의 유연성을 증가시키고, 객체 교체가 용이하며 메서드 오버로딩(Overloading), 메서드 오버라이딩(Overriding)을 사용하면 된다.

 

다음 코드는 Animal 타입 변수에 Cat 객체를 넣었지만, makeSound()가 Cat 클래스의 메서드를 호출하는 메서드 오버라이딩이 적용된 것이다.

class Animal {
    void makeSound() {
        System.out.println("냥이가 소리를 냅니다.");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("야옹!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Cat(); // 다형성 적용
        myAnimal.makeSound(); // "야옹!" 출력 (Cat의 메서드 호출)
    }
}

 

 

4️⃣ 추상화(Abstraction)

불필요한 세부정보를 숨기고 필요한 정보만을 드러내는 것을 말한다.

abstract 키워드를 사용하여 추상 클래스 및 인터페이스를 정의한다.

abstract class Animal {
    abstract void makeSound(); // 추상 메서드 (구현 X)
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("멍멍!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // "멍멍!" 출력
    }
}

 

 

 

 

🎯 객체 지향 프로그래밍의 5가지 원칙

SOLID 원칙은 객체 지향 프로그래밍에서 유지보수성과 확장성을 높이기 위한 5가지 설계 원칙이다.
이 원칙을 따르면 결합도를 낮추고 응집도를 높여 유지보수가 용이한 코드를 만들 수 있다.

 

1️⃣ 단일 책임 원칙 (SRP: Single Responsibility Principle)

클래스는 단 하나의 책임만 가져야 한다.
하나의 클래스는 하나의 역할만 담당해야 하며, 변경이 필요한 이유도 하나만 존재해야 한다.

 

다음은 SRP원칙을 위반한 예시이다.

ReportManager 클래스가 보고서 생성, 출력, 저장까지 모든 책임을 가지고 있어 유지보수가 어려울 수 있다.

class ReportManager {
    public void generateReport() {
        // 보고서 생성 로직
    }

    public void printReport() {
        // 보고서 출력 로직 (프린터 관련)
    }

    public void saveToFile() {
        // 파일 저장 로직
    }
}

 

다음처럼 각 클래스가 하나의 역할(책임)만 수행하도록 분리할 때 SRP를 만족하게 된다.

class ReportGenerator {
    public void generateReport() {
        // 보고서 생성 로직
    }
}

class ReportPrinter {
    public void printReport() {
        // 보고서 출력 로직
    }
}

class ReportSaver {
    public void saveToFile() {
        // 파일 저장 로직
    }
}

 

 

2️⃣ 개방-폐쇄 원칙 (OCP: Open-Closed Principle)

소프트웨어 요소는 확장에는 열려 있어야 하고, 수정에는 닫혀 있어야 한다.
즉, 기존 코드를 수정하지 않고도 기능을 확장할 수 있도록 설계해야 함을 의미한다.

 

다음은 OCP를 위반한 예시이다.

결제 방식이 추가될 때마다 if-else문을 수정해야 하므로 수정이 자주 일어나게 된다.

class PaymentProcessor {
    public void processPayment(String type) {
        if (type.equals("creditCard")) {
            System.out.println("Processing credit card payment");
        } else if (type.equals("paypal")) {
            System.out.println("Processing PayPal payment");
        }
    }
}

 

하지만 다음처럼 수정하면 새로운 결제 방식이 추가되어도 기존 코드를 수정하지 않고 새 클래스를 추가하며 확장이 가능하다.

interface Payment {
    void pay();
}

class CreditCardPayment implements Payment {
    public void pay() {
        System.out.println("Processing credit card payment");
    }
}

class PayPalPayment implements Payment {
    public void pay() {
        System.out.println("Processing PayPal payment");
    }
}

class PaymentProcessor {
    public void processPayment(Payment payment) {
        payment.pay();
    }
}

 

 

 

3️⃣ 리스코프 치환 원칙 (LSP: Liskov Substitution Principle)

자식 클래스는 부모 클래스를 대체할 수 있어야 한다.
즉, 부모 클래스를 사용하는 곳에서 자식 클래스를 넣어도 정상적으로 동작해야 한다는 것이다.

 

LSP를 위반한 예시는 다음과 같다.

Rectangle을 기대하고 Square를 사용했을 때 예상과 다르게 동작할 가능성이 있기 때문이다.

class Rectangle {
    protected int width, height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;  // 정사각형은 너비와 높이가 같아야 함
    }

    @Override
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

 

다음과 같이 Rectangle과 Square를 Shape 인터페이스로 분리하면 대체 가능성이 유지되며 LSP를 만족하게 된다.

interface Shape {
    int getArea();
}

class Rectangle implements Shape {
    protected int width, height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

class Square implements Shape {
    private int side;

    public Square(int side) {
        this.side = side;
    }

    public int getArea() {
        return side * side;
    }
}

 

 

4️⃣ 인터페이스 분리 원칙 (ISP: Interface Segregation Principle)

클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 한다.
즉, 인터페이스를 세분화하여 꼭 필요한 메서드만 제공해야 함을 의미한다.

 

다음은 ISP 위반 예시로 Developer는 eat() 메서드가 필요 없는데도 구현해야 한다.

interface Worker {
    void work();
    void eat();
}

class Developer implements Worker {
    public void work() {
        System.out.println("코딩 중...");
    }

    public void eat() {
        // 개발자는 식사를 하지 않을 수도 있음 (불필요한 메서드 구현)
    }
}

 

다음과 같이 인터페이스를 분리해주면 ISP를 만족한다.

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Developer implements Workable {
    public void work() {
        System.out.println("코딩 중...");
    }
}

class Employee implements Workable, Eatable {
    public void work() {
        System.out.println("업무 수행 중...");
    }

    public void eat() {
        System.out.println("점심 식사 중...");
    }
}

 

 

5️⃣ 의존 역전 원칙 (DIP: Dependency Inversion Principle)

고수준 모듈은 저수준 모듈에 의존하면 안 되며 둘 다 추상화에 의존해야 한다.

 

DIP를 위반한 예시는 다음과 같고 Application이 MySQLDatabase에 강하게 결합되어 있다.

class MySQLDatabase {
    public void connect() {
        System.out.println("MySQL 데이터베이스 연결");
    }
}

class Application {
    private MySQLDatabase database = new MySQLDatabase(); // 직접 의존

    public void start() {
        database.connect();
    }
}

 

하지만 다음과 같이 인터페이스(Database)에 의존하도록 바꾸면 DIP를 만족한다.

interface Database {
    void connect();
}

class MySQLDatabase implements Database {
    public void connect() {
        System.out.println("MySQL 데이터베이스 연결");
    }
}

class Application {
    private Database database;

    public Application(Database database) {
        this.database = database;
    }

    public void start() {
        database.connect();
    }
}