1.2.2 Object Oriented Programming

1.2.2 객체지향 프로그래밍

1. 객체지향 프로그래밍 개요

객체지향 프로그래밍(OOP, Object-Oriented Programming)은 컴퓨터 프로그래밍 패러다임 중 하나로, 데이터와 해당 데이터를 처리하는 방법을 하나의 객체로 묶어서 표현하는 방법론입니다. 이는 데이터 중심의 절차적 프로그래밍과 달리, 프로그램을 독립된 객체들의 상호작용으로 구성합니다. OOP는 코드 재사용성, 확장성, 유지보수성 등에서 많은 장점을 제공하며, 현재 널리 사용되고 있는 프로그래밍 패러다임입니다.

2. 객체지향 프로그래밍의 기본 개념

2.1 클래스(Class)와 객체(Object)

클래스는 객체를 생성하기 위한 청사진 또는 설계도로, 객체가 가져야 할 속성과 메서드를 정의합니다. 객체는 클래스에서 정의한 속성과 메서드를 실제로 구현한 실체입니다. 예를 들어, '자동차'라는 클래스를 정의하면, 실제로 존재하는 '내 차', '네 차' 등이 객체가 됩니다.

예시

다음은 자바로 작성된 클래스와 객체의 예시입니다.

public class Car {
    // 속성 (필드)
    String color;
    String model;

    // 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    // 메서드
    public void drive() {
        System.out.println("The " + color + " " + model + " is driving.");
    }
}

// 객체 생성
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("red", "Tesla Model S");
        myCar.drive();
    }
}

위 코드에서 Car 클래스는 색상(color)과 모델(model)이라는 두 가지 속성을 가지며, drive라는 메서드를 정의하고 있습니다. Main 클래스에서 Car 객체 myCar를 생성하고 drive 메서드를 호출합니다.

2.2 추상화(Abstraction)

추상화는 불필요한 세부 사항을 숨기고, 중요한 정보만을 나타내는 개념입니다. 프로그래밍에서는 객체의 복잡성을 줄이고, 사용자에게 필요한 기능만을 제공하도록 합니다.

예를 들어, 자동차 클래스에서 엔진의 내부 작동 방식을 숨기고, 운전자가 필요한 기능만 제공하는 것과 같습니다.

2.3 캡슐화(Encapsulation)

캡슐화는 객체의 속성과 메서드를 하나로 묶고, 일부를 외부에서 접근하지 못하도록 하는 것을 의미합니다. 이를 통해 객체의 데이터를 보호하고, 유지보수를 용이하게 합니다.

다음은 캡슐화를 활용한 예시입니다.

public class Person {
    // private 필드
    private String name;
    private int age;

    // public 메서드
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

위 예시에서 Person 클래스는 name과 age 필드를 private로 선언하여 외부에서 직접 접근할 수 없도록 했습니다. 대신 getName, setName, getAge, setAge 메서드를 통해 간접적으로 접근하도록 했습니다.

2.4 상속(Inheritance)

상속은 기존 클래스의 속성과 메서드를 새로운 클래스가 물려받아 사용하는 개념입니다. 이를 통해 코드의 재사용성을 높이고, 새로운 기능을 추가하거나 기존 기능을 수정할 때 유용합니다.

예시

다음은 자바에서 상속을 사용하는 예시입니다.

// 부모 클래스
public class Animal {
    public void eat() {
        System.out.println("This animal is eating.");
    }
}

// 자식 클래스
public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog is barking.");
    }
}

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

위 코드에서 Dog 클래스는 Animal 클래스를 상속받아 eat 메서드를 물려받았으며, 자체적으로 bark 메서드를 추가로 정의했습니다.

2.5 다형성(Polymorphism)

다형성은 동일한 인터페이스나 부모 클래스를 통해 여러 다른 클래스가 각각 다른 방식으로 동작할 수 있게 하는 기능입니다. 이를 통해 객체 간의 상호작용을 보다 유연하게 설계할 수 있습니다.

예시

다음은 다형성을 활용한 예시입니다.

// 부모 클래스
public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

// 자식 클래스 1
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

// 자식 클래스 2
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.makeSound(); // Some sound
        myDog.makeSound();    // Bark
        myCat.makeSound();    // Meow
    }
}

위 예시에서 Animal 클래스는 makeSound 메서드를 가지고 있으며, 이를 상속받은 Dog와 Cat 클래스는 각각의 방식으로 makeSound 메서드를 오버라이딩(재정의)했습니다. Main 클래스에서 각 객체의 makeSound 메서드를 호출하면, 해당 객체의 메서드가 실행됩니다.

3. 객체지향 설계 원칙 (SOLID 원칙)

객체지향 프로그래밍에서 좋은 소프트웨어를 설계하기 위해 SOLID 원칙을 따르는 것이 중요합니다. SOLID 원칙은 다섯 가지 기본 원칙으로 구성됩니다.

3.1 단일 책임 원칙 (Single Responsibility Principle, SRP)

모든 클래스는 단 하나의 책임만 가져야 한다는 원칙입니다. 이를 통해 클래스의 변경 이유를 하나로 줄여, 유지보수를 쉽게 할 수 있습니다.

3.2 개방-폐쇄 원칙 (Open/Closed Principle, OCP)

소프트웨어 요소는 확장에는 열려 있어야 하고, 변경에는 닫혀 있어야 한다는 원칙입니다. 즉, 기존 코드를 수정하지 않고도 기능을 추가할 수 있어야 합니다.

3.3 리스코프 치환 원칙 (Liskov Substitution Principle, LSP)

자식 클래스는 언제나 자신의 부모 클래스를 대체할 수 있어야 한다는 원칙입니다. 이를 통해 상속 구조에서의 일관성을 유지할 수 있습니다.

3.4 인터페이스 분리 원칙 (Interface Segregation Principle, ISP)

특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫다는 원칙입니다. 이를 통해 클라이언트에 꼭 필요한 메서드만 인터페이스로 제공할 수 있습니다.

3.5 의존 역전 원칙 (Dependency Inversion Principle, DIP)

고수준 모듈은 저수준 모듈의 구현에 의존해서는 안 되며, 추상화에 의존해야 한다는 원칙입니다. 이를 통해 모듈 간의 결합도를 낮추고 유연성을 높일 수 있습니다.

4. 객체지향 프로그래밍의 장점과 단점

4.1 장점

1. 코드 재사용성: 기존 클래스와 객체를 재사용하여 새로운 프로그램을 쉽게 만들 수 있습니다.

2. 유지보수 용이성: 코드가 구조화되어 있어 수정과 확장이 용이합니다.

3. 모듈화: 각 객체가 독립적으로 동작하여 모듈화가 용이합니다.

4.2 단점

1. 복잡성: 객체지향 설계는 초기 설계 단계에서 시간이 많이 소요될 수 있습니다.

2. 성능 저하: 객체 간의 상호작용이 빈번하게 발생할 경우 성능 저하가 발생할 수 있습니다.

5. 결론

객체지향 프로그래밍은 데이터와 기능을 객체라는 단위로 묶어 관리함으로써 코드의 재사용성, 유지보수성, 확장성을 높이는 강력한 프로그래밍 패러다임입니다. 클래스와 객체, 추상화, 캡슐화, 상속, 다형성 등의 기본 개념을 이해하고, SOLID 원칙을 준수하는 설계를 통해 높은 품질의 소프트웨어를 개발할 수 있습니다.