객체 지향 프로그래밍의 활용 방안

절차 지향 프로그래밍(Procedural Programming)

절차 지향 프로그래밍이란?

절차 지향 프로그램의 한계

• 유지 보수의 어려움

• 엄격한 순서

객체지향 프로그래밍(Object-Oriented Programming)

객체 지향 프로그램이란?

클래스(Class)와 인스턴스(Instence)

클래스 ⇒ (Car)

• 클래스는 붕어빵 틀과 유사합니다.

• 붕어빵 틀은 붕어빵을 만들기 위한 설계도로, 클래스는 객체를 생성하기 위한 설계도입니다.

• 클래스는 속성(멤버 변수)과 메서드(함수)를 정의하여 객체가 가져야 할 구조와 행동을 명시합니다.

객체 ⇒ (Bmw, Voikswagen, Audi)

• 객체는 붕어빵 틀을 통해 만들어진 실제 붕어빵과 같이, 클래스를 기반으로 생성된 실체입니다.

• 각 객체는 클래스에서 정의한 속성과 메서드를 가지며, 실제로 실행될 수 있는 인스턴스입니다.

• 예를 들어, 클래스가 "Car"일 때, "Bmw", "Voikswagen", "Audi"는 이 클래스의 객체로서, 각각의 차량을 나타냅니다.

클래스 객체 그리고 인스턴스

// 클래스 정의 (Car)
class Car {
  constructor(brand, model) {
    this.brand = brand; // 속성(멤버 변수)
    this.model = model;
  }

// 객체 생성 (Bmw, Voikswagen, Audi)
const bmw = new Car("Bmw", "X5");
const volkswagen = new Car("Volkswagen", "Golf");
const audi = new Car("Audi", "A4");

클래스

객체

인스턴스

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

장점

1. 협업에 용이함

1. 대형 프로젝트에 적합

1. 유지보수 용이

1. 코드 재사용성 용이

단점

1. 개발속도가 느림

1. 실행속도가 느림

1. 코딩의 난이도 상승

1. 용량 문제

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

캡슐화(Encapsulation)

캡슐화 예시

class Car {
  // 캡슐화된 필드
  #speed = 0;

  // 캡슐화된 메서드
  #validateSpeed(newSpeed) {
    if (newSpeed < 0 || newSpeed > 200) {
      console.log("Invalid speed");
      return false;
    }
    return true;
  }

  // 외부에서 속도 설정하는 메서드
  setSpeed(newSpeed) {
    if (this.#validateSpeed(newSpeed)) {
      this.#speed = newSpeed;
      console.log(`Current speed: ${this.#speed} km/h`);
    }
  }

  // 외부에서 현재 속도 조회하는 메서드
  getSpeed() {
    console.log(`Current speed: ${this.#speed} km/h`);
  }
}

// 객체 생성
const myCar = new Car();

// 외부에서 속도를 직접 설정할 수 없음
// myCar.#speed = 100; // 에러 발생

// 메서드를 통해 속도 설정
myCar.setSpeed(120); // 유효한 값이므로 설정됨

// 메서드를 통해 현재 속도 조회
myCar.getSpeed(); // "Current speed: 120 km/h"

javaCopy code
public class Car {
    private int speed;  // private으로 선언된 변수

    // 메소드를 통한 간접 접근
    public void setSpeed(int newSpeed) {
        if (newSpeed >= 0 && newSpeed <= 200) {
            this.speed = newSpeed;
        } else {
            System.out.println("Invalid speed");
        }
    }

    public int getSpeed() {
        return this.speed;
    }
}

추상화(Abstraction)

추상화 예시

class Car {
  #fuel;      // 연료
  #speed;     // 속도
  #direction; // 방향

  // 추상화된 동작 1
  constructor() {
    this.#fuel = 100;
    this.#speed = 0;
    this.#direction = 'forward';
  }

  // 추상화된 동작 2
  accelerate() {
    this.#speed += 10;
  }

  // 추상화된 동작 3
  turn(direction) {
    this.#direction = direction;
  }
}

// 추상화된 동작을 통해 자동차 객체 생성
const myCar = new Car();

// 추상화된 동작을 호출하여 가속 및 방향 전환
myCar.accelerate();        // 일정 속도로 가속
myCar.turn('left');        // 좌회전

상속(Inheritance)

상속 예시

class Car {
  #fuel;      // 연료
  #speed;     // 속도
  #direction; // 방향

  constructor() {
    this.#fuel = 100;
    this.#speed = 0;
    this.#direction = 'forward';
  }

  accelerate() {
    this.#speed += 10;
  }

  turn(direction) {
    this.#direction = direction;
  }
}

class ElectricCar extends Car {
  #battery;   // 배터리 용량

  constructor() {
    super();  // 부모 클래스의 생성자 호출
    this.#battery = 100;
  }

  // 추가된 동작
  charge() {
    this.#battery += 10;
  }
}

// 전기차 객체 생성
const myElectricCar = new ElectricCar();

// 상속된 동작 호출
myElectricCar.accelerate();  // 전기차도 가속 가능

// 새로 추가된 동작 호출
myElectricCar.charge();      // 전기차만 충전 가능

다형성(Polymorphism)

오버라이딩(Overriding)

class Car {
  startEngine() {
    console.log('일반 엔진 시작');
  }
}

class ElectricCar extends Car {
  startEngine() {
    console.log('전기 엔진 시작');
  }
}

const myCar = new ElectricCar();
myCar.startEngine();  // 전기 엔진 시작

오버로딩(Overloading)

class Car {
  drive() {
    console.log('주행 시작');
  }

  drive(speed) {
    console.log(`속도 ${speed}km/h로 주행 시작`);
  }
}

const myCar = new Car();
myCar.drive();        // 주행 시작
myCar.drive(100);     // 속도 100km/h로 주행 시작

다형성의 장점

• 코드의 간결성

• 재사용성

• 확장성

글을 마치며

Reference